Descripción general de la configuración de compilación

Los archivos de configuración de compilación contienen instrucciones para que Cloud Build realice tareas en función de tus especificaciones. Por ejemplo, el archivo de configuración de compilación puede contener instrucciones para compilar, enviar y empaquetar imágenes de Docker.

En esta página, se explica la estructura del archivo de configuración de Cloud Build.

Estructura de un archivo de configuración de compilación

Los archivos de configuración de compilación se modelan mediante el recurso Build de la API de Cloud Build.

Puedes escribir el archivo de configuración de compilación con la sintaxis de YAML o JSON. Si envías solicitudes de compilación mediante herramientas http de terceros como curl, usa la sintaxis de JSON.

Un archivo de configuración de compilación tiene la siguiente estructura:

YAML

steps:
- name: string
  args: [string, string, ...]
  env: [string, string, ...]
  dir: string
  id: string
  waitFor: [string, string, ...]
  entrypoint: string
  secretEnv: string
  volumes: object(Volume)
  timeout: string (Duration format)
- name: string
  ...
- name: string
  ...
timeout: string (Duration format)
queueTtl: string (Duration format)
logsBucket: string
options:
 env: [string, string, ...]
 secretEnv: string
 volumes: object(Volume)
 sourceProvenanceHash: enum(HashType)
 machineType: enum(MachineType)
 diskSizeGb: string (int64 format)
 substitutionOption: enum(SubstitutionOption)
 dynamicSubstitutions: boolean
 logStreamingOption: enum(LogStreamingOption)
 logging: enum(LoggingMode)
substitutions: map (key: string, value: string)
tags: [string, string, ...]
serviceAccount: string
secrets: object(Secret)
availableSecrets: object(Secrets)
artifacts: object (Artifacts)
images:
- [string, string, ...]

JSON

{
    "steps": [
    {
        "name": "string",
        "args": [
            "string",
            "string",
            "..."
        ],
        "env": [
            "string",
            "string",
            "..."
        ],
        "dir": "string",
        "id": "string",
        "waitFor": [
            "string",
            "string",
            "..."
        ],
        "entrypoint": "string",
        "secretEnv": "string",
        "volumes": "object(Volume)",
        "timeout": "string (Duration format)"
    },
    {
        "name": "string"
        ...
    },
    {
        "name": "string"
        ...
    }
    ],
    "timeout": "string (Duration format)",
    "queueTtl": "string (Duration format)",
    "logsBucket": "string",
    "options": {
        "sourceProvenanceHash": "enum(HashType)",
        "machineType": "enum(MachineType)",
        "diskSizeGb": "string (int64 format)",
        "substitutionOption": "enum(SubstitutionOption)",
        "dynamicSubstitutions": "boolean",
        "logStreamingOption": "enum(LogStreamingOption)",
        "logging": "enum(LoggingMode)"
        "env": [
            "string",
            "string",
            "..."
        ],
        "secretEnv": "string",
        "volumes": "object(Volume)",
    },
    "substitutions": "map (key: string, value: string)",
    "tags": [
        "string",
        "string",
        "..."
    ],
    "serviceAccount": "string",
    "secrets": "object(Secret)",
    "availableSecrets": "object(Secrets)",
    "artifacts": "object(Artifacts)",
    "images": [
        "string",
        "string",
        "..."
    ]
}

En cada una de las secciones del archivo de configuración de compilación, se define una parte de la tarea que quieres que ejecute Cloud Build:

Pasos de la compilación

Un paso de compilación especifica una acción que deseas que realice Cloud Build. Para cada paso de compilación, Cloud Build ejecuta un contenedor de Docker como una instancia de docker run. Los pasos de la compilación son similares a los comandos en una secuencia de comandos y te proporcionan la flexibilidad de ejecutar instrucciones arbitrarias en tu compilación. Si puedes empaquetar una herramienta de compilación en un contenedor, Cloud Build puede ejecutarla como parte de tu compilación. De forma predeterminada, Cloud Build ejecuta todos los pasos de una compilación en serie en la misma máquina. Si tienes pasos que pueden ejecutarse en simultáneo, usa la opción waitFor.

Se puede incluir uno o más pasos de compilación en tu archivo de configuración.

Usa el campo steps en el archivo de configuración de compilación para especificar un paso de compilación. A continuación, se muestra un fragmento del tipo de configuración que puedes establecer en el campo steps:

