Como criar, testar e implantar artefatos

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

Se você tiver um arquivo de configuração de versão e quiser 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 da criação docker em que é possível invocar os comandos . Os argumentos passados para essa etapa da criação serão transmitidos para docker diretamente, permitindo que você execute qualquer comando docker nessa etapa da criação.

No arquivo de configuração da 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 da versão a seguir, a etapa da criaçã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 da criação, conforme indicado pelo .. O código-fonte para 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êineres

O Cloud Build fornece etapas de versão compatíveis com linguagens e ferramentas comuns, que podem ser usadas para executar as versões.

Para criar artefatos que não são de contêineres, adicione uma seção de etapas de criaçã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 criação. Cada etapa de criação é executada com o respectivo contêiner anexado a uma rede local do Docker chamada cloudbuild. Para que os testes de integração funcionem, é preciso especificar o nome da rede.

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, chame a etapa de criação gke-deploy:

  1. Ative a API GKE.

  2. Crie um cluster.

  3. Adicione um papel do GKE à conta de serviço:

    1. Abra a página "Configurações do Cloud Build":

      Abrir a página Configurações do Cloud Build

      Você verá a página Permissões da conta de serviço:

      Captura de tela da página

    2. Defina o status do papel de Desenvolvedor do Kubernetes Engine como Ativado .

  4. Adicione uma das seguintes séries de etapas de criação no seu arquivo de configuração da criação:

    • Adicione essas etapas de criação se você estiver fornecendo seus próprios arquivos de configuração do Kubernetes que fazem referência à imagem:

      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/gke-deploy:stable'
        args:
        - run
        - --filename=[CONFIG]
        - --image=gcr.io/[PROJECT-ID]/[IMAGE]:[TAG]
        - --location=[LOCATION]
        - --cluster=[CLUSTER]
      
    • Adicione essas etapas de criação se você não tiver arquivos de configuração do Kubernetes para sua imagem:

      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/gke-deploy:stable'
        args:
        - run
        - --image=gcr.io/[PROJECT-ID]/[IMAGE]:[TAG]
        - --location=[LOCATION]
        - --cluster=[CLUSTER]
      

Esta versão chama a etapa de criação docker para criar uma imagem do Docker e enviá-la para o Container Registry. Em seguida, a versão chama a etapa de criação gke-deploy para implantar no cluster do GKE.

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 o [TAG] dela como a versão pretendida ou a confirmação de SHA
  • [CLUSTER], o nome do cluster ao que as credenciais de autenticação são solicitadas
  • [LOCATION], a região/zona do cluster
  • [CONFIG], os arquivos de configuração do Kubernetes a serem usados por gke-deploy run, se houver

App Engine

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

  1. Ative a API App Engine.

  2. Adicione o papel do App Engine à conta de serviço:

    1. Abra a página "Configurações do Cloud Build":

      Abrir a página Configurações do Cloud Build

      Você verá a página Permissões da conta de serviço:

      Captura de tela da página

    2. Defina o status do papel Administrador do Google App Engine como Ativo.

  3. 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 criação gcloud chama o comando gcloud app deploy para criar uma imagem de contêiner com seu código-fonte e, em seguida, implanta a imagem no App Engine.

Cloud Functions

Para implantar um aplicativo do Cloud Functions , chame a etapa da criação gcloud para invocar gcloud functions deploy:

  1. Ative a API Cloud Functions.

  2. Adicione o papel do Cloud Functions à conta de serviço:

    1. Abra a página "Configurações do Cloud Build":

      Abrir a página Configurações do Cloud Build

      Você verá a página Permissões da conta de serviço:

      Captura de tela da página

    2. Defina o status do papel de desenvolvedor do Cloud como Ativo.

    3. Selecione CONCEDER ACESSO A TODAS AS CONTAS DE SERVIÇO para conceder o papel de Usuário da conta de serviço a todas as contas de serviço no projeto, na sua página.

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

Cloud Run

Para implantar um aplicativo do Cloud Run, chame a etapa da criação gcloud para invocar gcloud beta run deploy:

  1. Ative a API Cloud Run.

  2. Adicione o papel do Cloud Run à conta de serviço:

    1. Abra a página "Configurações do Cloud Build":

      Abrir a página Configurações do Cloud Build

      Você verá a página Permissões da conta de serviço:

      Captura de tela da página

    2. Defina o status do papel Administrador do Cloud Run como Ativo.

    3. Selecione CONCEDER ACESSO A TODAS AS CONTAS DE SERVIÇO para conceder o papel de Usuário da conta de serviço a todas as contas de serviço no projeto, na sua página.

  3. Crie um arquivo de configuração de versão que use gcloud beta run deploy:

    steps:
      # build the container image
    - name: 'gcr.io/cloud-builders/docker'
      args: ['build', '-t', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]', '.']
      # push the container image to Container Registry
    - name: 'gcr.io/cloud-builders/docker'
      args: ['push', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]']
      # Deploy container image to Cloud Run
    - name: 'gcr.io/cloud-builders/gcloud'
      args: ['beta', 'run', 'deploy', '[SERVICE-NAME]', '--image', 'gcr.io/$PROJECT_ID/[SERVICE-NAME]', '--region', '[REGION]', '--platform', 'managed']
    images:
    - gcr.io/$PROJECT_ID/[SERVICE-NAME]
    

Substitua [SERVICE-NAME] e [REGION] pelo nome e pela região do serviço Cloud Run em que você está fazendo a implantação.

Se você estiver usando o Cloud Run no GKE, use gke em vez de managed e --cluster. Use --cluster-location em vez do parâmetro --region.

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

Para saber mais informações sobre como implantar imagens no Cloud Run, consulte Como implantar no Cloud Run .

Firebase

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

Para criar uma etapa de criação do Firebase, crie um Dockerfile e um arquivo de configuração da criação dos exemplos a seguir.

Crie um Dockerfile com os conteúdos a seguir. Isso instala a ferramenta de linha de comando do Firebase, firebase, quando chamada 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 os conteúdos a seguir. Esta configuração de versão usa o Dockerfile para colocar firebase-tools como firebase em um contêiner. 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'

Após colocar Dockerfile e cloudbuild.yaml no mesmo diretório, execute o seguinte comando, do shell ou da 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 (identificadas por .). A versão instala a ferramenta firebase no ambiente. Em seguida, a ferramenta é inserida em um contêiner e enviada ao seu Container Registry.

Para chamar firebase em suas versões, adicione a etapa de criação gcr.io/[PROJECT_ID]/firebase à sua configuração da criaçã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ê gerou.

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 da criação npm é chamada para instalar as dependências e executar testes de unidade.
  • A etapa de criação docker é chamada para criar uma imagem do Docker do aplicativo e enviar a imagem para o Container Registry.
  • A etapa da criação gke-deploy é chamada para implantar a imagem incorporada 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/gke-deploy:stable'
  args:
  - 'run'
  - '--image=gcr.io/my-project/my-image:$REVISION_ID'
  - '--location=us-east4-b'
  - '--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/gke-deploy:stable",
        "args": [
            "run",
            "--image=gcr.io/my-project/my-image:$REVISION_ID",
            "--location=us-east4-b",
            "--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:

  • Usa docker para criar uma ferramenta de análise
  • Executa pulls de alguns dados do diretório data-to-analyze
  • Envia 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