Fazer uma implantação canário de um aplicativo em um destino

Fazer uma implantação canário de um aplicativo em um destino

Neste guia de início rápido, mostramos como usar o Cloud Deploy para entregar uma imagem de aplicativo de amostra em uma implantação canário no Google Kubernetes Engine ou no Cloud Run. Também é possível executar uma implantação canário em clusters anexados do GKE, mas apenas o GKE e o Cloud Run são mostrados neste guia de início rápido.

Uma implantação canário divide o tráfego entre uma versão já implantada do aplicativo e a nova versão. O Cloud Run distribui o tráfego com base nas porcentagens configuradas no pipeline de entrega. O GKE implanta a nova versão em uma proporção de pods. Este guia de início rápido faz a implantação primeiro em 50% e depois em 100%.

Neste guia de início rápido, há apenas um destino, (prod). Portanto, criamos apenas um cluster do GKE ou um serviço do Cloud Run para executar o aplicativo.

Neste guia de início rápido, você fará o seguinte:

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

   Também é possível fazer implantações canário em clusters anexados do GKE, mas este guia de 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 do contêiner (pré-criada) a ser implantada.

3. Defina o pipeline de entrega e o destino de implantação do Cloud Deploy.

4. Invoque o pipeline de entrega criando uma versão, que implanta automaticamente em um destino.

   Esta primeira versão ignora a fase canário.

5. Confira o pipeline de entrega e a versão no console do Google Cloud .

6. Crie uma segunda versão, desta vez executando a etapa canário para implantar o aplicativo em 50%.

7. Avance a versão para implantação em 100%.

Antes de começar

Faça login na sua conta do Google Cloud . Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
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.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
Go to project selector
Verify that billing is enabled for your Google Cloud project.
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
Instale a CLI do Google Cloud.
Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.
Para inicializar a gcloud CLI, execute o seguinte comando:
gcloud init
Observação:execute a CLI gcloud no console Google Cloud sem instalar a Google Cloud CLI. Para executar a CLI gcloud no console Google Cloud , use o Cloud Shell.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Instale a CLI do Google Cloud.

Ao usar um provedor de identidade (IdP) externo, primeiro faça login na gcloud CLI com sua identidade federada.

Para inicializar a gcloud CLI, execute o seguinte comando:

gcloud init

Observação:execute a CLI gcloud no console Google Cloud sem instalar a Google Cloud CLI. Para executar a CLI gcloud no console Google Cloud , use o Cloud Shell.

Se você já tiver a CLI instalada, verifique se está executando a versão mais recente:

gcloud components update

1. Verifique se a conta de serviço padrão do Compute Engine tem permissões suficientes.

   A conta de serviço já pode ter as permissões necessárias. Essas etapas estão incluídas para projetos que desativam as concessões automáticas de papéis para contas de serviço padrão.

   1. Primeiro, adicione o papel clouddeploy.jobRunner:

      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")[e-mail] \
          --role="roles/clouddeploy.jobRunner"
      

   2. Adicione a função de desenvolvedor para seu ambiente 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)")[e-mail] \
         --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)")[e-mail] \
         --role="roles/run.developer"
     

   3. Adicione o papel iam.serviceAccountUser, que inclui a permissão actAs para implantação no ambiente de execução:

      gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")[e-mail] \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")[e-mail] \
          --role="roles/iam.serviceAccountUser" \
          --project=PROJECT_ID
      

Criar o ambiente 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 configurações recomendadas para suportar o uso 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. Consiga as credenciais do cluster:

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

3. Instale os CRDs da API Gateway do Kubernetes se eles 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. Instale o Istio para ativar a implementação do controlador de gateway dele.

   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 você estiver usando o Cloud Run, pule este comando. Não é necessário fazer nada aqui.

Preparar a configuração do Skaffold e o manifesto do aplicativo

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

Neste guia de início rápido, você cria um arquivo skaffold.yaml, que identifica o manifesto do Kubernetes ou a configuração de serviço do Cloud Run a ser implantada.

1. Abra uma janela do terminal.

2. Crie um novo diretório e navegue até ele.

   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 arquivo chamado 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: {}
   

   Esse arquivo é uma configuração mínima do Skaffold que identifica seu manifesto. Para este guia de início rápido, você vai criar o arquivo. Mas também é possível fazer com que o Cloud Deploy crie um para você, para aplicativos simples que não são de produção.

   Consulte a referência de skaffold.yaml para mais informações sobre esse arquivo.