YAML

steps:
- name: 'gcr.io/cloud-builders/kubectl'
  args: ['set', 'image', 'deployment/mydepl', 'my-image=gcr.io/my-project/myimage']
  env:
  - 'CLOUDSDK_COMPUTE_ZONE=us-east4-b'
  - 'CLOUDSDK_CONTAINER_CLUSTER=my-cluster'
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project-id/myimage', '.']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/kubectl",
        "args": [
            "set",
            "image"
            "deployment/mydepl"
            "my-image=gcr.io/my-project/myimage"
        ],
        "env": [
            "CLOUDSDK_COMPUTE_ZONE=us-east4-b",
            "CLOUDSDK_CONTAINER_CLUSTER=my-cluster"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/my-project-id/myimage",
            "."
        ]
    }
    ]
}

name

Usa el campo name de un paso de compilación para especificar un compilador en la nube, que es una imagen de contenedor que ejecuta herramientas comunes. Debes usar un compilador en un paso de compilación para ejecutar tus tareas.

En el siguiente fragmento, se muestran los pasos de compilación mediante los cuales se llaman a los compiladores de bazel, gcloud y docker:

YAML

steps:
- name: 'gcr.io/cloud-builders/bazel'
...

- name: 'gcr.io/cloud-builders/gcloud'
...

- name: 'gcr.io/cloud-builders/docker'
...

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/bazel"
        ...
    },
    {
        "name": "gcr.io/cloud-builders/gcloud"
        ...
    },
    {
        "name": "gcr.io/cloud-builders/docker"
        ...
    }
    ]
}

args

El campo args de un paso de compilación toma una lista de argumentos y los pasa al compilador al que hace referencia el campo name. Los argumentos que se pasan al compilador se pasan a la herramienta que se ejecuta en el compilador, lo que te permite invocar cualquier comando compatible con la herramienta. Si el compilador usado en el paso de compilación tiene un punto de entrada, se usará args como argumentos para ese punto de entrada. Si el compilador no define un punto de entrada, el primer elemento en args se usará como punto de entrada y el resto se usará como argumento.

En el siguiente fragmento, se invoca el comando docker build y, luego, se instalan las dependencias de Maven:

YAML

steps:
- name: 'gcr.io/cloud-builders/mvn'
  args: ['install']
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/my-project-id/myimage', '.']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/mvn",
        "args": [
            "install"
        ]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/my-project-id/myimage",
            "."
        ]
    }
    ]
}

env

El campo env de un paso de compilación toma una lista de las variables de entorno que se usarán cuando se ejecute el paso. Las variables tienen la forma KEY=VALUE.

En la siguiente configuración de compilación, en el campo env del paso de compilación, se establecen la zona de Compute Engine y el clúster de GKE antes de ejecutar kubectl:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/myproject/myimage', '.']
- name: 'gcr.io/cloud-builders/kubectl'
  args: ['set', 'image', 'deployment/myimage', 'frontend=gcr.io/myproject/myimage']
  env:
  - 'CLOUDSDK_COMPUTE_ZONE=us-east1-b'
  - 'CLOUDSDK_CONTAINER_CLUSTER=node-example-cluster'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    },
    {
        "name": "gcr.io/cloud-builders/kubectl",
        "args": [
            "set",
            "image",
            "deployment/myimage",
            "frontend=gcr.io/myproject/myimage"
        ],
        "env": [
            "CLOUDSDK_COMPUTE_ZONE=us-east1-b",
            "CLOUDSDK_CONTAINER_CLUSTER=node-example-cluster"
        ]
    }
    ]
}

dir

Usa el campo dir en un paso de compilación a fin de configurar un directorio de trabajo para usar cuando se ejecute el paso. De forma predeterminada, Cloud Build usa un directorio llamado /workspace como directorio de trabajo. Si el archivo de configuración tiene más de un paso de compilación, los elementos generados mediante un paso se pueden pasar al siguiente mediante la persistencia del directorio /workspace, que te permite configurar una canalización de pasos de compilación que compartan elementos. Si configuras el campo dir en el paso de compilación, el directorio de trabajo se establece en /workspace/<dir>. Si este valor es una ruta relativa, es relativa al directorio de trabajo de la compilación. Si este valor es absoluto, puede que esté fuera del directorio de trabajo de la compilación; en ese caso, el contenido de la ruta de acceso no puede persistir en las ejecuciones de los pasos de la compilación (a menos que se especifique un volumen para esa ruta).

