Compilar, probar y contenerizar aplicaciones de Go

En esta página se explica cómo usar Cloud Build para compilar, probar, contenerizar y desplegar aplicaciones Go, así como para guardar los registros de pruebas en Cloud Storage.

Antes de empezar

En las instrucciones de esta página se presupone que tienes conocimientos de Go. Además:

  • Enable the Cloud Build, Cloud Run, and Artifact Registry APIs.

    Enable the APIs

  • Para ejecutar los comandos gcloud de esta página, instala Google Cloud CLI.
  • Ten a mano tu proyecto de Go.
  • Si quieres crear un contenedor para tu aplicación Go con Cloud Build, necesitarás un Dockerfile junto con tu código fuente.
  • Si quieres almacenar el contenedor compilado en Artifact Registry, crea un repositorio de Docker en Artifact Registry.
  • Si quieres almacenar los registros de pruebas en Cloud Storage, crea un segmento en Cloud Storage.

Permisos de gestión de identidades y accesos necesarios

Para obtener instrucciones sobre cómo conceder estos roles, consulta el artículo Conceder un rol mediante la página IAM.

Configurar compilaciones de Go

La imagen pública golang de Docker Hub admite la compilación con módulos Go. Si usas esta imagen como paso de compilación en tu archivo de configuración de Cloud Build, podrás invocar comandos de go en la imagen. Los argumentos transferidos a este paso de compilación se transfieren directamente a la herramienta golang, lo que te permite ejecutar cualquier comando go en esta imagen.

En esta sección se explica un ejemplo de archivo de configuración de compilación para una aplicación Go. Incluye pasos de compilación para compilar la aplicación, añadir pruebas unitarias y, una vez superadas las pruebas, contenerizar y desplegar la aplicación.

Para compilar tu aplicación de Go, haz lo siguiente:

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

  2. Compilación y prueba: si has definido pruebas unitarias en tu aplicación, puedes configurar Cloud Build para que las ejecute añadiendo los siguientes campos en un paso de compilación:

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

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

      • Ejecutar el formateador de registros de prueba para descargar los resultados de los registros de prueba.
      • Imprimir la salida del registro.
      • Guardando los resultados de la prueba en sponge.log.
      • Genera los resultados en sponge.log en un archivo XML de JUNIT. El nombre del archivo XML de JUNIT se crea a partir de la versión corta del ID de la confirmación asociada a tu compilación. En un paso de compilación posterior, se guardarán los registros de este archivo en 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

  3. Conteneriza la aplicación: después de añadir el paso de compilación para asegurarte de que se han superado las pruebas, puedes compilar la aplicación. Cloud Build proporciona una imagen Docker prediseñada que puedes usar para contenerizar tu aplicación Go. Para contenedorizar tu aplicación, añade los siguientes campos en un paso de compilación:

    • name: asigna el valor gcr.io/cloud-builders/docker a este campo para usar la imagen de Docker precompilada en tu tarea.
    • args: añade los argumentos del comando docker build como valores de este campo.

    El siguiente paso de compilación crea la imagen myimage y la etiqueta con la versión corta del 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 momento de la compilación. Ten en cuenta que debes crear o tener un repositorio de Docker 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 creado en Artifact Registry, que es un Google Cloud servicio que puedes usar para almacenar, gestionar y proteger artefactos de compilación. Para ello, debe tener un repositorio de Docker en Artifact Registry. Para configurar Cloud Build de forma que almacene la imagen en un repositorio de Docker de Artifact Registry, añade un paso de compilación con los siguientes campos:

    • name: asigna el valor gcr.io/cloud-builders/docker a este campo para usar la imagen oficial del compilador docker en tu tarea.
    • args: añade los argumentos del comando docker push como valores de este campo. En la URL de destino, introduce el repositorio Docker de Artifact Registry en el que quieras almacenar la imagen.

    El siguiente paso de compilación envía la imagen que has compilado 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. Despliega el contenedor en Cloud Run: para desplegar la imagen en Cloud Run, añade un paso de compilación con los siguientes campos:

    • name: asigna el valor google/cloud-sdk a este campo para usar la imagen de la CLI de gcloud para invocar el comando gcloud y desplegar la imagen en Cloud Run.
    • args: añade los argumentos del comando gcloud run deploy como valores de este campo.

    El siguiente paso de compilación despliega la imagen compilada anteriormente 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 pruebas en Cloud Storage: puedes configurar Cloud Build para que almacene los registros de pruebas en Cloud Storage. Para ello, especifica la ubicación de un segmento y la ruta de los registros de pruebas.

    El siguiente paso de compilación almacena los registros de prueba que has guardado en el archivo XML de JUNIT en un segmento 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 de los pasos 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

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

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

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

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

    Para especificar el repositorio de Artifact Registry al compilar con activadores de compilación, indique el nombre del repositorio de Artifact Registry en el campo Variables de sustitución al crear el activador de compilación.

Siguientes pasos