Compila, prueba y, también, implementa artefactos

En esta página, se explica cómo usar las imágenes de compilación oficial de Cloud Build para escribir configuraciones de compilación a fin de recuperar el código fuente y las dependencias y, además, compilar, implementar y probar artefactos.

Si ya tienes un archivo de configuración de compilación y deseas ejecutar tus compilaciones en Cloud Build, lee Inicia compilaciones de forma manual y Automatiza compilaciones.

Antes de comenzar

Recupera dependencias

Recupera el código fuente o instala dependencias mediante un paso de compilación que ejecuta herramientas como Docker, Git, npm, y 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']

Compila imágenes de contenedores

Para compilar imágenes de contenedores de Docker, usa el paso de compilación docker en el que puedes invocar comandos docker. Los argumentos que se pasan a este paso de compilación se pasarán a docker de forma directa, lo que te permite ejecutar cualquier comando docker en este paso de compilación.

En tu archivo de configuración de compilación, agrega instrucciones para realizar lo siguiente:

  • Llamar al compilador docker y pasar los argumentos para invocar el comando build de Docker. En la configuración de compilación siguiente, el paso de compilación de Docker se llama dos veces para compilar dos imágenes, por lo que los archivos del código fuente se encuentran en el directorio de trabajo actual al momento de la compilación, como indica .. El código fuente para gcr.io/my-project/image2 se encuentra en el directorio dentro del directorio de trabajo actual al momento de la compilación, subdirectory.
  • Agrega el campo images para enviar las imágenes resultantes a 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"]
}

Compila artefactos no contenedores

Cloud Build proporciona pasos de compilación compatibles con lenguajes y herramientas comunes que puedes usar para ejecutar tus compilaciones.

Para compilar artefactos no contenedores, agrega una sección de pasos de compilación que ejecute compiladores como Maven, Gradle, Go, o 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

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

Bazel

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

Ejecuta pruebas de integración y unidad

Si cuentas con un código fuente disponible, puedes ejecutar pruebas de integración y unidad como pasos de compilación.

Supongamos que tienes una aplicación de JavaScript con pruebas de unidades, un Dockerfile que compila una imagen de Docker y pruebas de integración que se ejecutan en esa imagen en ejecución.

Si deseas ejecutar pruebas de integración y de unidades en esta aplicación, debes agregar las instrucciones para lo siguiente en tu archivo de configuración de compilación:

  • Instala dependencias para ejecutar la compilación.
  • Ejecuta la prueba de unidades.
  • Compila la imagen de Docker de la aplicación.
  • Ejecuta la aplicación y dependencias en segundo plano con Docker Compose.
  • Ejecuta las pruebas de integración en la pila de Docker Compose en ejecución.
  • Envía la imagen recién compilada a 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']
    

Implementa artefactos

Como parte tu canalización de implementación continua, Cloud Build puede realizar implementaciones con las herramientas de línea de comandos.

Usa los pasos siguientes para implementar en GKE, App Engine, Cloud Functions y Firebase.

Kubernetes Engine

Para implementar en GKE con kubectl, llama al paso de compilación kubectl a fin de actualizar un recurso de implementación:

  1. Habilita la API de GKE.
  2. Agrega la función IAM de GKE:
    1. En GCP Console, dirígete al menú de IAM.
    2. Desde la lista de cuentas de servicio, haz clic en el menú desplegable Funciones junto a la cuenta de servicio [YOUR-PROJECT-NUMBER]@cloudbuild.gserviceaccount.com de Cloud Build.
    3. Haz clic en Kubernetes Engine y, a continuación, haz clic en el Administrador de Kubernetes Engine.
    4. Haz clic en Guardar.
  3. Agrega el paso de compilación kubectl en tu configuración de compilación:

    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]'
    

Esta compilación llama al paso de compilación docker para crear una imagen de Docker y enviarla a Container Registry. Después, la compilación llama al paso de compilación kubectl para actualizar un recurso de implementación.

Para usar esta configuración de compilación de ejemplo, proporciona la información siguiente:

  • [PROJECT-ID], el ID del proyecto de GCP
  • [IMAGE], el nombre de la imagen y su [TAG] como la versión deseada o el SHA de confirmación
  • [CLUSTER], el nombre del clúster para el que se requieren las credenciales de autenticación
  • [COMPUTE-ZONE], la zona de procesamiento del proyecto
  • [DEPLOYMENT-NAME], el nombre del recurso de implementación de Kubernetes que kubectl set actualizará.

App Engine

Para implementar una aplicación de una imagen de contenedor en App Engine, llama al paso de compilación gcloud con los argumentos para el comando gcloud app deploy:

  1. Habilita la API de App Engine.
  2. Otorga la IAM de App Engine a la cuenta de servicio de Cloud Build:

    1. En GCP Console, dirígete al menú de IAM.
    2. En la lista de miembros, busca [YOUR-PROJECT-NUMBER]@cloudbuild.gserviceaccount.com.
    3. Haz clic en el ícono de lápiz en esa fila para otorgar una función nueva a esa cuenta.
    4. Haz clic en Agregar otra función.
    5. Selecciona App Engine y, a continuación, haz clic en Administrador de App Engine.
    6. Haz clic en Guardar.
    7. Crea un archivo de configuración de compilación que use gcloud app deploy:

      Pasos:

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