En el siguiente fragmento, se establece el directorio de trabajo en examples/hello_world:

YAML

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['install', '.']
  env: ['PROJECT_ROOT=hello']
  dir: 'examples/hello_world'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/go",
        "args": [
            "install",
            "."
        ],
        "env": [
            "PROJECT_ROOT=hello"
        ],
        "dir": "examples/hello_world"
    }
    ]
}

timeout

Usa el campo timeout en un paso de compilación a fin de establecer un límite de tiempo para ejecutar el paso. Si no configuras este campo, el paso no tendrá un límite de tiempo y se podrá ejecutarse hasta que se complete o hasta que se agote el tiempo de espera de la compilación. El campo timeout de un paso de compilación no debe superar el valor timeout especificado para una compilación. timeout debe especificarse en segundos con un máximo de nueve dígitos decimales, terminado en “s”. Ejemplo: “3.5s”.

En la siguiente configuración de compilación, se agota el tiempo de espera del paso ubuntu después de 500 segundos:

YAML

steps:
- name: 'ubuntu'
  args: ['sleep', '600']
  timeout: 500s
- name: 'ubuntu'
  args: ['echo', 'hello world, after 600s']

JSON

{
    "steps": [
    {
        "name": "ubuntu",
        "args": [
            "sleep",
            "600"
        ],
        "timeout": "500s"
    },
    {
        "name": "ubuntu",
        "args": [
            "echo",
            "hello world, after 600s"
        ]
    }
    ]
}

id

Usa el campo id a fin de establecer un identificador único para un paso de compilación. id se usa con el campo waitFor para establecer el orden en el que se deben ejecutar los pasos de compilación. A fin de obtener instrucciones para usar id y waitFor, consulta Configura el orden de los pasos de compilación.

waitFor

Usa el campo waitFor del paso de compilación para especificar qué pasos se deben ejecutar antes que dicho paso. Si no se proporciona ningún valor en waitFor, el paso de compilación no se ejecutará hasta que todos los pasos de compilación de la solicitud de compilación se completen de manera correcta. A fin de obtener instrucciones para usar id y waitFor, consulta Configura el orden de los pasos de compilación.

entrypoint

Usa entrypoint en un paso de compilación para especificar un punto de entrada si no quieres usar el predeterminado del compilador. Si no configuras este campo, Cloud Build usará el punto de entrada del compilador. En el siguiente fragmento, se establecen los puntos de entrada para el paso de compilación npm:

YAML

steps:
- name: 'gcr.io/cloud-builders/npm'
  entrypoint: 'node'
  args: ['--version']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/npm",
        "entrypoint": "node",
        "args": [
            "--version"
        ]
    }
    ]
}

secretEnv

Se trata de una lista de variables de entorno que se encriptan con una clave criptográfica de Cloud KMS. Estos valores se deben especificar en los secretos de la compilación. Para obtener información sobre el uso de este campo, consulta Uso de la variable encriptada en las solicitudes de compilación.

volumes

Un Volume es un volumen de contenedor de Docker que se activa en los pasos de la compilación para conservar archivos en estos pasos. Cuando Cloud Build ejecuta un paso de compilación, se activa un volumen workspace en /workspace de forma automática. Se pueden especificar volúmenes adicionales para que se activen en los contenedores de los pasos de compilación mediante el campo volumes de tus pasos.

Por ejemplo, el siguiente archivo de configuración de compilación escribe un archivo en un volumen en el primer paso y lo lee en el segundo paso. Si en estos pasos no se especificó la ruta de acceso /persistent_volume como un volumen persistente, el archivo se escribirá en esa ruta en el primer paso y se descartará antes de que se ejecute el segundo paso. Cuando se especifica el volumen con el mismo nombre en ambos pasos, el contenido de /persistent_volume del primer paso se conserva en el segundo.

YAML

steps:
- name: 'ubuntu'
  volumes:
  - name: 'vol1'
    path: '/persistent_volume'
  entrypoint: 'bash'
  args:
  - '-c'
  - |
        echo "Hello, world!" > /persistent_volume/file
- name: 'ubuntu'
  volumes:
  - name: 'vol1'
    path: '/persistent_volume'
  args: ['cat', '/persistent_volume/file']

