Como criar, testar e implantar artefatos

Nesta página, explicamos como usar as imagens oficiais do criador do Cloud Build para escrever configurações da versão para buscar código-fonte e dependências, bem como para criar, testar e implantar artefatos.

Se você já tem um arquivo de configuração de versão e quer executar suas versões no Cloud Build, leia Como iniciar versões manualmente e Como automatizar versões.

Antes de começar

Como buscar dependências

Busque o código-fonte ou instale dependências usando uma etapa de versão que executa ferramentas como docker, git, npm e gsutil:

docker

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['pull', 'gcr.io/$PROJECT_ID/latest-image']

git

steps:
- name: 'gcr.io/cloud-builders/git'
  args: ['clone', 'https://github.com/GoogleCloudPlatform/cloud-builders']

npm

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: ['install']

gsutil

steps:
- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'gs://mybucket/remotefile.zip', 'localfile.zip']

Como criar imagens de contêiner

Para criar imagens de contêiner do Docker, use a etapa de versão docker, em que você chama comandos docker. Argumentos passados para essa etapa de versão serão passados para docker diretamente, permitindo que você execute qualquer comando docker nessa etapa de versão.

No arquivo de configuração de versão, adicione instruções para os seguintes objetivos:

  • Chame o criador docker e transmita os argumentos para invocar o comando build do Docker. Na configuração de versão a seguir, a etapa da versão do Docker é chamada duas vezes para criar duas imagens. Os arquivos de código-fonte delas são encontrados no diretório de trabalho atual no momento de criação, conforme indicado por .. O código-fonte de gcr.io/my-project/image2 pode ser encontrado em um diretório dentro do diretório de trabalho atual no momento da criação, subdirectory.
  • Adicione o campo images para enviar as imagens resultantes para o Container Registry.

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project/image1', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project/image2', '.']
  dir: 'subdirectory'
images: ['gcr.io/my-project/image1', 'gcr.io/my-project/image2']

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": ["build", "-t", "gcr.io/my-project/image1", "."]
    },
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": ["build", "-t", "gcr.io/my-project/image2", "."],
      "dir": "subdirectory"
    }
  ],
  "images": ["gcr.io/my-project/image1", "gcr.io/my-project/image2"]
}

Como criar artefatos que não são de contêiner

O Cloud Build fornece etapas de versão suportadas para linguagens e ferramentas comuns que é possível usar para executar as versões.

Para criar artefatos que não são contêineres, adicione etapas de versão que executem criadores como maven, gradle, go ou bazel:

maven

steps:
- name: 'gcr.io/cloud-builders/mvn'
  args: ['install']
- name: 'gcr.io/cloud-builders/mvn'
  args: ['package']

gradle

steps:
- name: 'gcr.io/cloud-builders/gradle'
  args: ['build']

go

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['build', 'my-package']

bazel

steps:
- name: 'gcr.io/cloud-builders/bazel'
  args: ['build', '//path/to:target']

Como executar testes de unidade e integração

Se você tiver o código-fonte disponível, poderá executar testes de unidade e integração como etapas de versão.

Suponha que você tenha um aplicativo JavaScript com testes de unidade, um Dockerfile que cria uma imagem do Docker e testes de integração executados nessa imagem em execução.

Para executar testes de unidade e integração nesse aplicativo, adicione instruções para os seguintes itens no arquivo de configuração de versão:

  • Instale dependências para executar a versão.
  • Execute o teste de unidade.
  • Crie a imagem do Docker do aplicativo.
  • Execute o aplicativo e as dependências em segundo plano usando a composição do Docker.
  • Execute os testes de integração na pilha de composição do Docker em execução.
  • Envie a imagem recém-criada ao Container Registry.

    steps:
    - name: 'gcr.io/cloud-builders/npm'
      args: ['install']
    - name: 'gcr.io/cloud-builders/npm'
      args: ['run', 'test:unit']
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t', 'gcr.io/$PROJECT_ID/gcb-docker-compose:latest', '.']
    - name: 'docker/compose:1.15.0'
      args: ['up', '-d']
      env:
      - 'PROJECT_ID=$PROJECT_ID'
    - name: 'gcr.io/cloud-builders/npm'
      args: ['run', 'test:integration']
      env:
      - 'HOST=counter' # name of the running container
      - 'PORT=50051'
    images: ['gcr.io/$PROJECT_ID/gcb-docker-compose:latest']
    