4. Crie o manifesto do aplicativo.

   GKE

   Crie um arquivo chamado 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
   

   Esse arquivo é um manifesto do Kubernetes, que é aplicado ao cluster para implantar o aplicativo. Esse manifesto inclui os recursos Service e Deployment necessários para a implantação canário, além de uma HTTPRoute e o recurso Gateway necessário para usar a API Gateway.

   A imagem do contêiner a ser implantada é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando você cria o lançamento.

   GKE + API Gateway

   Crie um arquivo chamado 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
   

   Esse arquivo é um manifesto do Kubernetes, que é aplicado ao cluster para implantar o aplicativo. Esse manifesto inclui os recursos Service e Deployment necessários para a implantação canário, além de uma HTTPRoute e o recurso Gateway necessário para usar a API Gateway.

   A imagem do contêiner a ser implantada é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando você cria o lançamento.

   Cloud Run

   Crie um arquivo chamado 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
   

   Esse arquivo é uma definição básica de serviço do Cloud Run, que é aplicada no momento da implantação para criar seu serviço no Cloud Run. A imagem do contêiner a ser implantada é definida aqui como um marcador de posição, my-app-image, que é substituído pela imagem específica quando você cria o lançamento.

Observação: se você quiser usar manifestos diferentes por destino, leia este artigo sobre o gerenciamento de manifestos para saber mais sobre como usar perfis do Skaffold.

Criar pipelines e entregas de entrega

É possível definir o pipeline de entrega e os destinos em um arquivo ou em arquivos separados. Neste guia de início rápido, criamos um arquivo para nosso pipeline e nosso único destino:

GKE

Crie um arquivo chamado 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 arquivo chamado 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:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

Cloud Run

Crie um arquivo chamado clouddeploy.yaml no diretório deploy-canary-quickstart-run 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:
          cloudRun:
            automaticTrafficControl: true
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod Run Service
run:
  location: projects/PROJECT_ID/locations/us-central1

1. Registre o pipeline e os destinos com o serviço Cloud Deploy:

   gcloud deploy apply --file=clouddeploy.yaml --region=us-central1 --project=PROJECT_ID
   

   Agora você tem um pipeline com um destino configurado para uma estratégia de implantação canário.

2. Confirme o pipeline e os destinos:

   No console Google Cloud , navegue até a página Pipelines de entrega do Cloud Deploy para conferir a lista dos seus pipelines de entrega disponíveis.

   Abrir a página "Pipelines de entrega"

   O pipeline de entrega que você acabou de criar é exibido, e o destino que você configurou é listado na coluna Destinos.

   

Criar uma versão

Uma versão é o recurso central do Cloud Deploy que representa as mudanças que estão sendo implantadas. O pipeline de entrega define o ciclo de vida dessa versão. Consulte Arquitetura de serviço do Cloud Deploy para mais detalhes sobre esse ciclo de vida.

Para criar um recurso release que representa a imagem do contêiner a ser implantada, execute o seguinte comando no diretório deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi ou deploy-canary-quickstart-run:

GKE

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-canary-demo-app-1 \
   --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

GKE + API Gateway

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-canary-demo-app-1 \
   --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

Cloud Run

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-canary-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a

Observe a flag --images=, que você usa para substituir o marcador de posição (my-app-image) no manifesto ou na definição de serviço pela imagem específica qualificada por SHA. O Google recomenda que você crie modelos dos manifestos dessa forma e use nomes de imagens qualificados por SHA na criação da versão.

Quando você cria uma versão, o Cloud Deploy também cria automaticamente um recurso de lançamento para implantação imediata no seu único destino, prod.

Vamos pular para a fase estável

Com esse primeiro lançamento, vamos pular a fase canário e implantar em 100% (fase estável). Isso acontece porque o aplicativo não foi implantado antes. Portanto, não é possível calcular 50% dos pods (para o GKE) ou como o tráfego é dividido para o serviço (para o Cloud Run). Os pods (GKE) ou as revisões (Cloud Run) ainda não existem.

Como pulamos a fase de teste, agora estamos prontos para iniciar a fase estável, que leva o tráfego a 100%. Depois disso, vamos criar outra versão, que vai executar o canário.

