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 las 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 a fin de compilar dos imágenes, para las que los archivos del código fuente se encuentran en el directorio de trabajo actual al momento de la compilación, como se indica mediante .. El código fuente para gcr.io/my-project/image2 se encuentra en un 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

steps:
- 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 dispones de un código fuente, puedes ejecutar pruebas de integración y unidades como pasos de compilación. Cada paso de compilación se ejecuta con su contenedor adjunto en una red de Docker local llamada cloudbuild. Para que las pruebas de integración funcionen, se debe especificar el nombre de la red.

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 realizar la implementación en GKE, llama al paso de compilación de gke-deploy de la manera siguiente:

  1. Habilita la API de GKE.

  2. Crea un clúster.

  3. Agrega la función de GKE a la cuenta de servicio:

    1. Abre la página Configuración (Settings) de Cloud Build:

      Abrir la página Configuración (Settings) de Cloud Build

      Verás la página Permisos de cuenta de servicio (Service account permissions):

      Captura de pantalla de la página de permisos de la cuenta de servicio

    2. Configura el estado de la función Programador de Kubernetes Engine (Kubernetes Engine Developer) como Habilitado (Enabled).

  4. Agrega una de las series de pasos de compilación siguientes en tu archivo de configuración de compilación:

    • Agrega estos pasos de compilación si proporcionas tus propios archivos de configuración de Kubernetes que hacen referencia a tu imagen:

      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]
      
    • Agrega estos pasos de compilación si no tienes ningún archivo de configuración de Kubernetes para tu imagen:

      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 compilación llama al paso de compilación de docker para crear una imagen de Docker y enviarla a Container Registry. Luego, la compilación llama al paso de compilación de gke-deploy para realizar la implementación en tu clúster de GKE.

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
  • [LOCATION], la región o zona del clúster
  • [CONFIG], los archivos de configuración de Kubernetes que utilizará gke-deploy run, si existe

App Engine

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

  1. Habilita la API de App Engine.

  2. Agrega la función de App Engine a la cuenta de servicio dela manera siguiente:

    1. Abre la página Configuración (Settings) de Cloud Build:

      Abrir la página Configuración (Settings) de Cloud Build

      Verás la página Permisos de cuenta de servicio (Service account permissions):

      Captura de pantalla de la página de permisos de la cuenta de servicio

    2. Configura el estado de la función Administrador de App Engine (App Engine Admin) como Habilitar (Enable).

  3. Crea un archivo de configuración de compilación que use gcloud app deploy de la manera siguiente:

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

El paso de compilación de 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 de gcloud para que invoque gcloud functions deploy de la siguiente manera:

  1. Habilita la API de Cloud Functions.

  2. Agrega la función Cloud Functions a la cuenta de servicio:

    1. Abre la página Configuración (Settings) de Cloud Build:

      Abrir la página Configuración (Settings) de Cloud Build

      Verás la página Permisos de cuenta de servicio (Service account permissions):

      Captura de pantalla de la página de permisos de la cuenta de servicio

    2. Configura el estado de la función Programador de Cloud Functions (Cloud Functions Developer) como Habilitar (Enable).

    3. Selecciona OTORGAR ACCESO A TODAS LAS CUENTAS DE SERVICIO (GRANT ACCESS TO ALL SERVICE ACCOUNTS) para otorgar la función Usuario de la cuenta de servicio (Service Account User) en todas las cuentas de servicio en el proyecto en tu página.

  3. Crea un archivo de configuración de compilación que use gcloud functions deploy de la manera siguiente:

    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.

Cloud Run

A fin de implementar una aplicación en Cloud Run, llama al paso de compilación de gcloud para invocar gcloud beta run deploy dela manera siguiente:

  1. Habilita la API de Cloud Run.

  2. Agrega la función de Cloud Run a la cuenta de servicio:

    1. Abre la página Configuración (Settings) de Cloud Build:

      Abrir la página Configuración (Settings) de Cloud Build

      Verás la página Permisos de cuenta de servicio (Service account permissions):

      Captura de pantalla de la página de permisos de la cuenta de servicio

    2. Configura el estado de la función Administrador de Cloud Run (Cloud Run Admin) como Habilitar (Enable).

    3. Selecciona OTORGAR ACCESO A TODAS LAS CUENTAS DE SERVICIO (GRANT ACCESS TO ALL SERVICE ACCOUNTS) para otorgar la función Usuario de la cuenta de servicio (Service Account User) en todas las cuentas de servicio en el proyecto en tu página.

  3. Crea un archivo de configuración de compilación que use gcloud beta run deploy de la manera siguiente:

    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]
    

Reemplaza [SERVICE-NAME] y [REGION] por el nombre y la región del servicio de Cloud Run en el que realizas la implementación.

Si empleas Cloud Run en GKE, usa gke en lugar de managed, y --cluster y --cluster-location en lugar del parámetro --region.

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

Si deseas obtener más información sobre la implementación de imágenes en Cloud Run, consulta la sección para realizar implementaciones en Cloud Run.

Firebase

Para usar Firebase en tus compilaciones, crea un paso de compilación personalizado 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 de 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 de gke-deploy se llama para implementar la imagen compilada 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/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"
        ]
    }
    ]
}

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

Documentación de Cloud Build