Implemente uma aplicação de forma gradual num destino

Este início rápido mostra como usar o Cloud Deploy para fornecer uma imagem de aplicação de exemplo numa implementação canária no Google Kubernetes Engine ou no Cloud Run. (Também pode executar uma implementação canária em clusters anexados do GKE, mas apenas o GKE e o Cloud Run são apresentados neste início rápido.)

Uma implementação canary divide o tráfego entre uma versão da aplicação já implementada e a nova versão. O Cloud Run distribui o tráfego com base nas percentagens que configurar no pipeline de fornecimento. O GKE implementa a nova versão numa proporção de pods. Este início rápido é implementado primeiro em 50% e, em seguida, em 100%.

Neste início rápido, existe apenas um alvo, (prod). Por isso, criamos apenas um cluster do GKE ou um serviço do Cloud Run para executar a sua aplicação.

Neste início rápido, vai fazer o seguinte:

  1. Crie um cluster do GKE ou defina um serviço do Cloud Run.

    Também pode fazer a implementação canary em clusters anexados do GKE, mas este início rápido usa apenas o GKE e o Cloud Run.

  2. Crie uma configuração do Skaffold e um manifesto do Kubernetes para especificar a imagem de contentor (pré-criada) a implementar.

  3. Defina o pipeline de entrega e o alvo de implementação do Cloud Deploy.

  4. Invoque a sua pipeline de fornecimento criando um lançamento, que é automaticamente implementado num destino.

    Este primeiro lançamento ignora a fase de teste.

  5. Veja o pipeline de fornecimento e o lançamento na Google Cloud consola.

  6. Crie um segundo lançamento, desta vez executando a fase de teste canário para implementar a aplicação em 50%.

  7. Avançar o lançamento para implementação a 100%.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

  7. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  9. Verify that billing is enabled for your Google Cloud project.

  10. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

  11. Install the Google Cloud CLI.

  12. Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

  13. Para inicializar a CLI gcloud, execute o seguinte comando: 

    gcloud init

    14. Se já tiver a CLI instalada, certifique-se de que está a executar a versão mais recente:

    gcloud components update

  14. Certifique-se de que a conta de serviço predefinida do Compute Engine tem autorizações suficientes.

    A conta de serviço pode já ter as autorizações necessárias. Estes passos são incluídos para projetos que desativam as concessões de funções automáticas para contas de serviço predefinidas.

    1. Primeiro, adicione a função clouddeploy.jobRunner: 

      gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/clouddeploy.jobRunner"

    2. Adicione a função de programador para o seu tempo de execução específico.
      • Para o GKE e o GKE com a API Gateway: 

        gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/container.developer"

      • Para o Cloud Run: 

        gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/run.developer"

    3. Adicione a função iam.serviceAccountUser, que inclui a autorização actAspara implementar no tempo de execução:

      gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/iam.serviceAccountUser" \
    --project=PROJECT_ID

    Crie o seu ambiente de tempo de execução

    GKE

    Crie um cluster do GKE Autopilot:

     gcloud container clusters create-auto canary-quickstart-cluster \
                  --project=PROJECT_ID \
                  --region=us-central1

    GKE + API Gateway

    1. Crie um cluster do GKE com as definições recomendadas para suportar a utilização com o Istio:

      gcloud container clusters create canary-quickstart-cluster \
       --machine-type=n1-standard-1 \
       --num-nodes 4 \
       --region=us-central1 \
       --project=PROJECT_ID

    2. Obtenha as credenciais do cluster:

      gcloud container clusters get-credentials canary-quickstart-cluster \
       --project=PROJECT_ID \
       --region=us-central1

    3. Instale os CRDs da API Kubernetes Gateway, se ainda não estiverem presentes no cluster.

      kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v0.6.2/standard-install.yaml

    4. Ative a implementação do controlador de gateway do Istio instalando o Istio.

      curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.17.2 sh - \