Em uma situação real, geralmente é executada uma implantação canário em que o aplicativo já está em execução. Portanto, essa fase de ignorar será rara.

Conferir a versão no console do Google Cloud

Agora que você criou a primeira versão, o lançamento foi criado, e você pode ver a versão e o lançamento no console Google Cloud . Você também pode conferir a visualização do pipeline, que mostra o status atual da versão.

1. No console Google Cloud , navegue até a página Pipelines de entrega do Cloud Deploy para visualizar seu pipeline de entrega my-canary-demo-app-1.

   Abrir a página "Pipelines de entrega"

2. Clique no nome do pipeline de entrega "my-canary-demo-app-1".

   A visualização do pipeline mostra o status de implantação do app. Como há apenas um estágio no pipeline, a visualização mostra apenas um nó.

   

   E sua versão é listada na guia Versões em Detalhes do pipeline de entrega.

3. Clique no nome da versão, test-release-001.

   Seus lançamentos aparecem em Lançamentos. É possível clicar em um lançamento para ver os detalhes dele, incluindo o registro de implantação.

   

   Observe que o status do lançamento é "Avanço pendente" e o destino mostrado na visualização do pipeline tem um link para "Avançar para estável".

Avançar a fase de lançamento

Após o primeiro lançamento, a fase canary foi ignorada, e o lançamento está aguardando o início da fase "estável", que implanta o aplicativo em 100%:

1. Na visualização do pipeline, clique em Avançar para estável.

2. Quando solicitado, clique em Avançar para confirmar.

Após alguns minutos, o lançamento estará na fase "estável", e o aplicativo será implantado em 100%.

Executar a implantação canário

Como a primeira versão pulou a fase canário, vamos criar outra versão, que desta vez executa uma implantação canário.

1. Para criar um novo release, execute o seguinte comando no diretório deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi ou deploy-canary-quickstart-run:

   GKE

   gcloud deploy releases create test-release-002 \
     --project=PROJECT_ID \
     --region=us-central1 \
     --delivery-pipeline=my-canary-demo-app-1 \
     --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
   

   GKE + API Gateway

   gcloud deploy releases create test-release-002 \
     --project=PROJECT_ID \
     --region=us-central1 \
     --delivery-pipeline=my-canary-demo-app-1 \
     --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa
   

   Cloud Run

   gcloud deploy releases create test-release-002 \
     --project=PROJECT_ID \
     --region=us-central1 \
     --delivery-pipeline=my-canary-demo-app-1 \
     --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
   

   Após alguns minutos, um lançamento é criado, e desta vez a etapa de canary é executada:

   

   Quando a primeira fase de lançamento terminar, o lançamento vai estar na fase canário:

   

   Isso significa que o aplicativo agora está implantado em 50%. Para o GKE baseado em serviceNetworking, ele é implantado em metade dos seus pods. Para o tráfego do GKE e do Cloud Run baseado na API Gateway, 50% são alocados.

2. Clique em Implantação avançada e em Avançar quando solicitado.

   Isso avança o lançamento para a fase "estável", implantando o aplicativo em 100%.

   

Limpar

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga as etapas abaixo.

1. Exclua o cluster canary-quickstart-cluster (somente GKE):

   gcloud container clusters delete canary-quickstart-cluster --region=us-central1 --project=PROJECT_ID
   

2. Exclua o serviço my-canary-run-service (somente no Cloud Run):

   gcloud run services delete my-canary-run-service --region=us-central1 --project=PROJECT_ID
   

3. Exclua o pipeline de entrega, o destino e todos os recursos de lançamento e lançamento:

   gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
   

4. Exclua os buckets do Cloud Storage criados pelo Cloud Deploy.

   Uma termina com _clouddeploy, e a outra é [region].deploy-artifacts.[project].appspot.com.

   Abrir a página "Procurar" do Cloud Storage

Pronto, você concluiu as etapas deste início rápido.

A seguir

• Saiba mais sobre o Cloud Deploy.

• Aprenda as noções básicas sobre a implantação de aplicativos.

• Teste o tutorial do Cloud Deploy.

• Saiba como gerenciar seus manifestos.

• Saiba como combinar ferramentas de Google Cloud CI/CD para desenvolver e entregar software de maneira eficaz ao GKE.