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:

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

  2. Crie uma configuração do Skaffold e um manifesto do Kubernetes para especificar a imagem de contêiner (pré-criada) a ser implantada.

  3. Defina o pipeline de entrega e o destino de implantação do Cloud Deploy.

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

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

Antes de começar

  1. 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.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

    Enable the APIs

  5. Install the Google Cloud CLI.
  6. To initialize the gcloud CLI, run the following command:

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

    Go to project selector

  8. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

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

    Enable the APIs

  10. Install the Google Cloud CLI.
  11. To initialize the gcloud CLI, run the following command:

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

    gcloud components update
    

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

    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)")-compute@developer.gserviceaccount.com \
          --role="roles/clouddeploy.jobRunner"
      

    2. 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"
        

    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)")-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

  1. 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
    
  2. Consiga as credenciais do cluster:

    gcloud container clusters get-credentials canary-quickstart-cluster \
           --project=PROJECT_ID \
           --region=us-central1
    
  3. 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
    
  4. 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.

  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:

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

    visualização do pipeline de entrega no console do Google Cloud

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.

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

    visualização do pipeline de entrega no console do Google Cloud

    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.

    lançamentos no console do Google Cloud

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

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.

  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:

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

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

    pipeline de entrega na fase estável, implantado em 100%

Limpar

Para evitar cobranças na 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 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.

A seguir