Implantar um aplicativo canário em um destino

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

O Cloud Deploy usa o Skaffold para oferecer os detalhes sobre o que implantar e como fazer isso corretamente em seu destino.

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

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
   

   API GKE + 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: {}
   

   API GKE + 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. Neste guia de início rápido, você vai criar o arquivo. Mas você também pode deixe o Cloud Deploy criar uma para você, para aplicativos simples que não sejam de produção.

   Consulte a referência do skaffold.yaml. para saber mais sobre o 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 arquivo manifest, que é aplicado ao cluster para implantar o aplicativo.

   GKE + API Gateway

   Crie um arquivo chamado kubernetes.yaml no 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 é um arquivo manifest, 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 de canário, além de um HTTPRoute e o recurso de gateway necessário 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, que é aplicado no momento do deploy para criar seu serviço no Cloud Run.

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:

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 do 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 implantação canário estratégia.

2. Confirme o pipeline e os destinos:

   No console do 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 é mostrado, e o único destino configurado é 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 saber mais 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 deploy-canary-quickstart-gke: deploy-canary-quickstart-gke-gatewayapi ou deploy-canary-quickstart-run diretório:

 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

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

Vamos para a fase estável

Com essa primeira versão, pulamos a fase canário e implantamos 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 o tráfego é dividido para o serviço (no Cloud Run). Os pods (GKE) ou revisões (Cloud Run) não existem ainda.

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

Em uma situação real, você geralmente executa um implantação canário em que o aplicativo já está em execução. Portanto, essa fase e pular será raro.

Conferir a versão no console do Google Cloud

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

1. No console do Google Cloud, navegue até a página Pipelines de entrega do Cloud Deploy para conferir o 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 aplicativo. Como há apenas uma fase 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.

   

   O status do lançamento é "Pendente com antecedência". e o destino mostrado a 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 foi aguardando para iniciar o "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 for solicitado, clique em Avançar para confirmar.

Após alguns minutos, o lançamento está na fase "estável", e o app é 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
   

   API GKE + 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4
   

   Após alguns minutos, uma versão é criada, e desta vez o estágio canário é executado:

   

   Quando a primeira fase de lançamento for concluída, o lançamento vai entrar na fase canário:

   

   Isso significa que o aplicativo agora está implantado em 50%. Para baseado em serviceNetworking, ele é implantado em metade dos que os pods implementam. Para o GKE baseado na API Gateway e o tráfego do Cloud Run, a alocação é de 50%.

2. Clique em Avançar lançamento e em Avançar quando solicitado.

   Isso faz com que o lançamento seja encaminhado para a fase "estável". a implantação do aplicativo 100%.