El paso de compilación gcloud llama al comando gcloud app deploy para compilar una imagen de contenedor con tu código fuente y, luego, implementa la imagen en App Engine.

Cloud Functions

A fin de implementar una aplicación en Cloud Functions, llama al paso de compilación gcloud para invocar gcloud functions deploy:

  1. Habilita la API de Cloud Functions.
  2. Otorga la función de Desarrollador de Cloud Functions a la cuenta de servicio de Cloud Build:
    1. En GCP Console, dirígete al menú de IAM.
    2. En la lista de miembros, busca [PROJECT_NUMBER]@cloudbuild.gserviceaccount.com.
    3. Haz clic en el ícono de lápiz en esa fila para otorgar una función nueva a esa cuenta.
    4. Haz clic en Agregar otra función.
    5. Selecciona Cloud Functions y, a continuación, Desarrollador de Cloud Functions.
    6. Haz clic en Guardar.
  3. Otorga la función de Usuario de cuenta de servicio de IAM a la cuenta de servicio de Cloud Build en la cuenta de servicio del entorno de ejecución de Cloud Functions:
    1. En GCP Console, dirígete al menú de cuentas de servicio.
    2. En la lista de miembros, busca [PROJECT_ID]@appspot.gserviceaccount.com.
    3. Selecciona la cuenta de servicio anterior y haz clic en MOSTRAR PANEL DE INFORMACIÓN en la esquina superior derecha.
    4. En el panel Permisos, haz clic en el botón Agregar miembro.
    5. Ingresa la cuenta de servicio de Cloud Build ([PROJECT_NUMBER]@cloudbuild.gserviceaccount.com) en el campo de entrada Miembro nuevo.
    6. En el menú desplegable Función, selecciona Cuentas de servicio y, a continuación Usuario de cuenta de servicio.
    7. Haz clic en Guardar.
  4. Crea un archivo de configuración de compilación que use gcloud functions deploy:

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

Esto compila el código fuente de la aplicación y llama a gcloud functions deploy para implementar la aplicación Cloud Functions.

Firebase

Puedes usar Firebase en tus compilaciones si creas un paso de compilación personalizada de Firebase.

Para crear un paso de compilación de Firebase, crea un Dockerfile y un archivo de configuración de compilación a partir de los ejemplos siguientes.

Crea un Dockerfile con los contenidos siguientes. Con este, se instala firebase, la herramienta de línea de comandos de Firebase, cuando la llama la compilación:

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

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

Crea una configuración de compilación llamada cloudbuild.yaml con el contenido siguiente. Esta configuración de compilación usa Dockerfile para organizar el contenedor firebase-tools como firebase. A continuación, la compilación envía la imagen organizada en el contenedor a Container Registry para usarlo en compilaciones posteriores:

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

Con Dockerfile y cloudbuild.yaml en el mismo directorio, ejecuta el comando siguiente desde tu shell o ventana de terminal:

gcloud builds submit --config=cloudbuild.yaml .

El comando gcloud builds envía una compilación a Cloud Build que usa la configuración de compilación cloudbuild.yaml y la fuente en el directorio actual (indicado por .). La compilación instala la herramienta firebase en el entorno. Luego, la herramienta se organiza y se envía a tu Container Registry.

Para llamar a firebase en tus compilaciones, agrega el paso de compilación gcr.io/[PROJECT_ID]/firebase a tu configuración de compilación:

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 esta configuración de compilación, proporciona el valor [FIREBASE_TOKEN], que es el token de autenticación de Firebase que hubieras generado.

Ejemplos de archivos de configuración de compilación

Compilación activada desde GitHub

En la configuración siguiente, se muestra una compilación simple que se activa desde GitHub. Este tipo de configuración, por lo general, se usa en una canalización IC/EC.

En este ejemplo, sucede lo siguiente:

  • El paso de compilación npm se llama para instalar las dependencias y ejecutar las pruebas de unidades.
  • El paso de compilación docker se llama para compilar una imagen de Docker de la aplicación y enviar la imagen a Container Registry.
  • El paso de compilación kubectl se llama para implementar la imagen de compilación en el clúster de 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"
        ]
    }
    ]
}

Escribe solicitudes de compilación sin enviar imágenes

Puedes usar Cloud Build para realizar tareas arbitrarias sin producir imágenes de Docker.

En el ejemplo siguiente, se realizan estas acciones:

  • Se usa docker para compilar una herramienta de análisis.
  • Se incorporan algunos datos desde el directorio data-to-analyze.
  • Se envían los resultados del análisis a un depósito de 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"
      ]
    }
  ]
}

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...