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.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage 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.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.
- Install the Google Cloud CLI.
-
To initialize the gcloud CLI, run the following command:
gcloud init
- 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ãoactAs
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
- Primeiro, adicione o papel
Se você já tiver a CLI instalada, verifique se está executando a versão mais recente:
gcloud components update
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óriodeploy-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
nodeploy-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óriodeploy-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.
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%.
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óriodeploy-canary-quickstart-gke
,deploy-canary-quickstart-gke-gatewayapi
oudeploy-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%.
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
.
Pronto, você concluiu as etapas deste início rápido.