Se usó la API de Cloud Translation para traducir esta página.

Prácticas recomendadas para acelerar las compilaciones

En esta página, se proporcionan prácticas recomendadas para acelerar las compilaciones de Cloud Build.

Compila contenedores más eficientes

Cuando creas contenedores para una aplicación, los archivos que no se necesitan en el entorno de ejecución, como las dependencias de tiempo de compilación y los archivos intermedios, se pueden incluir inadvertidamente en la imagen del contenedor. Estos archivos innecesarios pueden aumentar el tamaño de la imagen del contenedor y agregar tiempo y costo adicionales cuando la imagen se mueve entre tu registro de imágenes del contenedor y el entorno de ejecución del contenedor.

Para ayudar a reducir el tamaño de la imagen de tu contenedor, separa la compilación de la aplicación, junto con las herramientas usadas para compilarla, del ensamblaje del contenedor de entorno de ejecución.

Si deseas obtener más información, consulta la sección para compilar contenedores más eficientes.

Usa la caché de Kaniko

La caché de Kaniko es una característica de Cloud Build que almacena en caché artefactos de compilación de contenedores mediante el almacenamiento y la indexación de capas intermedias dentro de un registro de imágenes de contenedor, como Container Registry de Google, en el que están disponibles para su uso en compilaciones posteriores. Si deseas obtener más información, consulta la sección para usar la caché de Kaniko.

Usa una imagen de Docker almacenada en caché

La forma más sencilla de aumentar la velocidad de compilación de tu imagen de Docker es con la especificación de una imagen en caché que se puede usar para compilaciones posteriores. Para especificar la imagen almacenada en caché, agrega el argumento --cache-from en el archivo de configuración de compilación, que le indicará a Docker que compile mediante esa imagen como fuente de caché.

Cada imagen de Docker está compuesta por capas apiladas. Con --cache-from se vuelven a compilar todas las capas desde la capa modificada hasta el final de la compilación; por eso, no es beneficioso usar --cache-from si cambias una capa en las etapas iniciales de tu compilación de Docker.

Se recomienda que siempre uses --cache-from para tus compilaciones, pero ten en cuenta las siguientes advertencias:

Necesitas una imagen de Docker compilada con anterioridad desde la que se pueda acceder al almacenamiento en caché.
Puedes usar --cache-from solo para compilaciones de Docker, no con compiladores que crean otros tipos de artefactos.
Se debe recuperar la imagen en caché desde un registro que pueda aumentar el tiempo de compilación.

En los pasos siguientes, se explica cómo compilar con una imagen almacenada en caché con anterioridad:

YAML

En tu configuración de compilación, agrega instrucciones para realizar lo siguiente:
- Extraer la imagen en caché desde Container Registry. Ten en cuenta que mediante el paso de compilación docker pull a continuación, se establece el entrypoint en bash, lo que te permite ejecutar el comando y, también, ignorar el error que se muestra. Esto es obligatorio cuando compilas una imagen por primera vez y docker pull no tiene una imagen existente para extraer.
- Agrega un argumento --cache-from para usar esa imagen a fin de volver a compilar.
```
steps:
- name: 'gcr.io/cloud-builders/docker'
  entrypoint: 'bash'
  args: ['-c', 'docker pull gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest || exit 0']
- name: 'gcr.io/cloud-builders/docker'
  args: [
            'build',
            '-t', 'gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest',
            '--cache-from', 'gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest',
            '.'
        ]
images: ['gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest']
```
  En el ejemplo anterior, [IMAGE_NAME] es el nombre de tu imagen.
Compila tu imagen con la configuración de compilación anterior:
```
gcloud builds submit --config cloudbuild.yaml .
```

JSON

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

Extraer la imagen en caché desde Container Registry. Ten en cuenta que mediante el paso de compilación docker pull a continuación, se establece entrypoint en bash, lo que te permite ejecutar el comando y, también, ignorar el error que se muestra. Esto es obligatorio cuando compilas una imagen por primera vez y docker pull no tiene una imagen existente para extraer.