JSON

  {
    "steps": [
      {
        "name": "ubuntu",
        "volumes": [
          {
            "name": "vol1",
            "path": "/persistent_volume"
          }
        ],
        "entrypoint": "bash",
        "args": [
          "-c",
          "echo \"Hello, world!\" > /persistent_volume/file\n"
        ]
      },
      {
        "name": "ubuntu",
        "volumes": [
          {
            "name": "vol1",
            "path": "/persistent_volume"
          }
        ],
        "args": [
          "cat",
          "/persistent_volume/file"
        ]
     }
    ]
  }

timeout

Usa el campo timeout para que se especifique durante cuánto tiempo debe ejecutarse una compilación con un nivel de detalle por segundo. Una vez transcurrido ese tiempo, el trabajo en la compilación finalizará y el estado de compilación será TIMEOUT. Si timeout no se establece, se aplicará un timeout predeterminado de 10 minutos a la compilación. El valor máximo que se puede aplicar a timeout es de 24 horas. timeout debe especificarse en segundos con un máximo de nueve dígitos decimales, terminado en “s”. Ejemplo: “3.5s”.

En el siguiente fragmento, timeout se establece en 660 segundos para evitar que la compilación agote el tiempo de espera debido a una suspensión:

YAML

steps:
- name: 'ubuntu'
  args: ['sleep', '600']
timeout: 660s

JSON

{
    "steps": [
    {
        "name": "ubuntu",
        "args": [
            "sleep",
            "600"
        ]
    }
    ],
    "timeout": "660s"
}

queueTtl

Usa el campo queueTtl para especificar la cantidad de tiempo que se puede poner en cola una compilación. Si una compilación se encuentra en la cola durante más tiempo que el valor establecido en queueTtl, la compilación vence y el estado de compilación se establece en EXPIRED. queueTtl comienza a marcar el número desde createTime. queueTtl debe especificarse en segundos con hasta nueve dígitos fraccionarios, terminados en “s”, por ejemplo, “3.5s”.

En el siguiente fragmento, timeout se estableció en “20s” y queueTtl se estableció en “10s”. queueTtl comienza a marcar el tiempo en createTime, que es el momento en el que se solicita la compilación, y timeout comienza a marcar en startTime, que es el momento en que comienza la compilación. Por lo tanto, queueTtl vencerá en createTime + 10, a menos que la compilación comience en ese momento.

YAML

steps:
- name: 'ubuntu'
  args: ['sleep', '5']
timeout: 20s
queueTtl: 10s

JSON

{
    "steps": [
    {
        "name": "ubuntu",
        "args": [
            "sleep",
            "5"
        ]
    }
    ],
    "timeout": "20s",
    "queueTtl": "10s"
}

logsBucket

Establece el campo logsBucket de una compilación para especificar un depósito de Cloud Storage en el que se deben escribir los registros. Si no configuras este campo, Cloud Build usará un bucket predeterminado para almacenar tus registros de compilación.

En el siguiente fragmento, se establece un bucket de registros para almacenar registros de compilación:

YAML

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['install', '.']
logsBucket: 'gs://mybucket'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/go",
        "args": [
            "install",
            "."
        ]
    }
    ],
    "logsBucket": "gs://mybucket"
}

options

Usa el campo a fin de especificar los siguientes optionsargumentos opcionales para la compilación:

env: Una lista de definiciones de variables de entorno globales que existirán para todos los pasos de compilación en esta compilación. Si una variable se define de forma global y en un paso de compilación, la variable usará el valor del paso de compilación. Los elementos tienen formato KEY=VALUE para la variable de entorno KEY que recibe el valor VALUE.

secretEnv: Lista de variables de entorno globales, encriptadas mediante una clave criptográfica de Cloud Key Management Service, que estará disponible para todos los pasos de esta compilación. Estos valores se deben especificar en el Secret de la compilación.

volumes: Lista de volúmenes para activar en TODOS los pasos de compilación a nivel global. Cada volumen se crea como un volumen vacío antes de comenzar el proceso de compilación. Una vez que finaliza la compilación, los volúmenes y sus contenidos se descartan. Los nombres y las rutas de acceso de los volúmenes globales no pueden entrar en conflicto con los volúmenes definidos en un paso de compilación. El uso de un volumen global en una compilación con un solo paso no es válido, ya que significa una solicitud de compilación con una configuración incorrecta.