&& ./istio-1.17.2/bin/istioctl install --set profile=minimal -y

    Cloud Run

    Se estiver a usar o Cloud Run, pode ignorar este comando. Não tem de fazer nada aqui.

    Prepare a configuração do Skaffold e o manifesto da aplicação

    O Cloud Deploy usa o Skaffold para fornecer os detalhes sobre o que implementar e como o implementar corretamente no seu destino.

    Neste início rápido, cria um ficheiro skaffold.yaml, que identifica a configuração do serviço do manifesto do Kubernetes ou do Cloud Run a implementar.

    1. Abra uma janela de terminal.

    2. Crie um novo diretório e navegue para o mesmo.

      GKE 

      mkdir deploy-canary-quickstart-gke
cd deploy-canary-quickstart-gke

      GKE + API Gateway 

      mkdir deploy-canary-quickstart-gke-gatewayapi
cd deploy-canary-quickstart-gke-gatewayapi

      Cloud Run 

      mkdir deploy-canary-quickstart-run
cd deploy-canary-quickstart-run

    3. Crie um ficheiro denominado skaffold.yaml com o seguinte conteúdo:

      GKE 

      apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

      GKE + API Gateway 

      apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

      Cloud Run 

      apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - run.yaml
deploy:
  cloudrun: {}

      Este ficheiro é uma configuração mínima do Skaffold que identifica o seu manifesto. Para este início rápido, cria o ficheiro. No entanto, também pode pedir ao Cloud Deploy que crie um para si para aplicações simples que não sejam de produção.

      Consulte a referência skaffold.yaml para mais informações acerca deste ficheiro.

    4. Crie o manifesto da aplicação.

      GKE

      Crie um ficheiro denominado kubernetes.yaml no diretório deploy-canary-quickstart-gke com o seguinte conteúdo:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: my-app-image
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: default
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80

      Este ficheiro é um manifesto do Kubernetes, que é aplicado ao cluster para implementar a aplicação. Este manifesto inclui os recursos de serviço e implementação necessários para a implementação canary, além de um HTTPRoute e o recurso de gateway necessário para usar a API Gateway.

      A imagem do contentor a implementar é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando cria a versão.

      GKE + API Gateway

      Crie um ficheiro denominado kubernetes.yaml no diretório deploy-canary-quickstart-gke-gatewayapi com o seguinte conteúdo:

      kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-gateway
  annotations:
    networking.istio.io/service-type: "ClusterIP"
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.example.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
---
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-httproute
spec:
  parentRefs:
  - kind: Gateway
    name: my-gateway
  hostnames:
  - "test.example.com"
  rules:
  - backendRefs:
    - name: my-service
      port: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
  - name: tcp-port
    protocol: TCP
    port: 80
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: my-app-image

      Este ficheiro é um manifesto do Kubernetes, que é aplicado ao cluster para implementar a aplicação. Este manifesto inclui os recursos de serviço e implementação necessários para a implementação canary, além de um HTTPRoute e o recurso de gateway necessário para usar a API Gateway.

      A imagem do contentor a implementar é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando cria a versão.

      Cloud Run

      Crie um ficheiro denominado run.yaml no diretório deploy-canary-quickstart-run com o seguinte conteúdo:

      apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-canary-run-service
spec:
  template:
    spec:
      containers:
      - image: my-app-image

      Este ficheiro é uma definição básica do serviço Cloud Run, que é aplicada no momento da implementação para criar o seu serviço no Cloud Run. A imagem do contentor a implementar é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando cria a versão.

    Crie o pipeline de entrega e as segmentações

    Pode definir o pipeline de entrega e os alvos num ficheiro ou em ficheiros separados. Neste início rápido, criamos um ficheiro para o nosso pipeline e o nosso único destino:

    GKE

    Crie um ficheiro denominado clouddeploy.yaml no diretório deploy-canary-quickstart-gke com o seguinte conteúdo:

    apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            serviceNetworking:
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

    GKE + API Gateway

    Crie um ficheiro denominado clouddeploy.yaml no diretório deploy-canary-quickstart-gke-gatewayapi com o seguinte conteúdo:

    apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            gatewayServiceMesh:
              httpRoute: "my-httproute"
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata: