

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Almacenamiento de las compilaciones en caché para mejorar el rendimiento
<a name="build-caching"></a>

Puede ahorrar tiempo si compila su proyecto utilizando una caché. Una caché puede almacenar fragmentos reutilizables del entorno de compilación y utilizarlos en diferentes compilaciones. El proyecto de compilación puede utilizar uno de los dos tipos de almacenamiento en caché: Amazon S3 o local. Si utiliza una caché local, debe elegir uno o varios de los tres modos disponibles: caché de origen, caché de capas de Docker y caché personalizada. 

**nota**  
El modo de caché de capas de Docker solamente está disponible en los entornos Linux. Si eliges este modo, debes ejecutar tu compilación en modo privilegiado. CodeBuild los proyectos a los que se les concede el modo privilegiado otorgan a su contenedor acceso a todos los dispositivos. Para obtener más información, consulte la sección sobre [privilegios en tiempo de ejecución y capacidades de Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker Docs.

**Topics**
+ [Almacenamiento en caché de Amazon S3](caching-s3.md)
+ [Almacenamiento en la caché local](caching-local.md)
+ [Especificación de una caché local](specify-caching-local.md)

# Almacenamiento en caché de Amazon S3
<a name="caching-s3"></a>

El almacenamiento en caché de Amazon S3 aloja la caché en un bucket de Amazon S3 disponible en varios hosts de compilación. Esta opción resulta adecuada para artefactos de compilación de tamaño pequeño a intermedio que son más costosos de compilar que de descargar.

Para usar Amazon S3 en una compilación, puede especificar las rutas de los archivos que desea almacenar en caché`buildspec.yml`. CodeBuild almacenará y actualizará automáticamente la caché en la ubicación de Amazon S3 configurada en el proyecto. Si no especifica las rutas de los archivos, CodeBuild hará todo lo posible por almacenar en caché las dependencias de los idiomas más comunes para ayudarle a acelerar las compilaciones. Puede ver los detalles de la memoria caché en los registros de compilación.

Además, si quieres tener varias versiones de caché, puedes definir una clave de caché en. `buildspec.yml` CodeBuild almacena la caché en el contexto de esta clave de caché y crea una copia de caché única que no se actualizará una vez creada. Las claves de caché también se pueden compartir entre proyectos. Las características como claves dinámicas, control de versiones de caché y uso compartido de memoria caché entre compilaciones solo están disponibles cuando se especifica una clave.

Para obtener más información sobre la sintaxis de la caché en el archivo buildspec, consulte [cache](build-spec-ref.md#build-spec.cache) en la referencia de buildspec.

**Topics**
+ [Generación de claves dinámicas](#caching-s3-dynamic)
+ [codebuild-hash-files](#caching-s3-dynamic.codebuild-hash-files)
+ [Versión de caché](#caching-s3-version)
+ [Uso compartido de caché entre proyectos](#caching-s3-sharing)
+ [Ejemplos de buildspec](#caching-s3-examples)

## Generación de claves dinámicas
<a name="caching-s3-dynamic"></a>

Una clave de caché puede incluir comandos de intérprete de comandos y variables de entorno para que sea única, lo que permite actualizaciones de caché automáticas cuando cambia la clave. Por ejemplo, puede definir una clave utilizando el hash del archivo `package-lock.json`. Cuando las dependencias de ese archivo cambian, cambia el hash y, por tanto, la clave de caché, lo que desencadena la creación automática de una nueva caché.

```
cache:
    key: npm-key-$(codebuild-hash-files package-lock.json)
```

CodeBuild evaluará la expresión `$(codebuild-hash-files package-lock.json)` para obtener la clave final:

```
npm-key-abc123
```

También puede definir una clave de caché mediante variables de entorno, como `CODEBUILD_RESOLVED_SOURCE_VERSION`. Esto garantiza que cada vez que cambie la fuente, se genere una nueva clave, lo que provocará que se guarde automáticamente una nueva caché:

```
cache:
   key: npm-key-$CODEBUILD_RESOLVED_SOURCE_VERSION
```

CodeBuild evaluará la expresión y obtendrá la clave final:

```
npm-key-046e8b67481d53bdc86c3f6affdd5d1afae6d369
```

## codebuild-hash-files
<a name="caching-s3-dynamic.codebuild-hash-files"></a>

`codebuild-hash-files`es una herramienta CLI que calcula un hash SHA-256 para un conjunto de archivos del directorio de CodeBuild origen mediante patrones globales:

```
codebuild-hash-files <glob-pattern-1> <glob-pattern-2> ...
```

Algunos ejemplos de uso de `codebuild-hash-files`:

```
codebuild-hash-files package-lock.json
codebuild-hash-files '**/*.md'
```

## Versión de caché
<a name="caching-s3-version"></a>

La versión de caché es un hash generado a partir de las rutas de los directorios que se almacenan en caché. Si dos cachés tienen versiones diferentes, se tratan como cachés distintas durante el proceso de coincidencia. Por ejemplo, las dos cachés siguientes se consideran diferentes porque hacen referencia a rutas diferentes:

```
version: 0.2

phases:
  build:
    commands:
      - pip install pandas==2.2.3 --target pip-dependencies
cache:
  key: pip-dependencies 
  paths:
    - "pip-dependencies/**/*"
```

```
version: 0.2

phases:
  build:
    commands:
      - pip install pandas==2.2.3 --target tmp/pip-dependencies
cache:
  key: pip-dependencies 
  paths:
    - "tmp/pip-dependencies/**/*"
```

## Uso compartido de caché entre proyectos
<a name="caching-s3-sharing"></a>

Puede usar el campo `cacheNamespace` de la API en la sección `cache` para compartir una caché entre varios proyectos. Este campo define el ámbito de la caché. Para compartir una caché, debe hacer lo siguiente:
+ Usa lo mismo. `cacheNamespace`
+ Especifique la misma `key` de caché.
+ Defina rutas de caché idénticas.
+ Utilice los mismos buckets de Amazon S3 y `pathPrefix` si están configurados.

Esto garantiza la coherencia y permite compartir la caché entre los proyectos.

### Especificación de un espacio de nombres de caché (consola)
<a name="caching-s3-sharing.console"></a>

1. Abre la AWS CodeBuild consola en [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Elija **Crear proyecto**. Para obtener más información, consulte [Creación de un proyecto de compilación (consola)](create-project.md#create-project-console) y [Ejecutar una compilación (consola)](run-build-console.md).

1. En **Artefactos**, elija **Configuración adicional**.

1. En **Tipo de caché**, elija **Amazon S3**.

1. En **Espacio de nombres de caché: opcional,** introduzca un valor de espacio de nombres.  
![\[Guarda en caché el parámetro del espacio de nombres en la consola. CodeBuild\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/s3-cache-namespace.png)

1. Continúe con los valores predeterminados y, a continuación, elija **Crear el proyecto de compilación**.

### Especifique un espacio de nombres de caché (AWS CLI)
<a name="caching-s3-sharing.cli"></a>

Puede utilizar el `--cache` parámetro de AWS CLI para especificar un espacio de nombres de caché.

```
--cache '{"type": "S3", "location": "your-s3-bucket", "cacheNamespace": "test-cache-namespace"}'
```

## Ejemplos de buildspec
<a name="caching-s3-examples"></a>

A continuación, se ofrecen varios ejemplos de buildspec para idiomas comunes:

**Topics**
+ [Dependencias de Node.js de caché](#caching-s3-examples.nodejs)
+ [Dependencias de Python de caché](#caching-s3-examples.python)
+ [Dependencias de Ruby de caché](#caching-s3-examples.ruby)
+ [Dependencias de Go de caché](#caching-s3-examples.go)

### Dependencias de Node.js de caché
<a name="caching-s3-examples.nodejs"></a>

Si el proyecto incluye un archivo `package-lock.json` y utiliza `npm` para administrar dependencias de Node.js, en el siguiente ejemplo se muestra cómo configurar almacenamiento en caché. De forma predeterminada, `npm` instala dependencias en el directorio `node_modules`.

```
version: 0.2

phases:
  build:
    commands:
      - npm install
cache:
  key: npm-$(codebuild-hash-files package-lock.json)
  paths:
    - "node_modules/**/*"
```

### Dependencias de Python de caché
<a name="caching-s3-examples.python"></a>

Si el proyecto incluye un archivo `requirements.txt` y utiliza pip para administrar dependencias de Python, en el siguiente ejemplo se muestra cómo configurar almacenamiento en caché. De forma predeterminada, pip instala paquetes en el directorio `site-packages` del sistema.

```
version: 0.2

phases:
  build:
    commands:
      - pip install -r requirements.txt
cache:
  key: python-$(codebuild-hash-files requirements.txt)
  paths:
    - "/root/.pyenv/versions/${python_version}/lib/python${python_major_version}/site-packages/**/*"
```

Además, puede instalar dependencias en un directorio específico y configurar el almacenamiento en caché para ese directorio.

```
version: 0.2

phases:
  build:
    commands:
      - pip install -r requirements.txt --target python-dependencies
cache:
  key: python-$(codebuild-hash-files requirements.txt)
  paths:
    - "python-dependencies/**/*"
```

### Dependencias de Ruby de caché
<a name="caching-s3-examples.ruby"></a>

Si el proyecto incluye un archivo `Gemfile.lock` y utiliza `Bundler` para administrar dependencias de gemas, en el siguiente ejemplo se muestra cómo configurar correctamente almacenamiento en caché.

```
version: 0.2

phases:
  build:
    commands:
      - bundle install --path vendor/bundle
cache:
  key: ruby-$(codebuild-hash-files Gemfile.lock)
  paths:
    - "vendor/bundle/**/*"
```

### Dependencias de Go de caché
<a name="caching-s3-examples.go"></a>

Si el proyecto incluye un archivo `go.sum` y utiliza módulos de Go para administrar dependencias, en el siguiente ejemplo se muestra cómo configurar almacenamiento en caché. De forma predeterminada, los módulos de Go se descargan y almacenan en el directorio `${GOPATH}/pkg/mod`.

```
version: 0.2

phases:
  build:
    commands:
      - go mod download
cache:
  key: go-$(codebuild-hash-files go.sum)
  paths:
    - "/go/pkg/mod/**/*"
```

# Almacenamiento en la caché local
<a name="caching-local"></a>

El almacenamiento en caché local aloja en una caché localmente en un host de compilación, que es el único host de compilación para el que está disponible la caché. Esta opción resulta adecuada para artefactos de compilación de tamaño intermedio a grande, ya que la caché está disponible de forma inmediata en el host de compilación. Esta no es la mejor opción si no hace muchas compilaciones. De este modo, el rendimiento de la compilación no se verá afectado por el tiempo de transferencia de la red.

Si elige la opción de almacenamiento en caché local, debe elegir uno o varios de los siguientes modos de caché: 
+ El modo de caché de origen almacena en la caché los metadatos de Git del origen principal y los orígenes secundarios Una vez que se ha creado la caché, las compilaciones que se realicen posteriormente solo extraerán los cambios realizados entre las confirmaciones. Este modo es conveniente para los proyectos que tienen un directorio de trabajo limpio y un origen que es un gran repositorio de Git. Si eliges esta opción y tu proyecto no usa un repositorio de Git (AWS CodeCommit GitHub, GitHub Enterprise Server o Bitbucket), la opción se ignora. 
+ El modo de caché de capas de Docker almacena en caché las capas de Docker existentes. Este modo es conveniente para los proyectos que compilan o extraen imágenes grandes de Docker. Puede evitar los problemas de rendimiento derivados de extraer imágenes grandes de Docker de la red. 
**nota**  
Las cachés de capas de Docker solo pueden utilizarse en entornos Linux. 
Es necesario establecer la marca `privileged` para que el proyecto tenga los permisos de Docker necesarios.   
De forma predeterminada, el daemon de Docker está habilitado para compilaciones sin VPC. Si quiere usar contenedores de Docker para las compilaciones de VPC, consulte [Runtime Privilege and Linux Capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker Docs y habilite el modo privilegiado. Además, Windows no admite el modo privilegiado.
Debe tener en cuenta la implicación de seguridad antes de utilizar una caché de capas de Docker. 
+ El modo de caché personalizada almacena en caché los directorios que se especifican en el archivo buildspec. Este modo es conveniente si el escenario de compilación no se ajusta a ninguno de los otros dos modos de caché local. Si utiliza una caché personalizada: 
  + Solo se pueden especificar directorios para el almacenamiento en caché. No se pueden especificar archivos individuales. 
  + Para hacer referencia a los directorios almacenados en la caché, se utiliza Symlinks. 
  + Los directorios de la caché se asocian a la compilación antes de que se descarguen los orígenes del proyecto. Los elementos almacenados en la memoria caché invalidan los elementos de origen si tienen el mismo nombre. Los directorios se especifican utilizando rutas de caché en la archivo buildspec. Para obtener más información, consulte [Sintaxis de buildspec](build-spec-ref.md#build-spec-ref-syntax). 
  + Evite los nombres de directorio que sean los mismos en el origen y en la memoria caché. Los directorios almacenados localmente en la memoria caché pueden invalidar o eliminar el contenido de los directorios del repositorio de origen que tienen el mismo nombre.

**nota**  
El tipo de entorno de `LINUX_GPU_CONTAINER` y el tipo de procesamiento de `BUILD_GENERAL1_2XLARGE` no son compatibles con el almacenamiento en caché local. Para obtener más información, consulte [Modos y tipos de computación del entorno de compilación](build-env-ref-compute-types.md).

**nota**  
No se admite el almacenamiento en caché local cuando se configura CodeBuild para trabajar con una VPC. Para obtener más información sobre el uso VPCs con CodeBuild, consulte. [Úselo AWS CodeBuild con Amazon Virtual Private Cloud](vpc-support.md)

# Especificación de una caché local
<a name="specify-caching-local"></a>

Puede usar la consola AWS CLI, el SDK o CloudFormation especificar una caché local. Para obtener más información acerca del almacenamiento en caché local, consulte [Almacenamiento en la caché local](caching-local.md).

**Topics**
+ [Especificar el almacenamiento en la caché local (CLI)](#caching-local-cli)
+ [Especificar el almacenamiento en la caché local (consola)](#caching-local-console)
+ [Especificar el almacenamiento en la caché local (CloudFormation)](#caching-local-cfn)

## Especificar el almacenamiento en la caché local (CLI)
<a name="caching-local-cli"></a>

Puede usar el `--cache` parámetro de AWS CLI para especificar cada uno de los tres tipos de caché local. 
+ Para especificar una caché de origen: 

  ```
  --cache type=LOCAL,mode=[LOCAL_SOURCE_CACHE]
  ```
+ Para especificar una caché de capas de Docker: 

  ```
  --cache type=LOCAL,mode=[LOCAL_DOCKER_LAYER_CACHE]
  ```
+ Para especificar una caché personalizada: 

  ```
  --cache type=LOCAL,mode=[LOCAL_CUSTOM_CACHE]
  ```

Para obtener más información, consulte [Crear un proyecto de compilación (AWS CLI)](create-project.md#create-project-cli).

## Especificar el almacenamiento en la caché local (consola)
<a name="caching-local-console"></a>

Puede especificar una caché en la sección **Artifacts (Artefactos)** de la consola. En **Tipo de caché**, seleccione **Amazon S3** o **Local**. Si elige **Local**, seleccione una o varias de los tres opciones de caché local.

![\[Especifique una caché local mediante la selección de una o varias de las tres opciones de caché local.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/local-cache.png)


Para obtener más información, consulte [Creación de un proyecto de compilación (consola)](create-project.md#create-project-console).

## Especificar el almacenamiento en la caché local (CloudFormation)
<a name="caching-local-cfn"></a>

Si lo utiliza CloudFormation para especificar una caché local`Type`, especifique en la `Cache` propiedad for`LOCAL`. El siguiente ejemplo de CloudFormation código con formato YAML especifica los tres tipos de caché local. Puede especificar cualquier combinación de tipos. Si utiliza una caché de capas de Docker, en `Environment`, debe establecer `PrivilegedMode` en `true` y `Type` en `LINUX_CONTAINER`. 

```
CodeBuildProject:
    Type: AWS::CodeBuild::Project
    Properties:
      Name: MyProject
      ServiceRole: <service-role>
      Artifacts:
        Type: S3
        Location: <bucket-name>
        Name: myArtifact
        EncryptionDisabled: true
        OverrideArtifactName: true
      Environment:
        Type: LINUX_CONTAINER
        ComputeType: BUILD_GENERAL1_SMALL
        Image: aws/codebuild/standard:5.0
        Certificate: <bucket/cert.zip>
        # PrivilegedMode must be true if you specify LOCAL_DOCKER_LAYER_CACHE
        PrivilegedMode: true
      Source:
        Type: GITHUB
        Location: <github-location>
        InsecureSsl: true
        GitCloneDepth: 1
        ReportBuildStatus: false
      TimeoutInMinutes: 10
      Cache:
        Type: LOCAL
        Modes: # You can specify one or more cache mode, 
          - LOCAL_CUSTOM_CACHE
          - LOCAL_DOCKER_LAYER_CACHE
          - LOCAL_SOURCE_CACHE
```

**nota**  
De forma predeterminada, el daemon de Docker está habilitado para compilaciones sin VPC. Si quiere usar contenedores de Docker para las compilaciones de VPC, consulte [Runtime Privilege and Linux Capabilities](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) en el sitio web de Docker Docs y habilite el modo privilegiado. Además, Windows no admite el modo privilegiado.

Para obtener más información, consulte [Crear un proyecto de compilación (CloudFormation)](create-project.md#create-project-cloud-formation).