sourceProvenanceHash: Establece la opción sourceProvenanceHash a fin de especificar el algoritmo hash para la procedencia de la fuente. En el siguiente fragmento, se especifica que el algoritmo hash es SHA256:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/myproject/myimage', '.']
options:
    sourceProvenanceHash: ['SHA256']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    }
    ],
    "options": {
        "sourceProvenanceHash": ["SHA256"]
    }
}

machineType: Cloud Build proporciona cuatro tipos de máquinas virtuales con alta capacidad de CPU para ejecutar tus compilaciones: dos tipos de máquinas. con 8 CPU y dos tipos de máquinas con 32 CPU. El tipo de máquina predeterminado es 1 CPU. Solicitar una máquina virtual con alta capacidad de CPU puede aumentar el tiempo de inicio de tu compilación. Agrega la opción machineType para solicitar una máquina virtual con una capacidad de CPU más alta:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/myproject/myimage', '.']
options:
 machineType: 'E2_HIGHCPU_8'

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    },
    ],
    "options": {
        "machineType": "E2_HIGHCPU_8"
    }
}

Para obtener más información sobre el uso de la opción machineType, consulta Acelera tus compilaciones.

diskSizeGb: Usa la opción diskSizeGb a fin de solicitar un tamaño de disco personalizado para la compilación. El tamaño máximo que puedes solicitar es de 1,000 GB.

En el siguiente fragmento, se solicita un tamaño de disco de 200 GB:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/myproject/myimage', '.']
options:
 diskSizeGb: 200

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    }
    ],
    "options": {
        "diskSizeGb": 200
    }
}

logStreamingOption: Usa esta opción para especificar si deseas transmitir los registros de compilación a Cloud Storage. De forma predeterminada, Cloud Build recopila los registros de compilación cuando finaliza la compilación; esta opción especifica si deseas transmitir los registros de compilación en tiempo real a través del proceso de compilación. En el siguiente fragmento, se especifica que los registros de compilación se transmiten a Cloud Storage:

YAML

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['install', '.']
options:
 logStreamingOption: STREAM_ON

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/go",
        "args": [
            "install",
            "."
        ]
    }
    ],
    "options": {
        "logStreamingOption": "STREAM_ON"
    }
}

logging: Usa esta opción para especificar si deseas almacenar registros en Cloud Logging o Cloud Storage. Si no estableces esta opción, Cloud Build almacenará los registros tanto en Cloud Logging como en Cloud Storage. Puedes establecer la opción logging en GCS_ONLY para almacenar los registros solo en Cloud Storage. En el siguiente fragmento, se especifica que los registros se almacenan en Cloud Storage:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/myproject/myimage', '.']
options:
 logging: GCS_ONLY

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    }
    ],
    "options": {
        "logging": "GCS_ONLY"
    }
}

dynamic_substitutions: Usa esta opción para habilitar o inhabilitar de forma explícita la expansión de parámetros de Bash en sustituciones. Si un activador invoca tu compilación, el campo dynamic_substitutions siempre se establece en verdadero y no es necesario especificarlo en tu archivo de configuración de compilación. Si tu compilación se invoca de forma manual, debes establecer el campo dynamic_substitutions como verdadero para que las expansiones de parámetros de Bash se interpreten cuando ejecutas tu compilación.

substitutionOption: Establecerás esta opción, junto con el campo substitutions que se encuentra a continuación, para especificar el comportamiento cuando hay un error en las verificaciones de sustitución.

substitutions

Usa sustituciones en el archivo de configuración de compilación para sustituir variables específicas cuando se compila. Las sustituciones son útiles para las variables cuyo valor no se conoce hasta el momento de la compilación o si deseas reutilizar una solicitud de compilación existente con diferentes valores de variable. De forma predeterminada, la compilación muestra un error si falta una variable de sustitución o una sustitución. Sin embargo, puedes usar la opción ALLOW_LOOSE para omitir esta verificación.

En el siguiente fragmento, se usan sustituciones para imprimir “hello world”. La opción de sustitución ALLOW_LOOSE está establecida, lo que significa que la compilación no mostrará un error si falta una sustitución o una variable de sustitución.

YAML

steps:
- name: 'ubuntu'
  args: ['echo', 'hello ${_SUB_VALUE}']