Como implantar artefatos

Como parte do seu canal de implantação contínua, o Cloud Build pode executar implantações usando ferramentas de linha de comando.

Use as etapas a seguir para implantar no GKE, no App Engine, no Cloud Functions e no Firebase.

Kubernetes Engine

Para implantar no GKE com kubectl, chame a etapa de versão kubectl para atualizar um recurso de implantação:

  1. Ative a API GKE.
  2. Adicione o papel do IAM do GKE:
    1. No Console do GCP, acesse o menu do IAM.
    2. Na lista de contas de serviço, clique no menu suspenso Papéis ao lado da conta de serviço [YOUR-PROJECT-NUMBER]@cloudbuild.gserviceaccount.com do Cloud Build.
    3. Clique em Kubernetes Engine e, em seguida, em Administrador do Kubernetes Engine.
    4. Clique em Salvar.
  3. Adicione a etapa de versão kubectl à configuração de versão:

    steps:
    - name: 'gcr.io/cloud-builders/docker'
      args: ["build", "-t", "gcr.io/[PROJECT-ID]/[IMAGE]", "."]
    - name: 'gcr.io/cloud-builders/docker'
      args: ["push", "gcr.io/[PROJECT-ID]/[IMAGE]"]
    - name: 'gcr.io/cloud-builders/kubectl'
      args:
      - set
      - image
      - deployment
      - [DEPLOYMENT-NAME]
      - [CONTAINER]=gcr.io/[PROJECT-ID]/[IMAGE]:[TAG]
      env:
      - 'CLOUDSDK_COMPUTE_ZONE=[COMPUTE-ZONE]'
      - 'CLOUDSDK_CONTAINER_CLUSTER=[CLUSTER]'
    

Essa versão chama a etapa de versão docker para criar uma imagem do Docker e enviá-la ao Container Registry. Em seguida, a versão chama a etapa de versão kubectl para atualizar um recurso de implantação.

Para usar este exemplo de configuração de versão, forneça as seguintes informações:

  • [PROJECT-ID], o ID do projeto do GCP
  • [IMAGE], o nome da imagem e a [TAG] dela como a versão desejada ou a efetivação de SHA
  • [CLUSTER], o nome do cluster ao qual as credenciais de autenticação são solicitadas
  • [COMPUTE-ZONE], a zona de computação do projeto
  • [DEPLOYMENT-NAME], o nome do recurso de implantação do Kubernetes a ser atualizado pelo kubectl set

App Engine

Para implantar um aplicativo de uma imagem de contêiner no App Engine, chame a etapa de versão gcloud com argumentos para o comando gcloud app deploy:

  1. Ative a API do App Engine.
  2. Conceda o papel do IAM do App Engine à conta de serviço do Cloud Build:

    1. No Console do GCP, acesse o menu do IAM.
    2. Na lista de membros, procure [YOUR-PROJECT-NUMBER]@cloudbuild.gserviceaccount.com.
    3. Clique no ícone de lápis nessa linha para conceder um novo papel a essa conta.
    4. Clique em Adicionar outro papel.
    5. Selecione App Engine e clique em Administrador do App Engine.
    6. Clique em Salvar.
    7. Crie um arquivo de configuração de versão que use gcloud app deploy:

      steps:
      - name: 'gcr.io/cloud-builders/gcloud'
        args: ['app', 'deploy']
      timeout: '1600s'
      

