Esta página foi traduzida pela API Cloud Translation.

Implantar um aplicativo canário em um destino

Neste guia de início rápido, mostramos como usar o Cloud Deploy para enviar 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 Canary no GKE Enterprise, mas apenas o GKE e o Cloud Run são mostrados neste Guia Rápido.

Uma implantação canário divide o tráfego entre uma versão já implantada do 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. Isso o 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. 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:

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

Também é possível fazer a implantação Canary em clusters do GKE Enterprise, mas este guia de início rápido usa apenas o GKE e o Cloud Run.
Crie uma configuração do Skaffold e um manifesto do Kubernetes para especificar a imagem de contêiner (pré-criada) a ser implantada.
Defina o pipeline de entrega e o destino de implantação do Cloud Deploy.
Invoque o pipeline de entrega criando uma versão, que é implantada automaticamente em um destino.

Essa primeira versão ignora a fase de canário.
Confira o pipeline de entrega e a versão no console do Google Cloud.
Crie uma segunda versão, desta vez executando o estágio canário para implantar o aplicativo em 50%.
Avance a versão para implantar para 100%.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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

gcloud components update

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 são incluídas para projetos que desativam as concessões automáticas de papéis para contas de serviço padrão.

Primeiro, adicione o papel clouddeploy.jobRunner:

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/clouddeploy.jobRunner"

Adicione o papel de desenvolvedor ao 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)")-compute@developer.gserviceaccount.com \
    --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)")-compute@developer.gserviceaccount.com \
    --role="roles/run.developer"

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)")-compute@developer.gserviceaccount.com \
    --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
    --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
    --role="roles/iam.serviceAccountUser" \
    --project=PROJECT_ID

Criar o ambiente de execução

GKE;

Crie um GKE Autopilot cluster:

 gcloud container clusters create-auto canary-quickstart-cluster \
                  --project=PROJECT_ID \
                  --region=us-central1

API GKE + Gateway

Criar um cluster do GKE com as configurações recomendadas para 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

Consiga as credenciais do cluster:

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

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

Ative a implementação do controlador de gateway do Istio instalando o 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, pode pular este comando, não é preciso fazer nada aqui.

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.

Abra uma janela de terminal.

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

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.

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:

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

API GKE + 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 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

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

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

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

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"
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.
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%:

Na visualização do pipeline, clique em Avançar para a versão estável.
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%.

pipeline de entrega na fase estável

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.

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:

pipeline de entrega iniciando a fase canário

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

visualização do pipeline de entrega no console do Google Cloud, com o aplicativo implantado em 50%

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

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

Limpar

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

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

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

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

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

Exclua os buckets do Cloud Storage que o Cloud Deploy criou.

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.

Implantar um aplicativo canário em um destino

Antes de começar

Criar o ambiente de execução

GKE;

API GKE + Gateway

Cloud Run

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

GKE;

API GKE + Gateway

Cloud Run

GKE;

API GKE + Gateway

Cloud Run

GKE;

GKE + API Gateway

Cloud Run

Criar pipelines e entregas de entrega

GKE;

API GKE + Gateway

Cloud Run

Criar uma versão

GKE;

API GKE + Gateway

Cloud Run

Vamos para a fase estável

Conferir a versão no console do Google Cloud

Avançar a fase de lançamento

Executar a implantação canário

GKE;

API GKE + Gateway

Cloud Run

Limpar

A seguir