Experimento do Google Cloud Deploy e do Cloud Run

Neste documento, apresentamos um tutorial de experimento que coloca você à disposição com um pipeline de entrega no Google Cloud Deploy que implanta contêineres no Cloud Run. Ao final deste tutorial, você terá um pipeline de CD direcionado ao Cloud Run com dois ambientes: dev e prod. É possível implantar e promover novas imagens de contêiner usando os estágios do pipeline e acompanhar o processo no Console do Google Cloud.

Este tutorial depende de vários serviços do Google Cloud, principalmente do Config Controller e incluindo serviços pré-GA que ainda estão no pré-lançamento e não estão em geral disponíveis (API Cloud Run Admin v2). Com o Config Controller, é possível provisionar recursos de maneira declarativa usando o Modelo de recurso do Kubernetes (KRM, na sigla em inglês). O Google Cloud Deploy usa o Config Controller para criar e gerenciar serviços do Cloud Run como parte do pipeline de entrega.

Se você tiver dúvidas, encontrar bugs ou quiser enviar feedback, entre em contato pelo e-mail clouddeploy-feedback-external@google.com.

Tutorial do Cloud Shell

As instruções deste documento também estão incluídas em um tutorial fácil de seguir, baseado no Cloud Shell. Siga este tutorial ao usar este documento para orientação e contexto.

Configurar o ambiente

Crie um novo projeto e defina o projeto padrão para a Google Cloud CLI.

Recomendamos que você comece com um novo projeto.
```
gcloud config set project PROJECT_ID
```
No comando acima, substitua PROJECT_ID pelo ID do projeto real. Neste documento, o código (comandos e arquivos) contém {PROJECT_ID} como um marcador. A substituição aqui preencherá todas as instâncias deste documento, a menos que você atualize a página.
Ative as APIs necessárias:
```
gcloud services enable \
    krmapihosting.googleapis.com \
    clouddeploy.googleapis.com \
    compute.googleapis.com \
    run.googleapis.com
```
Este comando ativa as seguintes APIs, que são necessárias para concluir este experimento:
- Compute Engine
- Controlador de configuração
- Google Cloud Deploy
- Cloud Build (ativado pelo Google Cloud Deploy)
- Cloud Storage (ativado pelo Google Cloud Deploy)
- Resource Manager
- Cloud Run
- Google Kubernetes Engine (ativado pelo Config Controller)
Verifique se você instalou e configurou a Google Cloud CLI.

Além disso, será necessário garantir que o kubectl esteja instalado:
```
which kubectl || gcloud components install kubectl
```
Se você estiver executando comandos do Cloud Shell, esses componentes já estão instalados.

Configurar a conta de serviço padrão do Compute Engine

Por padrão, o Google Cloud Deploy usa a conta de serviço padrão do Compute Engine. A conta de serviço já pode ter as permissões necessárias. Essa etapa é para organizações que desativam as concessões automáticas de papéis para contas de serviço padrão.

Execute os comandos a seguir para garantir que a conta de serviço tenha as permissões adequadas:

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"

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"

Consulte a Visão geral do Google Cloud Deploy.

Nesta visão geral, você aprenderá sobre o serviço e os conceitos do Google Cloud Deploy.

Configurar o Config Controller

O Google Cloud Deploy usa uma instância do Config Controller para implantar os serviços e revisões do Cloud Run.

Antes de criar o Config Controller, verifique se há uma rede padrão:
```
gcloud compute networks list
```
A saída bem-sucedida do Console terá esta aparência:
```
NAME: default
SUBNET_MODE: AUTO
BGP_ROUTING_MODE: REGIONAL
IPV4_RANGE:
GATEWAY_IPV4:
```
Se você don't tiver uma rede padrão, execute o seguinte comando:
```
gcloud compute networks create default --subnet-mode=auto
```
Se a saída estiver correta, não será necessário executar esse comando.

Se tiver outros problemas, consulte o Guia de solução de problemas do Controlador de configuração ou entre em contato com o administrador da sua organização.

Crie sua instância do Config Controller.

gcloud anthos config controller create cc-deployrun --location=us-central1

Conceda permissões do Config Controller nos projetos em que você quer implantar. O comando a seguir dá as permissões mínimas necessárias para que o controlador de configuração crie e gerencie serviços do Cloud Run no seu projeto.

