Esta página foi traduzida pela API Cloud Translation.

Crie, teste e contentorize aplicações Go

Esta página explica como usar o Cloud Build para criar, testar, colocar em contentores e implementar aplicações Go, e como guardar os registos de testes no Cloud Storage.

Antes de começar

As instruções nesta página pressupõem que tem conhecimentos sobre o Go. Além disso:

Enable the Cloud Build, Cloud Run, and Artifact Registry APIs.
Enable the APIs
Para executar os comandos gcloud nesta página, instale a CLI do Google Cloud.
Tenha o seu projeto Go à mão.
Se quiser colocar a sua app Go num contentor através do Cloud Build, precisa de um Dockerfile juntamente com o código-fonte.
Se quiser armazenar o contentor criado no Artifact Registry, crie um repositório Docker no Artifact Registry.
Se quiser armazenar registos de testes no Cloud Storage, crie um contentor no Cloud Storage.

Autorizações de IAM necessárias

Para armazenar registos de testes no Logging, conceda a função Storage Object Creator (roles/storage.objectCreator) para o contentor do Cloud Storage à sua conta de serviço de compilação.
Para armazenar imagens criadas no Artifact Registry, conceda à conta de serviço de compilação a função Artifact Registry Writer (roles/artifactregistry.writer).

Para obter instruções sobre como conceder estas funções, consulte o artigo Conceder uma função através da página do IAM.

Configurar compilações Go

A imagem golang pública do Docker Hub suporta a criação com módulos Go. A utilização desta imagem como um passo de compilação no ficheiro de configuração do Cloud Build permite-lhe invocar comandos go na imagem. Os argumentos transmitidos a este passo de compilação são transmitidos diretamente à ferramenta golang, o que lhe permite executar qualquer comando go nesta imagem.

Esta secção explica um exemplo de ficheiro de configuração de compilação para uma app Go. Tem passos de compilação para compilar a app, adicionar testes unitários e, depois de os testes serem aprovados, para colocar a app num contentor e implementá-la.

Para criar a sua aplicação Go:

No diretório raiz do projeto, crie um ficheiro de configuração do Cloud Build denominado cloudbuild.yaml.
Crie e teste: se tiver definido testes unitários na sua aplicação, pode configurar o Cloud Build para executar os testes adicionando os seguintes campos num passo de compilação:
- name: defina o valor deste campo como golang para usar a imagem golang do Docker Hub para a sua tarefa.
- entrypoint: defina o valor deste campo como /bin/bash. Isto permite-lhe executar comandos bash de várias linhas diretamente a partir do passo de compilação.
- args: o campo args de um passo de compilação recebe uma lista de argumentos e transmite-os à imagem referenciada pelo campo name. No exemplo seguinte, o campo args recebe os argumentos para:
  - Executar o formatador de registo de teste para transferir a saída do registo de teste.
  - Imprimir o resultado do registo.
  - A guardar os resultados dos testes em sponge.log.
  - Produzir os resultados em sponge.log num ficheiro XML JUNIT. O nome do ficheiro XML JUNIT é criado com a versão abreviada do ID de commit associado à sua compilação. Um passo de compilação subsequente guarda os registos neste ficheiro no Cloud Storage.
