Esquema del archivo de 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 el esquema del archivo de configuración de Cloud Build. Para obtener instrucciones sobre cómo crear y usar un archivo de configuración de compilación, consulta Crea un archivo de configuración de compilación básico.

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.

Nota: Si usas VS Code o IntelliJ IDE, puedes usar Cloud Code para crear los archivos de configuración YAML. Cloud Code está integrado en el editor de Cloud Shell y no requiere ninguna configuración. Para obtener más información, consulta Cloud Code para VS Code y Cloud Code para IntelliJ.

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

YAML

steps:
- name: string
  args: [string, string, ...]
  env: [string, string, ...]
  allowFailure: boolean
  allowExitCodes: [string (int64 format), string (int64 format), ...]
  dir: string
  id: string
  waitFor: [string, string, ...]
  entrypoint: string
  secretEnv: string
  volumes: object(Volume)
  timeout: string (Duration format)
  script: string
  automapSubstitutions: boolean
- 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
 automapSubstitutions: boolean
 logStreamingOption: enum(LogStreamingOption)
 logging: enum(LoggingMode)
 defaultLogsBucketBehavior: enum(DefaultLogsBucketBehavior)
 pool: object(PoolOption)
 requestedVerifyOption: enum(RequestedVerifyOption)
substitutions: map (key: string, value: string)
tags: [string, string, ...]
serviceAccount: string
secrets: object(Secret)
availableSecrets: object(Secrets)
artifacts: object(Artifacts)
  mavenArtifacts: [object(MavenArtifact), ...]
  pythonPackages: [object(PythonPackage), ...]
  npmPackages: [object(npmPackage), ...]
images:
- [string, string, ...]

JSON

{
    "steps": [
    {
        "name": "string",
        "args": [
            "string",
            "string",
            "..."
        ],
        "env": [
            "string",
            "string",
            "..."
        ],
        "allowFailure": "boolean",
        "allowExitCodes: [
            "string (int64 format)",
            "string (int64 format)",
            "..."
        ],
        "dir": "string",
        "id": "string",
        "waitFor": [
            "string",
            "string",
            "..."
        ],
        "entrypoint": "string",
        "secretEnv": "string",
        "volumes": "object(Volume)",
        "timeout": "string (Duration format)",
        "script" : "string",
        "automapSubstitutions" : "boolean"
    },
    {
        "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",
        "automapSubstitutions": "boolean",
        "logStreamingOption": "enum(LogStreamingOption)",
        "logging": "enum(LoggingMode)"
        "defaultLogsBucketBehavior": "enum(DefaultLogsBucketBehavior)"
        "env": [
            "string",
            "string",
            "..."
        ],
        "secretEnv": "string",
        "volumes": "object(Volume)",
        "pool": "object(PoolOption)"
        "requestedVerifyOption": "enum(RequestedVerifyOption)"
    },
    "substitutions": "map (key: string, value: string)",
    "tags": [
        "string",
        "string",
        "..."
    ],
    "serviceAccount": "string",
    "secrets": "object(Secret)",
    "availableSecrets": "object(Secrets)",
    "artifacts": "object(Artifacts)",
      "mavenArtifacts": ["object(MavenArtifact)", ...],
      "pythonPackages": ["object(PythonPackage)", ...],
      "npmPackages": ["object(npmPackage)", ...],
    "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.

Puedes incluir hasta 300 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.

Puedes crear hasta 100 argumentos por paso. La longitud máxima del argumento es 10,000 caracteres.

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 para configurar un directorio de trabajo para usar cuando se ejecute el contenedor del paso. Si configuras el campo dir en el paso de compilación, haz lo siguiente: el directorio de trabajo está configurado como /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 de código, se establece el directorio de trabajo para el paso de compilación de la siguiente manera: /workspace/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"
        ]
    }
    ]
}

Nota: El campo timeout existe para el paso de compilación y la compilación: En el campo timeout de un paso de compilación, se especifica la cantidad de tiempo que puede durar la ejecución del paso. A su vez, en el campo timeout de una compilación, se especifica durante cuánto tiempo puede ejecutarse la compilación.

script