export SA_EMAIL="$(kubectl get ConfigConnectorContext -n config-control -o jsonpath='{.items[0].spec.googleServiceAccount}' 2> /dev/null)"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/run.admin" \
    --project "PROJECT_ID"

gcloud projects add-iam-policy-binding "PROJECT_ID" \
    --member "serviceAccount:${SA_EMAIL}" \
    --role "roles/iam.serviceAccountUser" \
    --project "PROJECT_ID"

Criar seus arquivos de configuração

O Google Cloud Deploy usa o Skaffold para fornecer os detalhes do que será implantado e como implantá-lo corretamente nos destinos separados. Neste experimento, temos dois destinos: run-dev e run-prod.

Destinos de experimentos do Cloud Run do Google Cloud Deploy, run-dev e run-prod

Nesta seção, você cria um arquivo skaffold.yaml que identifica os manifestos do Cloud Run que implantarão seu aplicativo por meio de um pipeline de entrega do Google Cloud Deploy. Você também criará os manifestos dos serviços do Cloud Run, um para cada ambiente de destino (run-dev-service.yaml e run-prod-service.yaml, respectivamente).

Crie um novo diretório para seus manifestos e navegue até ele:
```
mkdir deploy-cloudrun
cd deploy-cloudrun
```

Crie o arquivo skaffold.yaml nesse diretório.

skaffold.yaml informa ao Google Cloud Deploy quais manifestos serão implantados em cada destino no pipeline para uma determinada versão.

apiVersion: skaffold/v2beta26
kind: Config
profiles:
 - name: prod
   deploy:
     kubectl:
       manifests:
         - run-prod-*.yaml
 - name: dev
   deploy:
     kubectl:
       manifests:
         - run-dev-*.yaml

Crie o arquivo run-dev-service.yaml, no mesmo diretório.

Este manifesto declarativo representa a versão do ambiente dev do seu serviço do Cloud Run.

Observe as configurações personalizadas para esse ambiente, como limitar o escalonamento de contêineres a duas instâncias. Os rótulos e um nome são usados para distinguir essa versão do serviço no seu projeto. Observe que o nome da imagem é uma variável: run-container em vez de uma imagem de contêiner específica. Isso é substituído por uma imagem de contêiner específica quando você cria uma versão no Google Cloud Deploy.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-dev
  name: deploytest-dev
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: dev
        image: run-container
    scaling:
      maxInstanceCount: 2
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Crie o arquivo run-prod-service.yaml, no mesmo diretório

Este manifesto representa a versão prod do seu serviço do Cloud Run. Observe o nome, os rótulos e as configurações de escalonamento atualizados, bem como a reutilização de run-container.

apiVersion: run.cnrm.cloud.google.com/v1beta1
kind: RunService
metadata:
  labels:
    cloud-deploy-target: run-prod
  name: deploytest-prod
  namespace: config-control
spec:
  ingress: INGRESS_TRAFFIC_ALL
  location: us-central1
  projectRef:
    external: projects/PROJECT_ID
  template:
    containers:
      - env:
          - name: environment
            value: prod
        image: run-container
    scaling:
      maxInstanceCount: 10
  traffic:
    - percent: 100
      type: TRAFFIC_TARGET_ALLOCATION_TYPE_LATEST

Criar pipelines e entregas de entrega

É possível definir o pipeline de entrega e os destinos do Google Cloud Deploy em um arquivo ou em arquivos separados. Neste tutorial, para simplificar, você criará um único arquivo.

No diretório com seus manifestos criados recentemente (/deploy-cloudrun/), crie o arquivo clouddeploy.yaml:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
 name: my-run-app-1
description: main application pipeline
serialPipeline:
 stages:
 - targetId: run-dev
   profiles:
   - dev
 - targetId: run-prod
   profiles:
   - prod
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-dev
description: Cloud Run development environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: run-prod
description: Cloud Run production environment
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/krmapihost-cc-deployrun

cloudeploy.yaml define uma sequência de progressão de dois estágios no pipeline de entrega: run-dev e run-prod. O arquivo também define destinos para cada um desses dois estágios.

Observe que os dois destinos apontam para o mesmo Config Controller como um cluster do GKE. Esse Config Controller, compatível com um cluster do GKE subjacente criado no momento da criação do Config Controller, cria os serviços do Cloud Run para cada ambiente usando o respectivo manifesto.

Seu cluster do GKE