A etapa da versão gcloud chama o comando gcloud app deploy para criar uma imagem de contêiner com seu código-fonte e, em seguida, implantar a imagem no App Engine.

Cloud Functions

Para implantar um aplicativo no Cloud Functions, chame a etapa de versão gcloud para invocar gcloud functions deploy:

  1. Ative a API do Cloud Functions.
  2. Conceda o papel Desenvolvedor do Cloud Functions à conta de serviço do Cloud Build:
    1. No Console do GCP, acesse o menu do IAM.
    2. Na lista de membros, procure [PROJECT_NUMBER]@cloudbuild.gserviceaccount.com.
    3. Clique no ícone de lápis nessa linha para conceder um novo papel a essa conta.
    4. Clique em Adicionar outro papel.
    5. Selecione Cloud Functions e, em seguida, Desenvolvedor do Cloud Functions.
    6. Clique em Salvar.
  3. Conceda o papel Usuário da conta de serviço do IAM à conta de serviço do Cloud Build na conta de serviço do ambiente de execução do Cloud Functions:
    1. No Console do GCP, visite o menu "Contas de serviço".
    2. Na lista de membros, procure [PROJECT_ID]@appspot.gserviceaccount.com.
    3. Selecione a conta de serviço acima e clique em EXIBIR PAINEL DE INFORMAÇÕES no canto superior direito.
    4. No painel Permissões, clique no botão Adicionar membro.
    5. Insira a conta de serviço do Cloud Build ([PROJECT_NUMBER]@cloudbuild.gserviceaccount.com) no campo de entrada Novo membro.
    6. Na lista suspensa Papel, selecione Contas de serviço e Usuário da conta de serviço.
    7. Clique em Salvar.
  4. Crie um arquivo de configuração de versão que use gcloud functions deploy:

    steps:
    - name: 'gcr.io/cloud-builders/gcloud'
      args:
      - functions
      - deploy
      - [FUNCTION_NAME]
      - --source=.
      - --trigger-http
    

Isso cria o código-fonte do aplicativo e chama gcloud functions deploy para implantar o Cloud Functions do aplicativo.

Firebase

É possível usar o Firebase nas suas versões, basta criar uma etapa personalizada de versão do Firebase.

Para criar uma etapa de versão do Firebase, crie um Dockerfile e um arquivo de configuração de versão com base nos exemplos a seguir.

Crie um Dockerfile com o conteúdo a seguir. Ele instala a ferramenta de linha de comando do Firebase, firebase, quando chamado pela versão:

# use latest Node LTS (Boron)
FROM node:boron
# install Firebase CLI
RUN npm install -g firebase-tools

ENTRYPOINT ["/usr/local/bin/firebase"]

Crie uma configuração de versão chamada cloudbuild.yaml com o conteúdo a seguir. Essa configuração de versão usa Dockerfile para colocar firebase-tools em contêiner como firebase. Em seguida, a versão envia a imagem em contêiner ao Container Registry para uso em versões posteriores:

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'gcr.io/[PROJECT_ID]/firebase', '.' ]
images:
- 'gcr.io/[PROJECT_ID]/firebase'

Com Dockerfile e cloudbuild.yaml no mesmo diretório, execute o comando abaixo no shell ou na janela de terminal:

gcloud builds submit --config=cloudbuild.yaml .

O comando gcloud builds envia uma versão para o Cloud Build, que usa a configuração de versão cloudbuild.yaml e a origem no diretório atual (denotado por .). A versão instala a ferramenta firebase no ambiente. Em seguida, a ferramenta é inserida em contêiner e enviada ao seu Container Registry.

Para chamar firebase em suas versões, adicione a etapa de versão gcr.io/[PROJECT_ID]/firebase à sua configuração de versão:

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'install' ]
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'test' ]
- name: 'gcr.io/cloud-builders/npm'
  args: [ 'run', 'build.prod' ]
