Compila, prueba y aloja en contenedores aplicaciones de Go

En esta página, se explica cómo usar Cloud Build para compilar, probar, contenerizar y, luego, implementar aplicaciones en Go, y cómo guardar los registros de prueba en Cloud Storage.

Antes de comenzar

En las instrucciones de esta página se supone que estás familiarizado con Go. Además, ten en cuenta la siguiente información:

  • Habilita las APIs de Cloud Build, Cloud Run y Artifact Registry si alguna aún no está habilitada.

    Roles necesarios para habilitar las APIs

    Para habilitar APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén más información para otorgar roles.

    Habilitar las API

  • Para ejecutar los comandos de gcloud en esta página, instala Google Cloud CLI.
  • Ten a mano tu proyecto de Go.
  • Si deseas contenerizar tu app en Go con Cloud Build, necesitarás un Dockerfile junto con tu código fuente.
  • Si deseas almacenar el contenedor compilado en Artifact Registry, crea un repositorio de Docker en Artifact Registry.
  • Si deseas almacenar registros de prueba en Cloud Storage, crea un bucket en Cloud Storage.

Permisos de IAM obligatorios

Si deseas obtener instrucciones para otorgar estos roles, consulta Cómo otorgar un rol con la página de IAM.

Cómo configurar compilaciones de Go

La imagen golang pública de Docker Hub es compatible con la compilación mediante módulos de Go. Usar esta imagen como un paso de compilación en el archivo de configuración de Cloud Build te permite invocar comandos de go dentro de la imagen. Los argumentos que se pasan a este paso de compilación se pasan directamente a la herramienta de golang, lo que te permite ejecutar cualquier comando de go en esta imagen.

En esta sección, se explica un ejemplo de archivo de configuración de compilación para una app de Go. Tiene pasos de compilación para compilar la app, agregar pruebas de unidades y, después de que se aprueben las pruebas, crear contenedores en la app y, luego, implementarla.

Para compilar la aplicación de Go, sigue estos pasos:

  1. En el directorio raíz del proyecto, crea un archivo de configuración de Cloud Build llamado cloudbuild.yaml.

  2. Compila y prueba: Si definiste pruebas de unidades en tu aplicación, puedes configurar Cloud Build para que ejecute las pruebas. Para ello, agrega los siguientes campos en un paso de compilación:

    • name: Establece el valor de este campo en golang para usar la imagen de Go desde Docker Hub para tu tarea.
    • entrypoint: Configura el valor de este campo en /bin/bash. Esto te permite ejecutar comandos de Bash de varias líneas directamente desde el paso de compilación.

    • args: En el campo args de un paso de compilación, se toma una lista de argumentos y se los pasa a la imagen a la que se hace referencia en el campo name. En el siguiente ejemplo, el campo args toma los argumentos para lo siguiente:

      • Ejecutar el generador de registros de prueba para descargar el resultado del registro de prueba.
      • Imprimir el resultado del registro.
      • Guardar resultados de pruebas en sponge.log.
      • Se generan los resultados en sponge.log en un archivo en formato XML de JUNIT. El nombre del archivo XML de JUnit se construye con la versión abreviada del ID de la confirmación asociada a tu compilación. Los pasos de compilación posteriores guardarán los registros de este archivo en Cloud Storage.
      steps:
  # Run tests and save to file
  - name: golang:1.26-trixie
    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

  3. Crea contenedores en la app: Después de agregar el paso de compilación a fin de garantizar que las pruebas se hayan aprobado, puedes compilar la aplicación. Cloud Build proporciona una imagen de Docker prediseñada que puedes usar para contenerizar tu aplicación en Go. Para organizar tu app en contenedores, agrega los siguientes campos en un paso de compilación:

    • name: Establece el valor de este campo en gcr.io/cloud-builders/docker para usar la imagen de Docker prediseñada para tu tarea.
    • args: Agrega los argumentos para el comando docker build como valores para este campo.

    En el siguiente paso de compilación, se compila la imagen myimage y se etiqueta con la versión corta de tu ID de confirmación. El paso de compilación usa sustituciones para el ID del proyecto, el nombre del repositorio y los valores SHA cortos, por lo que estos valores se sustituyen automáticamente en el tiempo de compilación. Ten en cuenta que deberás crear o tener un repositorio de Docker existente en Artifact Registry para almacenar la imagen.

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

  4. Envía el contenedor a Artifact Registry: Puedes almacenar el contenedor compilado en Artifact Registry, que es un Google Cloud servicio que puedes usar para almacenar, administrar y proteger artefactos de compilación. Para hacer esto, deberás tener un repositorio de Docker existente en Artifact Registry. Para configurar Cloud Build a fin de almacenar la imagen en un repositorio de Docker de Artifact Registry, agrega un paso de compilación con los siguientes campos:

    • name: Establece el valor de este campo en gcr.io/cloud-builders/docker para usar la imagen oficial del compilador docker para tu tarea.
    • args: Agrega los argumentos para el comando docker push como valores de este campo. Para la URL de destino, ingresa el repositorio de Docker de Artifact Registry en el que deseas almacenar la imagen.

    En el siguiente paso de compilación, se envía la imagen que compilaste en el paso anterior a 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']

  5. Implementa el contenedor en Cloud Run: Para implementar la imagen en Cloud Run, agrega un paso de compilación con los siguientes campos:

    • name: Establece el valor de este campo en google/cloud-sdk para usar la imagen de la gcloud CLI y, así, invocar el comando gcloud para implementar la imagen en Cloud Run.
    • args: Agrega los argumentos para el comando gcloud run deploy como los valores de este campo.

    En el siguiente paso de compilación, se implementa la imagen compilada con anterioridad en 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']

  6. Guardar registros de prueba en Cloud Storage: Puedes configurar Cloud Build para almacenar cualquier registro de prueba en Cloud Storage si especificas una ubicación de bucket existente y una ruta de acceso a los registros de prueba.

    En el siguiente paso de compilación, se almacenan los registros de prueba que guardaste en el archivo XML JUNIT en un bucket de Cloud Storage:

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

    En el siguiente fragmento, se muestra el archivo de configuración de compilación completo para los pasos anteriores:

    steps:
  # Run tests and save to file
  - name: golang:1.26-trixie
    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

  7. Inicia la compilación con la CLI de gcloud o los activadores de compilación. Debes especificar el nombre del repositorio de Artifact Registry cuando inicies la compilación.

    Para especificar el repositorio de Artifact Registry cuando inicies la compilación con gcloud CLI, haz lo siguiente:

    gcloud builds submit --region=us-west2 --config=cloudbuild.yaml \
    --substitutions=_AR_REPO_NAME="AR_REPO_NAME"

    Reemplaza AR_REPO_NAME por el nombre de tu repositorio de Artifact Registry.

    Para especificar el repositorio de Artifact Registry cuando compiles con activadores de compilación, especifica el nombre de tu repositorio de Artifact Registry en el campo Variables de sustitución cuando crees el activador de compilación.

¿Qué sigue?