substitutions:
    _SUB_VALUE: world
options:
    substitution_option: 'ALLOW_LOOSE'

JSON

{
    "steps": [
    {
        "name": "ubuntu",
        "args": [
            "echo",
            "hello ${_SUB_VALUE}"
        ]
    }
    ],
    "substitutions": {
        "_SUB_VALUE": "world"
},
    "options": {
        "substitution_option": "ALLOW_LOOSE"
    }
}

Para obtener instrucciones adicionales sobre el uso de substitutions, consulta Sustituye valores de variables.

tags

Usa el campo tags para organizar tus compilaciones en grupos y filtrarlas. Mediante la siguiente configuración, se establecen dos etiquetas con el nombre mytag1 y mytag2:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  ...
- name: 'ubuntu'
  ...
tags: ['mytag1', 'mytag2']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker"
    },
    {
        "name": "ubuntu"
    }
    ],
    "tags": [
        "mytag1",
        "mytag2"
    ]
}

secretos disponibles

Usa este campo para usar un secreto del administrador de secretos con Cloud Build. Para obtener más información, consulta Usa secretos.

secrets

Secreto empareja un conjunto de variables de entorno secretas que contienen valores encriptados con la clave de Cloud KMS que se puede usar para desencriptar el valor.

número

Usa este campo para especificar la cuenta de servicio de IAM que se usará en el momento de la compilación. Para obtener más información, consulta Configura cuentas de servicio especificadas por el usuario.

imágenes

En el campo images del archivo de configuración de compilación, se especifican una o más imágenes de Docker que Cloud Build enviará a Container Registry. Es posible que tengas una compilación que realice tareas sin producir ninguna imagen de Docker, pero si compilas imágenes y no las envías a Container Registry, las imágenes se descartan cuando finaliza la compilación. Si durante la compilación no se produce una imagen especificada, la compilación fallará. Para obtener más información sobre el almacenamiento de imágenes, consulta Almacena imágenes y artefactos.

Mediante la siguiente configuración de compilación, se establece el campo images a fin de almacenar la imagen de compilación:

YAML

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

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/myproject/myimage",
            "."
        ]
    }
    ],
    "images": [
        "gcr.io/myproject/myimage"
    ]
}

artifacts

En el campo artifacts del archivo de configuración de compilación, se especifican uno o más artefactos, que no son contenedores, que se almacenarán en Cloud Storage. Para obtener más información sobre el almacenamiento de artefactos que no son contenedores, consulta Almacena imágenes y artefactos.

Mediante la siguiente configuración de compilación, se establece el campo artifacts para almacenar el paquete de Go integrado en gs://mybucket/:

YAML

steps:
- name: 'gcr.io/cloud-builders/go'
  args: ['build', 'my-package']
artifacts:
  objects:
    location: 'gs://mybucket/'
    paths: ['my-package']

JSON

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/go",
        "args": [
            "build",
            "my-package"
        ]
    }
    ],
    "artifacts": {
      "objects": {
        "location": "gs://mybucket/",
        "paths": [
            "my-package"
        ]
      }
    }
}

Usa Dockerfiles

Si estás ejecutando compilaciones de Docker en Cloud Build mediante la herramienta de gcloud o los activadores de compilación, solo puedes usar un Dockerfile para compilar la imagen. No se necesita un archivo de configuración de compilación diferente. Si deseas realizar más ajustes en tus compilaciones de Docker, puedes proporcionar un archivo de configuración de compilación además del Dockerfile. Para obtener instrucciones sobre cómo compilar una imagen de Docker mediante un Dockerfile, consulta la Guía de inicio rápido para Docker.

Red de Cloud Build

Cuando Cloud Build ejecuta cada paso de compilación, conecta el contenedor del paso a una red local de Docker llamada cloudbuild. La red cloudbuild aloja Credenciales predeterminadas de la aplicación (ADC) que los servicios de Google Cloud pueden usar para encontrar las credenciales de forma automática. Si ejecutas contenedores de Docker anidados y quieres exponer ADC en un contenedor subyacente o mediante gsutil o gcloud en un paso docker, usa la marca --network en tu paso de Docker build:

YAML

steps:
- name: gcr.io/cloud-builders/docker
  args: ["build","--network=cloudbuild", "."]

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "--network=cloudbuild",
        "."
      ]
   }
  ]
}

Pasos siguientes