Implantar um aplicativo canário em um destino

Implantar um aplicativo canário 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 no GKE Enterprise, 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 que você configura no pipeline de entrega. O GKE implanta a nova versão em uma proporção de pods. Este guia de início rápido implanta em 50% primeiro e depois em 100%.

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

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

1. Criar um cluster do GKE ou definir um serviço do Cloud Run.

   Também é possível fazer a implantação canário nos clusters do GKE Enterprise, 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 de 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 é implantada 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 o estágio canário para implantar o aplicativo em 50%.

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

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, 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.

2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

4. Ative as APIs Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

   Ative as APIs

5. Instale a CLI do Google Cloud.

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

   gcloud init

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

7. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

8. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

9. Ative as APIs Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

   Ative as APIs

10. Instale a CLI do Google Cloud.

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

    gcloud init

    observação: execute a CLI gcloud no console do Google Cloud sem instalar a Google Cloud CLI. Para executar a gcloud CLI no console do 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

12. 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 em 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 o ambiente de execução específico.
    • Para o GKE e 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 implantar 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 seu ambiente de execução

GKE;

Crie um cluster do Autopilot do GKE:

 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 usar 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 Kubernetes Gateway, 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 do 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 você estiver usando o Cloud Run, poderá pular este comando, não é necessário fazer nada aqui.

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

O Cloud Deploy usa o Skaffold para fornecer os detalhes sobre o que implantar e como implantá-lo corretamente no destino.

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

1. Abra uma janela de 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ê cria o arquivo. Mas você também pode fazer com que o Cloud Deploy crie um para você, para aplicativos simples que não sejam de produção.

   Consulte a referência do 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 simples do Kubernetes, aplicado ao cluster para implantar o aplicativo.

   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 de serviço e implantação necessários para a implantação canário, além de um HTTPRoute e o recurso de gateway necessários para usar a API Gateway.

   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 é um arquivo de configuração de serviço do Cloud Run, aplicado no momento da implantação para criar o serviço no Cloud Run.

Observação: se você quiser usar manifestos diferentes por destino, leia este artigo sobre como gerenciar 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 o pipeline e o ú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 do Google Cloud, navegue até a página Pipelines de entrega do Cloud Deploy para ver uma lista de pipelines de entrega disponíveis.

   Abrir a página "Pipelines de entrega"

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

   

Criar uma versão

Uma versão é o recurso central do Cloud Deploy que representa as alterações 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 ver detalhes sobre esse ciclo de vida.

Para criar um recurso release que represente 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc

Quando você cria uma versão, o Cloud Deploy cria automaticamente um recurso de lançamento para implantar imediatamente em seu único destino, prod.

Pulamos para a fase estável

Com essa primeira versão, pulamos a fase canário e implantamos para 100% (fase estável). Isso ocorre porque o aplicativo não foi implantado anteriormente. Portanto, não há como 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 revisões (Cloud Run) ainda não existem.

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

Em uma situação real, você normalmente executará uma implantação canário em que o aplicativo já está em execução, então essa fase de pular será rara.

Confira a versão no console do Google Cloud

Agora que você criou a primeira versão, o lançamento foi criado e é possível conferir a versão e o lançamento no console do Google Cloud. Também é possível visualizar a visualização do pipeline, que mostra o status atual da versão.

1. No console do Google Cloud, navegue até a página Pipelines de entrega do Cloud Deploy para ver 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 da implantação do aplicativo. 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 é "Pending avanço" e o destino mostrado na visualização do pipeline tem um link para "Avançar para a versão estável".

Avançar a fase de lançamento

Após a primeira versão, a fase canário 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 a versão estável.

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

Após alguns minutos, o lançamento está na fase "estável" e o aplicativo é implantado como 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, executará 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc
   

   Após alguns minutos, um lançamento é criado e, desta vez, o estágio canário é executado:

   

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

   

   Isso significa que o aplicativo foi implantado em 50%. No GKE baseado em serviceNetworking, ele é implantado em metade dos seus pods. Para o GKE baseado na API Gateway e o tráfego do Cloud Run é alocado para 50%.

2. Clique em Lançamento avançado 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 sua conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.

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

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

2. Exclua o serviço my-canary-run-service (somente 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.

• Aprenda a combinar as ferramentas de CI/CD do Google Cloud para desenvolver e fornecer software no GKE.