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

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 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ê 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.

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:

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

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

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:

 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

 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

 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 de versões.

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 para a fase estável

Neste 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 do lançamento.

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 a primeira versão, 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 termina, o lançamento entra 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%.