Usa el campo script en un paso de compilación para especificar una secuencia de comandos de shell que se ejecutará en el paso. Si especificas script en un paso de compilación, no puedes especificar args ni entrypoint en el mismo paso. Para obtener instrucciones sobre el uso del campo script, consulta Cómo ejecutar secuencias de comandos de bash.

automapSubstitutions

Si se establece en true, asigna automáticamente todas las sustituciones y hazlas disponibles como variables de entorno en un solo paso. Si se establece en false, ignorar sustituciones para ese paso. Para ver ejemplos, consulta Sustituye valores de variables.

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"
        ]
     }
    ]
  }

allowFailure

En un paso de compilación, si estableces el valor del campo allowFailure en true y el paso falla, la compilación se realiza correctamente, siempre y cuando todos los demás pasos de compilación de esa compilación se realicen correctamente.

Si todos los pasos de compilación de una compilación tienen allowFailure establecido en true y todos los pasos de compilación fallan, el estado de la compilación sigue siendo Successful.

allowExitCodes tiene prioridad sobre este campo.

El siguiente fragmento de código permite que la compilación se realice de forma correcta cuando falla el primer paso:

YAML

steps:
- name: 'ubuntu'
  args: ['-c', 'exit 1']
  allowFailure: true
steps:
- name: 'ubuntu'
  args: ['echo', 'Hello World']

JSON

{
  "steps": [
    {
        "name": "ubuntu",
        "args": [
            "-c",
            "exit -1"
        ],
        "allowFailure": true,
    },
    {
        "name": "ubuntu",
        "args": [
            "echo",
            "Hello World"
        ]
    }
  ]
}

allowExitCodes

Usa el campo allowExitCodes para especificar que se puede ignorar una falla de un paso de compilación cuando ese paso muestra un código de salida en particular.

Si un paso de compilación falla con un código de salida que coincide con el valor que proporcionaste en allowExitCodes, Cloud Build permitirá que este paso falle sin que falle toda la compilación.

Si el 100% de tus pasos de compilación fallan, pero cada paso se cierra con un código que especificaste en el campo allowExitCodes, la compilación sigue siendo correcta.

Sin embargo, si el paso de compilación falla y produce otro código de salida (uno que no coincide con el valor que especificaste en allowExitCodes), la compilación general fallará.

Los códigos de salida relevantes para tu compilación dependen de tu software. Por ejemplo, “1” es un código de salida común en Linux. También puedes definir tus propios códigos de salida en tus secuencias de comandos. El campo allowExitCodes acepta números de hasta 255.

Este campo tiene prioridad sobre allowFailure.

El siguiente fragmento de código permite que la compilación se realice correctamente cuando el primer paso falla con uno de los códigos de salida proporcionados:

YAML

steps:
- name: 'ubuntu'
  args: ['-c', 'exit 1']
  allowExitCodes: [1]
steps:
- name: 'ubuntu'
  args: ['echo', 'Hello World']

JSON

{
  "steps": [
    {
        "name": "ubuntu",
        "args": [
            "-c",
            "exit 1"
        ],
        "allowExitCodes": [1],
    },
    {
        "name": "ubuntu",
        "args": [
            "echo",
            "Hello World"
        ]
    }
  ]
}

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 está configurado, un timeout predeterminado de 60 minutos se aplicará 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"
}

Nota: El campo timeout existe para el paso de compilación y la compilación. En el campo timeout de un paso de compilación, se especifica cuánto tiempo puede durar la ejecución del paso, mientras que en el campo timeout de una compilación, se especifica durante cuánto tiempo puede ejecutarse la compilación.

queueTtl

Usa el campo queueTtl para especificar la cantidad de tiempo que se puede poner en cola una compilación. Si si una compilación está en cola por más tiempo que el valor establecido en queueTtl, la compilación caduca y la compilación status se establece en EXPIRED Si no se proporciona ningún valor, Cloud Build usa el valor predeterminado de 3600s (1 hora). La marca queueTtl comienza a contar desde createTime. queueTtl debe especificarse en segundos con hasta nueve dígitos decimales, que terminan con “s”, por ejemplo, 3.5s.