```
steps:
  # Run tests and save to file
  - name: golang:1.24
    entrypoint: /bin/bash
    args: 
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml
```
Coloque a app num contentor: depois de adicionar o passo de compilação para garantir que os testes foram aprovados, pode compilar a aplicação. O Cloud Build fornece uma imagem Docker pré-criada que pode usar para colocar a sua aplicação Go num contentor. Para colocar a sua app num contentor, adicione os seguintes campos num passo de compilação:
- name: defina o valor deste campo como gcr.io/cloud-builders/docker para usar a imagem do Docker pré-criada para a sua tarefa.
- args: adicione os argumentos do comando docker build como valores para este campo.
O seguinte passo de compilação cria a imagem myimage e atribui-lhe uma etiqueta com a versão abreviada do ID de confirmação. O passo de compilação usa substituições para o ID do projeto, o nome do repositório e os valores SHA curtos. Por isso, estes valores são substituídos automaticamente no momento da compilação. Tenha em atenção que tem de criar ou ter um repositório do Docker no Artifact Registry para armazenar a imagem.
```
# Docker Build
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 
         'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', '.']
```
Enviar o contentor para o Artifact Registry: pode armazenar o contentor criado no Artifact Registry, que é um Google Cloud serviço que pode usar para armazenar, gerir e proteger artefactos de compilação. Para isso, tem de ter um repositório do Docker existente no Artifact Registry. Para configurar o Cloud Build de modo a armazenar a imagem num repositório Docker do Artifact Registry, adicione um passo de compilação com os seguintes campos:
- name: defina o valor deste campo como gcr.io/cloud-builders/docker para usar a imagem do criador docker oficial para a sua tarefa.
- args: adicione os argumentos do comando docker push como valores deste campo. Para o URL de destino, introduza o repositório Docker do Artifact Registry onde quer armazenar a imagem.
O seguinte passo de compilação envia a imagem que compilou no passo anterior para o Artifact Registry:
```
# Docker push to Google Artifact Registry
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA']
```
Implemente o contentor no Cloud Run: para implementar a imagem no Cloud Run, adicione um passo de compilação com os seguintes campos:
- name: defina o valor deste campo como google/cloud-sdk para usar a imagem da CLI gcloud para invocar o comando gcloud para implementar a imagem no Cloud Run.
- args: adicione os argumentos do comando gcloud run deploy como os valores deste campo.
O seguinte passo de compilação implementa a imagem criada anteriormente no Cloud Run:
```
# Deploy to Cloud Run
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['run', 'deploy', 'helloworld-${SHORT_SHA}', 
         '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', 
         '--region', 'us-central1', '--platform', 'managed']
```

Guardar registos de testes no Cloud Storage: pode configurar o Cloud Build para armazenar quaisquer registos de testes no Cloud Storage especificando uma localização e um caminho de contentor existentes para os registos de testes.

O seguinte passo de compilação armazena os registos de testes que guardou no ficheiro XML JUNIT num contentor do Cloud Storage:

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml

O fragmento seguinte mostra o ficheiro de configuração de compilação completo para os passos anteriores:

steps:
  # Run tests and save to file
  - name: golang:1.24
    entrypoint: /bin/bash
    args: 
      - -c
      - |
        go install github.com/jstemmer/go-junit-report/v2@latest
        2>&1 go test -timeout 1m -v ./... | /go/bin/go-junit-report -set-exit-code -iocopy -out ${SHORT_SHA}_test_log.xml

  # Docker Build
  - name: 'gcr.io/cloud-builders/docker'
    args: ['build', '-t', 
           'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', '.']

  # Docker push to Google Artifact Registry
  - name: 'gcr.io/cloud-builders/docker'
    args: ['push', 'us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA']

  # Deploy to Cloud Run
  - name: 'gcr.io/cloud-builders/gcloud'
    args: ['run', 'deploy', 'helloworld-${SHORT_SHA}', 
           '--image=us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA', 
           '--region', 'us-central1', '--platform', 'managed']

# Save test logs to Google Cloud Storage
artifacts:
  objects:
    location: gs://$_BUCKET_NAME/
    paths:
      - ${SHORT_SHA}_test_log.xml
# Store images in Google Artifact Registry
images:
  - us-central1-docker.pkg.dev/$PROJECT_ID/$_AR_REPO_NAME/myimage:$SHORT_SHA

Inicie a compilação através da CLI gcloud ou dos acionadores de compilação. Tem de especificar o nome do repositório do Artifact Registry quando iniciar a compilação.

Para especificar o repositório do Artifact Registry quando iniciar a compilação através da CLI gcloud:
```
gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_AR_REPO_NAME="AR_REPO_NAME"
```
Substitua AR_REPO_NAME pelo nome do seu repositório do Artifact Registry.

Para especificar o repositório do Artifact Registry quando cria compilações com acionadores de compilação, especifique o nome do repositório do Artifact Registry no campo Variáveis de substituição quando cria o acionador de compilação.

O que se segue?

Saiba como fazer implementações azul-verde no Compute Engine.
Saiba como criar imagens de contentores.
Saiba como resolver problemas de erros de compilação.

Crie, teste e contentorize aplicações Go Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Autorizações de IAM necessárias

Configurar compilações Go

O que se segue?

Crie, teste e contentorize aplicações Go