Agrega un argumento --cache-from para usar esa imagen a fin de volver a compilar.

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/docker",
        "entrypoint": "bash",
        "args": ["-c", "docker pull gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest || exit 0"]
    },
    {
        "name": "gcr.io/cloud-builders/docker",
        "args": [
            "build",
            "-t",
            "gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest",
            "--cache-from",
            "gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest",
            "."
        ]
    }
    ],
    "images": ["gcr.io/$PROJECT_ID/[IMAGE_NAME]:latest"]
}

En el ejemplo anterior, [IMAGE_NAME] es el nombre de tu imagen.

Compila tu imagen con la configuración de compilación anterior:
```
gcloud builds submit --config cloudbuild.json .
```

Almacena directorios en caché con Google Cloud Storage

Con el fin de aumentar la velocidad de una compilación, vuelve a usar los resultados de una compilación anterior. Puedes copiar los resultados de una compilación previa en un bucket de Google Cloud Storage, usar los resultados para hacer cálculos más rápido y, luego, copiar los resultados nuevos otra vez en el bucket. Usa este método si tu compilación tarda mucho y produce pocos archivos que no demoran mucho en copiarse desde y hacia Google Cloud Storage.

A diferencia de --cache-from, que es solo para compilaciones de Docker, el almacenamiento en caché de Google Cloud Storage se puede usar con cualquier compilador compatible con Cloud Build.

Usa los pasos a continuación para almacenar en caché los directorios que usan Google Cloud Storage:

YAML

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

Copia los resultados de una compilación previa desde el bucket de Google Cloud Storage.
Usa los resultados para la compilación actual.

Vuelve a copiar los resultados nuevos en el bucket.

steps:
- name: gcr.io/cloud-builders/gsutil
  args: ['cp', 'gs://mybucket/results.zip', 'previous_results.zip']
# operations that use previous_results.zip and produce new_results.zip
- name: gcr.io/cloud-builders/gsutil
  args: ['cp', 'new_results.zip', 'gs://mybucket/results.zip']

Compila tu código con la configuración de compilación anterior:
```
gcloud builds submit --config cloudbuild.yaml .
```

JSON

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

Copia los resultados de una compilación previa desde el bucket de Google Cloud Storage.
Usa los resultados para la compilación actual.

Vuelve a copiar los resultados nuevos en el bucket.

{
    "steps": [
    {
        "name": "gcr.io/cloud-builders/gsutil",
        "args": ["cp", "gs://mybucket/results.zip", "previous_results.zip"]
    },
    {
        // operations that use previous_results.zip and produce new_results.zip
    },
    {
        "name": "gcr.io/cloud-builders/gsutil",
        "args": ["cp", "new_results.zip", "gs://mybucket/results.zip"]
    }
    ]
}

Compila tu código con la configuración de compilación anterior:
```
gcloud builds submit --config cloudbuild.json .
```

Evita subir archivos innecesarios

Cuando se activa una compilación, tu directorio de código se sube para que Cloud Build lo use.

Puedes excluir archivos que tu compilación no necesita con una .gcloudignore para optimizar el tiempo de carga.

Estos son algunos ejemplos de archivos que, por lo general, se excluyen:

Documentación y código de muestra para desarrolladores de proyectos
Código de andamiaje generado, objetos binarios, archivos *.jar o elementos web compilados que se usan para el desarrollo
Dependencias de terceros para el desarrollo local

Para preparar un archivo .gcloudignore a fin de abordar estos casos, crea un archivo en la raíz del proyecto con el siguiente contenido:

.git
dist
node_modules
vendor
*.jar

La exclusión del código compilado y las dependencias de terceros también da como resultado un proceso de compilación más coherente y un menor riesgo de implementación accidental de código que aún está en desarrollo activo.

¿Qué sigue?

Obtén información sobre cómo aumentar la CPU virtual para compilaciones.