En el siguiente fragmento, timeout se establece en 20s, y queueTtl se establece en 10s. queueTtl comienza a marcarse a la(s) createTime, que es el momento en el que la compilación se solicita, y timeout empieza a marcar en startTime, que es el horario en que de inicio de compilación. Por lo tanto, queueTtl vencerá en createTime + 10s, 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 CPUs y dos tipos de máquinas con 32 CPUs. Cloud Build también proporciona dos tipos de máquinas virtuales adicionales con 1 y 2 CPUs para ejecutar tus compilaciones. El tipo de máquina predeterminado es e2-standard-2 con 2 CPU. Solicitar una máquina virtual con alta capacidad de CPU puede incrementar el tiempo de inicio de la 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 4,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"
    }
}

defaultLogsBucketBehavior: La opción defaultLogsBucketBehavior te permite configurar Cloud Build para que cree un bucket de registros predeterminado dentro de tu propio proyecto en la misma región que tu compilación. Para obtener más información, consulta Almacena registros de compilación en un bucket regionalizado y de propiedad del usuario.

Mediante la siguiente configuración de compilación, se establece el campo defaultLogsBucketBehavior en el valor REGIONAL_USER_OWNED_BUCKET:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'us-central1-docker.pkg.dev/myproject/myrepo/myimage', '.' ]
options:
  defaultLogsBucketBehavior: REGIONAL_USER_OWNED_BUCKET

JSON

{
  "steps": [
    {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "us-central1-docker.pkg.dev/myproject/myrepo/myimage",
        "."
      ]
    }
    ],
    "options": {
      "defaultLogsBucketBehavior": "REGIONAL_USER_OWNED_BUCKET"
    }
}

dynamicSubstitutions: Usa esta opción para habilitar o inhabilitar de forma explícita la expansión de parámetros de Bash en las sustituciones. Si un activador invoca tu compilación, el El campo dynamicSubstitutions siempre se establece como verdadero y no es necesario especificadas en tu archivo de configuración de compilación. Si tu compilación se invoca de forma manual, debes establecer el campo dynamicSubstitutions en verdadero para las expansiones del parámetro de Bash para no se puede interpretar cuando ejecutes tu compilación.

automapSubstitutions: Asigna automáticamente todas las sustituciones a las variables de entorno que se disponibles en toda la compilación. Para ver ejemplos, consulta Sustituye valores de variables.

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.

pool: Configura el valor de este campo con el nombre del recurso del grupo privado para ejecutar la compilación. Si deseas obtener instrucciones para ejecutar una compilación en un grupo privado, consulta Ejecuta compilaciones en un grupo privado.

requestedVerifyOption: Establece el valor de requestedVerifyOption en VERIFIED para habilitar y verificar la generación de certificaciones y metadatos de procedencia para tu compilación. Una vez configuradas, tus compilaciones solo se marcarán como SUCCESS si se generan las certificaciones y la procedencia.

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"
    }
}

Nota: Si la compilación se invoca mediante un activador, la opción ALLOW_LOOSE se configura de forma predeterminada. En este caso, tu compilación no mostrará un error si falta una variable de sustitución o una sustitución. No se puede anular la opción ALLOW_LOOSE para compilaciones invocadas por activadores.

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"
    ]
}

availableSecrets

Usa este campo para usar un secreto de Secret Manager 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.

Nota: Usa availableSecrets en lugar de secrets. Para obtener más información, consulta Usar Secrets y Usa credenciales encriptadas.

serviceAccount

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.

images

En el campo images del archivo de configuración de compilación, se especifica uno o más Docker de Linux. imágenes que Cloud Build enviará a Artifact Registry o Container Registry (Obsoleto). Es posible que tengas una compilación que realice tareas sin generar ninguna imagen de Docker para Linux, pero si compilas imágenes y no las envías al registro, estas se descartarán cuando finalice la compilación. Si durante la compilación no se genera una imagen especificada, la compilación fallará. Para ver más más detallada sobre el almacenamiento de imágenes, consulta Almacena artefactos en Artifact Registry.

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 artefactos de compilación en Cloud Storage.

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"
        ]
      }
    }
}

