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 somente 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. Neste guia de início rápido, a implantação em 50% é feita primeiro 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 seu 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 a implantação canário nos clusters do GKE Enterprise, mas este guia de início rápido usa somente 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 seu pipeline de entrega criando uma versão, que é implantada automaticamente em um destino.

   Esta primeira versão pula 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 a versão para implantar em 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. Estas etapas estão incluídas para projetos que desativam 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 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 oferecer suporte ao 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 as 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. 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 esse 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 os detalhes sobre o que implantar e como implantá-lo corretamente no destino.

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

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/v3alpha1
   kind: Config
   manifests:
     rawYaml:
     - kubernetes.yaml
   deploy:
     kubectl: {}
   

   GKE + API Gateway

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

   Cloud Run

   apiVersion: skaffold/v3alpha1
   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, crie o arquivo. Mas você também pode pedir 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 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 arquivo é um arquivo de configuração de serviço do Cloud Run, aplicado no momento da implantação para criar seu 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 o uso de 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 destino único:

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 pronto para implantar o aplicativo, com um destino múltiplo composto por dois destinos do GKE.

2. Confirme o pipeline e os destinos:

   No console do Google Cloud, navegue até a página Pipelines de entrega do Cloud Deploy para visualizar a 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 que você configurou aparece 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=gcr.io/cloudrun/hello@sha256:98cdb98c2d97a67d5e9183beedfec98ca9d5967acd874409b4800bf4d1a51710

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

Pulamos para a fase estável

Com esta primeira versão, pulamos a fase canário e implantamos em 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.

Após pular 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ê geralmente executará uma implantação canário em que o aplicativo já está em execução, portanto, essa ação de pular a fase será rara.

Confira a versão no console do Google Cloud

Agora que você criou a primeira versão, o lançamento está criado e é possível visualizar a versão e o lançamento no console do Google Cloud. Também é possível ver 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 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 é "Progresso pendente" 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 Advance to 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 em 100%.

Executar a implantação canário

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

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=gcr.io/cloudrun/hello@sha256:98cdb98c2d97a67d5e9183beedfec98ca9d5967acd874409b4800bf4d1a51710
   

   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 está implantado em 50%. No GKE baseado em serviceNetworking, ele é implantado na metade dos pods. Para o GKE e o Cloud Run baseados na API Gateway, o tráfego é 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 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.

• Confira o tutorial do Cloud Deploy.

• Saiba como gerenciar seus manifestos.

• Saiba como combinar as ferramentas de CI/CD do Google Cloud para desenvolver e fornecer software ao GKE.