- name: 'gcr.io/[PROJECT_ID]/firebase'
  args: [ 'deploy', '-P', 'js-demo-fe-staging', '--token', '[FIREBASE_TOKEN]']

Para usar essa configuração de versão, forneça o valor [FIREBASE_TOKEN], que é o token de autenticação do Firebase que você teria gerado.

Exemplos de arquivos de configuração de versão

Versão acionada pelo GitHub

A configuração a seguir mostra uma versão simples que é acionada pelo GitHub. Normalmente, esse tipo de configuração é usado em um canal CI/CD.

Neste exemplo:

  • a etapa de versão npm é chamada para instalar as dependências e executar testes de unidade;
  • a etapa de versão docker é chamada para criar uma imagem do Docker do aplicativo e enviá-la ao Container Registry;
  • a etapa de versão kubectl é chamada para implantar a imagem criada no cluster do Kubernetes.

YAML

steps:
- name: 'gcr.io/cloud-builders/npm'
  args: ['install']
- name: 'gcr.io/cloud-builders/npm'
  args: ['test']
- name: 'gcr.io/cloud-builders/docker'
  args: ["build", "-t", "gcr.io/my-project/my-image:$REVISION_ID", "."]
- name: 'gcr.io/cloud-builders/docker'
  args: ["push", "gcr.io/my-project/my-image:$REVISION_ID"]
- name: 'gcr.io/cloud-builders/kubectl'
  args:
  - 'set'
  - 'image'
  - 'deployment/my-deployment'
  - 'my-container=gcr.io/my-project/my-image:$REVISION_ID'
  env:
  - 'CLOUDSDK_COMPUTE_ZONE=us-east4-b'
  - 'CLOUDSDK_CONTAINER_CLUSTER=my-cluster'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/npm",
        "args": [
            "install"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/npm",
        "args": [
            "test"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/my-project/my-image:$REVISION_ID",
            "."
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "push",
            "gcr.io/my-project/my-image:$REVISION_ID"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/kubectl",
        "args": [
            "set",
            "image",
            "deployment/my-deployment",
            "frontend=gcr.io/my-project/my-image:$REVISION_ID"
        ],
        "env": [
            "CLOUDSDK_COMPUTE_ZONE=us-east4-b",
            "CLOUDSDK_CONTAINER_CLUSTER=my-cluster"
        ]
    }
    ]
}

Como escrever solicitações de versão sem enviar imagens

É possível usar o Cloud Build para realizar tarefas arbitrárias sem produzir imagens do Docker.

No exemplo a seguir, é possível:

  • utilizar o docker para criar uma ferramenta de análise;
  • chamar alguns dados do diretório data-to-analyze;
  • enviar os resultados da análise para um intervalo do Cloud Storage.

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'analyzer', '.']

- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'gs://my-data-warehouse/data-to-analyze.tgz', '.']

- name: 'debian'
  args: ['tar', '-xzf', 'data-to-analyze.tgz']

- name: 'analyzer'
  args: ['--output=results.csv']
  dir: 'data-to-analyze'

- name: 'gcr.io/cloud-builders/gsutil'
  args: ['cp', 'data-to-analyze/results.csv', 'gs://my-data-warehouse/results.tgz']

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "analyzer",
        "."
      ]
    },
    {
      "name": "gcr.io/cloud-builders/gsutil",
      "args": [
        "cp",
        "gs://my-data-warehouse/data-to-analyze.tgz",
        "."
      ],
    },
    {
      "name": "debian",
      "args": [
        "tar",
        "-xzf",
        "data-to-analyze.tgz"
      ],
    },
    {
      "name": "analyzer",
      "args": [
        "--output=results.csv"
      ],
      "dir": "data-to-analyze"
    },
    {
      "name": "gcr.io/cloud-builders/gsutil",
      "args": [
        "cp",
        "data-to-analyze/results.csv",
        "gs://my-data-warehouse/results.tgz"
      ]
    }
  ]
}

A seguir

Enviar comentários sobre…