mavenArtifacts

El campo mavenArtifacts te permite subir artefactos de Java sin contenedor a los repositorios de Maven en Artifact Registry. Para obtener más información, consulta Cómo compilar y probar aplicaciones de Java.

En la siguiente configuración de compilación, se establece el campo mavenArtifacts para subir el archivo empaquetado my-app-1.0-SNAPSHOT.jar al repositorio de Artifact Registry https://us-central1-maven.pkg.dev/my-project-id/my-java-repo:

YAML

artifacts:
  mavenArtifacts:
    - repository: 'https://us-central1-maven.pkg.dev/my-project-id/my-java-repo'
      path: '/workspace/my-app/target/my-app-1.0-SNAPSHOT.jar'
      artifactId: 'my-app-1'
      groupId: 'com.mycompany.app'
      version: '1.0.0'

JSON

{
  "artifacts": {
    "mavenArtifacts": [
      {
        "repository": "https://us-central1-maven.pkg.dev/my-project-id/my-java-repo",
        "path": "/workspace/my-app/target/my-app-1.0-SNAPSHOT.jar",
        "artifactId": "my-app-1",
        "groupId": "com.mycompany.app",
        "version": "1.0.0"
      }
    ]
  }
}

pythonPackages

El campo pythonPackages te permite subir paquetes de Python a Artifact Registry. Para obtener más información, consulta Compila y prueba aplicaciones de Python.

La siguiente configuración de compilación establece el campo pythonPackages para subir el paquete de Python dist/my-pkg.whl al repositorio https://us-east1-python.pkg.dev/my-project/my-repo de Artifact Registry:

YAML

artifacts:
  pythonPackages:
   - repository: 'https://us-east1-python.pkg.dev/my-project/my-repo'
     paths: ['dist/my-pkg.whl']

JSON

{
  "artifacts": {
    "pythonPackages": [
      {
        "repository": "https://us-east1-python.pkg.dev/my-project/my-repo",
        "paths": ["dist/my-pkg.whl"]
      }
    ]
  }
}

npmPackages

Usa el campo npmPackages para configurar Cloud Build de modo que suba tus paquetes de npm compilados a los repositorios compatibles en Artifact Registry. Debes proporcionar valores para repository y packagePath.

El campo repository especifica el repositorio de Artifact Registry para almacenar tus paquetes. El campo packagePath especifica el directorio local que contiene el paquete npm que se subirá. Este directorio debe contener un archivo package.json.

Te recomendamos que uses una ruta de acceso absoluta para el valor de packagePath. Puedes usar . para hacer referencia al directorio de trabajo actual, pero el campo no se puede omitir o se dejan vacías. Para obtener más instrucciones sobre el uso de npmPackages, consulta Cómo compilar y probar aplicaciones de Node.js.

En la siguiente configuración de compilación, se establece el campo npmPackages para subir el paquete de npm en el directorio /workspace/my-pkg al repositorio de Artifact Registry https://us-east1-npm.pkg.dev/my-project/my-repo.

YAML

artifacts:
  npmPackages:
   - repository: 'https://us-east1-npm.pkg.dev/my-project/my-repo'
     packagePath: '/workspace/my-pkg'

JSON

{
  "artifacts": {
    "npmPackages": [
      {
        "repository": "https://us-east1-npm.pkg.dev/my-project/my-repo",
        "packagePath": "/workspace/my-pkg"
      }
    ]
  }
}

Usa Dockerfiles

Si ejecutas compilaciones de Docker en Cloud Build con la CLI de gcloud o activadores de compilación, puedes usar un Dockerfile sin un archivo de configuración de compilación independiente. 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 con un Dockerfile, consulta la Guía de inicio rápido: Compilación.

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 a un contenedor subyacente o con gcloud en un paso docker Usa la marca --network en el paso build de Docker:

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

• Obtén más información sobre cómo crear un archivo de configuración de compilación básico a fin de configurar compilaciones para Cloud Build.
• Lee Inicia las compilaciones de forma manual para obtener instrucciones sobre cómo ejecutar compilaciones en Cloud Build.