

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.

# Incorpora AWS CodeBuild
<a name="builds-working"></a>

Una *compilación* representa un conjunto de acciones que se realizan AWS CodeBuild para crear artefactos de salida (por ejemplo, un archivo JAR) a partir de un conjunto de artefactos de entrada (por ejemplo, una colección de archivos de clases Java).

Las siguientes reglas se aplican cuando ejecuta varias compilaciones:
+ Cuando es posible, las compilaciones se ejecutan simultáneamente. El número máximo de compilaciones en ejecución simultánea puede variar. Para obtener más información, consulte [Cuotas para AWS CodeBuild](limits.md). 
+ Si el proyecto de compilación tiene establecido un límite de compilaciones simultáneas y el número de compilaciones en ejecución alcanza este límite, las compilaciones devuelven un error. Para obtener más información, consulte [Activar el límite de compilaciones simultáneas](create-project.md#enable-concurrent-build-limit.console).
+ Si el proyecto de compilación no tiene establecido un límite de compilaciones simultáneas y el número de compilaciones en ejecución alcanza el límite de compilaciones simultáneas de la plataforma y el tipo de computación, las compilaciones quedan a la espera en una cola. El número máximo de compilaciones de una cola es de cinco veces el límite de compilaciones simultáneas. Para obtener más información, consulte [Cuotas para AWS CodeBuild](limits.md).

  Una compilación en una cola que no se inicia después del número de minutos especificado en su valor de tiempo de espera se elimina de la cola. El valor predeterminado del tiempo de espera es de ocho horas. Puede anular el tiempo de espera de la cola de compilación con un valor comprendido entre cinco minutos y ocho horas cuando ejecuta la compilación. Para obtener más información, consulte [Ejecute AWS CodeBuild compilaciones manualmente](run-build.md).

  No es posible predecir el orden en que se inician las compilaciones en cola. 

**nota**  
Puede acceder al historial de una compilación durante un año.

Puede realizar estas tareas cuando trabaje con compilaciones:

**Topics**
+ [Ejecute AWS CodeBuild compilaciones manualmente](run-build.md)
+ [Ejecute compilaciones en el AWS Lambda cómputo](lambda.md)
+ [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md)
+ [Ejecución de compilaciones en lotes](batch-build.md)
+ [Ejecución de pruebas paralelas en compilaciones por lotes](parallel-test.md)
+ [Almacenamiento de las compilaciones en caché para mejorar el rendimiento](build-caching.md)
+ [Depurar compilaciones AWS CodeBuild](debug-builds.md)
+ [Eliminación de compilaciones en AWS CodeBuild](delete-builds.md)
+ [Vuelve a intentar compilar manualmente AWS CodeBuild](retry-build.md)
+ [Cómo reintentar hacer una compilación de forma automática en la AWS CodeBuild](auto-retry-build.md)
+ [Detención de las compilaciones en AWS CodeBuild](stop-build.md)
+ [Detención de las compilaciones por lotes en AWS CodeBuild](stop-batch-build.md)
+ [Cómo desencadenar compilaciones de AWS CodeBuild de forma automática](build-triggers.md)
+ [Vea los detalles de la construcción en AWS CodeBuild](view-build-details.md)
+ [Ver una lista de elementos IDs incorporados AWS CodeBuild](view-build-list.md)
+ [Ver una lista de compilaciones IDs para un proyecto de construcción en AWS CodeBuild](view-builds-for-project.md)

# Ejecute AWS CodeBuild compilaciones manualmente
<a name="run-build"></a>

Puedes usar la AWS CodeBuild consola o AWS SDKs ejecutar una compilación CodeBuild. AWS CLI

**Topics**
+ [Ejecute compilaciones localmente con el AWS CodeBuild agente](use-codebuild-agent.md)
+ [Ejecutar una compilación (consola)](run-build-console.md)
+ [Ejecutar una compilación (AWS CLI)](run-build-cli.md)
+ [Ejecutar una compilación por lotes (AWS CLI)](run-batch-build-cli.md)
+ [Iniciar la ejecución de compilaciones automáticamente (AWS CLI)](run-build-cli-auto-start.md)
+ [Detener la ejecución de compilaciones automáticamente (AWS CLI)](run-build-cli-auto-stop.md)
+ [Ejecutar una compilación (AWS SDKs)](run-build-sdks.md)

# Ejecute compilaciones localmente con el AWS CodeBuild agente
<a name="use-codebuild-agent"></a>

Puede usar el AWS CodeBuild agente para ejecutar CodeBuild compilaciones en una máquina local. Hay agentes disponibles para las plataformas x86\$164 y ARM.

Es posible suscribirse para recibir notificaciones cuando se publican versiones nuevas del agente. 

## Requisitos previos
<a name="use-codebuild-agent.prerequisites"></a>

Antes de comenzar, haga lo siguiente:
+ Instale Git en su equipo local.
+ Instale y configure [Docker](https://www.docker.com/) en su máquina local.

## Configure la imagen de compilación
<a name="use-codebuild-agent.setup-image"></a>

Solo es necesario configurar la imagen de compilación la primera vez que se va a ejecutar el agente o cuando la imagen haya cambiado.

**Para configurar la imagen de compilación**

1. Si desea utilizar una imagen seleccionada de Amazon Linux 2, puede extraerla del repositorio CodeBuild público de Amazon ECR en [https://gallery.ecr. aws/codebuild/amazonlinux-x86\$164-standard](https://gallery.ecr.aws/codebuild/amazonlinux-x86_64-standard) con el siguiente comando:

   ```
   $ docker pull public.ecr.aws/codebuild/amazonlinux-x86_64-standard:4.0
   ```

   Como alternativa, si desea utilizar otra imagen de Linux, ejecute los pasos siguientes:

   1. Clona el repositorio CodeBuild de imágenes:

      ```
      $ git clone https://github.com/aws/aws-codebuild-docker-images.git
      ```

   1. Cambie al directorio de imágenes. En este ejemplo se utiliza la imagen de `aws/codebuild/standard:5.0`.

      ```
      $ cd aws-codebuild-docker-images/ubuntu/standard/5.0
      ```

   1. Compile la imagen. Esto puede tardar varios minutos. 

      ```
      $ docker build -t aws/codebuild/standard:5.0 .
      ```

1. Descarga el CodeBuild agente.

   Para descargar la versión x86\$164 del agente, ejecute el comando siguiente:

   ```
   $ docker pull public.ecr.aws/codebuild/local-builds:latest
   ```

   Para descargar la versión ARMA del agente, ejecute el comando siguiente:

   ```
   $ docker pull public.ecr.aws/codebuild/local-builds:aarch64
   ```

1. <a name="codebuild-agent-sha"></a>El CodeBuild agente está disponible en [https://gallery.ecr. aws/codebuild/local-compila](https://gallery.ecr.aws/codebuild/local-builds). 

   La firma del algoritmo de hash seguro (SHA) de la versión x86\$164 del agente es:

   ```
   sha256:ccb19bdd7af94e4dc761e4c58c267e9455c28ec68d938086b4dc1cf8fe6b0940
   ```

   La firma SHA de la versión ARM del agente es:

   ```
   sha256:7d7b5d35d2ac4e062ae7ba8c662ffed15229a52d09bd0d664a7816c439679192
   ```

   Puede usar el SHA para identificar la versión del agente. Para ver la firma SHA del agente, ejecute el comando siguiente y busque el SHA en `RepoDigests`: 

   ```
   $ docker inspect public.ecr.aws/codebuild/local-builds:latest
   ```

## Ejecuta el agente CodeBuild
<a name="use-codebuild-agent.run-agent"></a>

**Para ejecutar el CodeBuild agente**

1. Cambie al directorio que contiene el código fuente del proyecto de compilación.

1. Descargue el script [codebuild\$1build.sh](https://github.com/aws/aws-codebuild-docker-images/blob/master/local_builds/codebuild_build.sh).

   ```
   $ curl -O  https://raw.githubusercontent.com/aws/aws-codebuild-docker-images/master/local_builds/codebuild_build.sh
   $ chmod +x codebuild_build.sh
   ```

1. Ejecute el script de `codebuild_build.sh` y especifique la imagen del contenedor y el directorio de salida:

   Para ejecutar una compilación de x86\$164, utilice el comando siguiente:

   ```
   $ ./codebuild_build.sh -i <container-image> -a <output directory>
   ```

   Para ejecutar una compilación de ARM, utilice el comando siguiente:

   ```
   $ ./codebuild_build.sh -i <container-image> -a <output directory> -l public.ecr.aws/codebuild/local-builds:aarch64
   ```

   *<container-image>*Sustitúyalo por el nombre de la imagen del contenedor, como `aws/codebuild/standard:5.0` o`public.ecr.aws/codebuild/amazonlinux-x86_64-standard:4.0`.

   El script lanza la imagen de compilación y ejecuta la compilación en el proyecto en el directorio actual. Para especificar la ubicación del proyecto de compilación, añada la opción `-s <build project directory>` al comando del script.

## Reciba notificaciones sobre las nuevas versiones CodeBuild del agente
<a name="receive-codebuild-agent-notifications"></a>

Puede suscribirse a las notificaciones de Amazon SNS para que se le notifique cuando se publiquen nuevas versiones del AWS CodeBuild agente. 

**Para suscribirse a las notificaciones de los CodeBuild agentes**

1. [Abra la consola Amazon SNS en https://console.aws.amazon.com/sns/ la versión 3/home.](https://console.aws.amazon.com/sns/v3/home) 

1. En la barra de navegación, si aún no está seleccionada, cambie la AWS región a **EE.UU. Este (Norte de Virginia).** Debe seleccionar esta AWS región porque las notificaciones de Amazon SNS a las que se está suscribiendo se crean en esta región. 

1. En el panel de navegación, seleccione **Subscriptions**. 

1. Seleccione **Create subscription**. 

1. En **Crear suscripción**, haga lo siguiente: 

   1. En **Topic ARN**, use el siguiente nombre de recurso de Amazon (ARN): 

      ```
      arn:aws:sns:us-east-1:850632864840:AWS-CodeBuild-Local-Agent-Updates
      ```

   1. En **Protocol (Protocolo)**, elija **Email (Correo electrónico)** o **SMS**. 

   1. En **Endpoint (Punto de conexión)**, elija dónde desea recibir las notificaciones (por correo electrónico o SMS). Escriba un correo electrónico, una dirección o un número de teléfono, incluido el código de área. 

   1. Seleccione **Crear subscripción**. 

   1. Seleccione **Correo electrónico** para recibir un correo electrónico en el que se le pedirá que confirme la suscripción. Siga las instrucciones del mensaje para completar la suscripción. 

      Si ya no desea recibir estas notificaciones, utilice el siguiente procedimiento para cancelar la suscripción. 

**Para cancelar la suscripción a las notificaciones de los agentes CodeBuild**

1. [Abra la consola Amazon SNS en https://console.aws.amazon.com/sns/ la versión 3/home.](https://console.aws.amazon.com/sns/v3/home) 

1. En el panel de navegación, seleccione **Suscripciones**. 

1. Elija la suscripción y, en **Actions (Acciones)**, elija **Delete subscriptions (Eliminar suscripciones)**. Cuando se le pida confirmación, elija **Delete**. 

# Ejecutar una compilación (consola)
<a name="run-build-console"></a>

Si desea usar AWS CodePipeline para ejecutar una compilación con CodeBuild, omita estos pasos y siga las instrucciones de [Úselo CodeBuild con CodePipeline](how-to-create-pipeline.md).

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

1. En el panel de navegación, elija **Proyectos de compilación**.

1. En la lista de proyectos de compilación, seleccione el proyecto de compilación.

1. Es posible ejecutar la compilación con la configuración predeterminada del proyecto de compilación o anular la configuración de compilación solo para esta compilación.

   1. Para ejecutar la compilación con la configuración predeterminada del proyecto de compilación, seleccione **Iniciar compilación**. La compilación comienza inmediatamente.

   1. Para anular la configuración predeterminada de compilación, seleccione **Iniciar compilación con anulaciones**. En la página **Iniciar compilación**, es posible anular lo siguiente:
      + **Configuración de compilación**
      + **Origen**
      + **Anulaciones de variables de entorno**

      Si necesita seleccionar anulaciones más avanzadas, seleccione **Anulaciones de compilación avanzada**. En esta página, es posible anular lo siguiente:
      + **Configuración de compilación**
      + **Origen**
      + **Entorno**
      + **Buildspec**
      + **Artefactos**
      + **Registros**

      Cuando haya hecho sus selecciones de anulación, seleccione **Iniciar compilación**.

Para obtener información detallada acerca de esta compilación, consulte [Ver detalles de las compilaciones (consola)](view-build-details.md#view-build-details-console).

# Ejecutar una compilación (AWS CLI)
<a name="run-build-cli"></a>

**nota**  
Si desea usar CodePipeline para ejecutar una compilación con AWS CodeBuild, omita estos pasos y siga las instrucciones de [Cree una canalización que utilice CodeBuild (AWS CLI)](how-to-create-pipeline-cli.md).  
Para obtener más información sobre cómo usar AWS CLI con CodeBuild, consulte [Referencia de la línea de comandos](cmd-ref.md).

1. Ejecute el comando `start-build` de una de las siguientes formas:

   ```
   aws codebuild start-build --project-name <project-name>
   ```

   Utilice esta opción si desea ejecutar una compilación que utilice la última versión del artefacto de entrada de la compilación y la configuración existente del proyecto de compilación.

   ```
   aws codebuild start-build --generate-cli-skeleton
   ```

   Utilice esta opción si desea ejecutar una versión de compilación con una versión anterior del artefacto de entrada de compilación o si desea anular la configuración de los artefactos de salida de compilación, variables de entorno, especificación de compilación o período de tiempo de espera de compilación predeterminado.

1. Si ejecuta el comando **start-build** con la opción `--project-name`, sustituya *<project-name>* por el nombre del proyecto de compilación y vaya al paso 6 de este procedimiento. Para obtener una lista de proyectos de compilación, consulte [Visualización de los nombres de los proyectos de compilación](view-project-list.md).

1. Si ejecuta el comando **start-build** con la opción `--idempotency-token`, se incluye un identificador único en el que se distingue entre mayúsculas y minúsculas, o token, con la solicitud de `start-build`. El token es válido durante 5 minutos después de la solicitud. Si repite la solicitud `start-build` con el mismo token, pero cambia un parámetro, CodeBuild devuelve un error de coincidencia de parámetros.

1. Si ejecuta el comando **start-build** con la opción `--generate-cli-skeleton`, se mostrarán en el resultado datos con formato JSON. Copie los datos en un archivo (por ejemplo, `start-build.json`) en la ubicación del equipo o instancia local en la que haya instalado la AWS CLI. Modifique los datos copiados para que coincidan con el siguiente formato y guarde los resultados:

   ```
   {
     "projectName": "projectName",
     "sourceVersion": "sourceVersion",
     "artifactsOverride": {
       "type": "type",
       "location": "location",
       "path": "path",
       "namespaceType": "namespaceType",
       "name": "artifactsOverride-name",
       "packaging": "packaging"
     },
     "buildspecOverride": "buildspecOverride",
     "cacheOverride": {
       "location": "cacheOverride-location",
       "type": "cacheOverride-type"
     },
     "certificateOverride": "certificateOverride",
     "computeTypeOverride": "computeTypeOverride",
     "environmentTypeOverride": "environmentTypeOverride",
     "environmentVariablesOverride": {
       "name": "environmentVariablesOverride-name",
       "value": "environmentVariablesValue",
       "type": "environmentVariablesOverride-type"
     },
     "gitCloneDepthOverride": "gitCloneDepthOverride",
     "imageOverride": "imageOverride",
     "idempotencyToken": "idempotencyToken",
     "insecureSslOverride": "insecureSslOverride",
     "privilegedModeOverride": "privilegedModeOverride",
     "queuedTimeoutInMinutesOverride": "queuedTimeoutInMinutesOverride",
     "reportBuildStatusOverride": "reportBuildStatusOverride",
     "timeoutInMinutesOverride": "timeoutInMinutesOverride",
     "sourceAuthOverride": "sourceAuthOverride",
     "sourceLocationOverride": "sourceLocationOverride",
     "serviceRoleOverride": "serviceRoleOverride",
     "sourceTypeOverride": "sourceTypeOverride"
   }
   ```

   Reemplace los siguientes marcadores de posición:
   + *projectName*: cadena necesaria. El nombre del proyecto de compilación que desea usar para esta compilación. 
   + *sourceVersion*: cadena opcional. Una versión del código fuente que se va a compilar, como la siguiente:
     + Para Amazon S3, el ID de versión correspondiente a la versión del archivo ZIP de entrada que desea compilar. Si no se especifica *sourceVersion*, se usa la versión más reciente.
     + Para CodeCommit, el ID de confirmación correspondiente a la versión del código fuente que desea compilar. Si no se especifica *sourceVersion*, se usa el ID de confirmación HEAD de la ramificación personalizada. (No puede especificar un nombre de etiqueta para *sourceVersion*, pero puede especificar el ID de confirmación de la etiqueta).
     + Para GitHub, el ID de confirmación, el ID de solicitud de inserción, el nombre de ramificación o el nombre de etiqueta correspondiente a la versión de código fuente que desea compilar. Si se especifica un ID de solicitud de inserción, este debe tener el formato `pr/pull-request-ID` (por ejemplo, `pr/25`). Si se especifica un nombre de ramificación, se usa el ID de confirmación HEAD de la ramificación. Si no se especifica *sourceVersion*, se usa el ID de confirmación HEAD de la ramificación personalizada. 
     + Para Bitbucket, el ID de confirmación, el nombre de ramificación o el nombre de etiqueta correspondiente a la versión de código fuente que desea compilar. Si se especifica un nombre de ramificación, se usa el ID de confirmación HEAD de la ramificación. Si no se especifica *sourceVersion*, se usa el ID de confirmación HEAD de la ramificación personalizada. 
   + Los siguientes marcadores de posición son para `artifactsOverride`.
     + *type*: opcional. El tipo de artefacto de salida de la compilación que invalida el definido en el proyecto de compilación para esta compilación.
     + *location*: opcional. La ubicación del artefacto de salida de la compilación que invalida la definida en el proyecto de compilación para esta compilación.
     + *path*: opcional. La ruta del artefacto de salida de la compilación que invalida la definida en el proyecto de compilación para esta compilación.
     + *namespaceType*: opcional. El tipo de ruta del artefacto de salida de la compilación que invalida el definido en el proyecto de compilación para esta compilación.
     + *name*: opcional. El nombre del artefacto de salida de la compilación que invalida el definido en el proyecto de compilación para esta compilación.
     + *packaging*: opcional. El tipo de empaquetado del artefacto de salida de la compilación que invalida el definido en el proyecto de compilación para esta compilación.
   + *buildspecOverride*: opcional. Declaración de buildspec que invalida la declaración definida en el proyecto de esta compilación. Si se establece este valor, puede ser una definición de buildspec en línea, la ruta a un archivo de buildspec alternativo en relación con el valor de la variable de entorno `CODEBUILD_SRC_DIR` incorporada, o la ruta a un bucket de S3. El bucket de S3 debe estar en la misma región de AWS que el proyecto de compilación. Especifique el archivo buildspec utilizando su ARN (por ejemplo, `arn:aws:s3:::<my-codebuild-sample2>/buildspec.yml`). Si este valor no se proporciona o se establece en una cadena vacía, el código fuente debe contener un archivo `buildspec.yml` en su directorio raíz. Para obtener más información, consulte [Nombre de archivo y ubicación de almacenamiento de buildspec](build-spec-ref.md#build-spec-ref-name-storage).
   + Los siguientes marcadores de posición son para `cacheOverride`.
     + *cacheOverride-location*: opcional. La ubicación de un objeto `ProjectCache` para esta compilación que anula el objeto `ProjectCache` especificado en el proyecto de compilación. `cacheOverride` es opcional y toma un objeto `ProjectCache`. `location` es obligatorio en un objeto `ProjectCache`.
     + *cacheOverride-type*: opcional. El tipo de un objeto `ProjectCache` para esta compilación que anula el objeto `ProjectCache` especificado en el proyecto de compilación. `cacheOverride` es opcional y toma un objeto `ProjectCache`. `type` es obligatorio en un objeto `ProjectCache`.
   + *certificateOverride*: opcional. El nombre de un certificado para esta compilación que sustituye el especificado en el proyecto de compilación.
   + *environmentTypeOverride*: opcional. Un tipo de contenedor para esta compilación que sustituye el especificado en el proyecto de compilación. La cadena válida actual es `LINUX_CONTAINER`.
   + Los siguientes marcadores de posición son para `environmentVariablesOverride`.
     + *environmentVariablesOverride-name*: opcional. El nombre de una variable de entorno del proyecto de compilación cuyo valor desea invalidar para esta compilación.
     + *environmentVariablesOverride-type*: opcional. El tipo de variable de entorno del proyecto de compilación cuyo valor desea invalidar para esta compilación.
     + *environmentVariablesValue*: opcional. El valor de la variable de entorno definida en el proyecto de compilación que desea invalidar para esta compilación.
   + *gitCloneDepthOverride*: opcional. El valor de **Git clone depth** en el proyecto de compilación cuyo valor desea invalidar para esta compilación. Si el tipo de origen es Amazon S3, este valor no se admite.
   + *imageOverride*: opcional. El nombre de una imagen para esta compilación que sustituye el especificado en el proyecto de compilación.
   + *idempotencyToken*: opcional. Una cadena que sirve de token para especificar que la solicitud de compilación es idempotente. Puede elegir cualquier cadena de 64 caracteres o menos. El token es válido durante 5 minutos después de la solicitud de inicio de la compilación. Si se repite la solicitud de inicio de compilación con el mismo token, pero se cambia un parámetro, CodeBuild devuelve un error de coincidencia de parámetros. 
   + *insecureSslOverride*: valor booleano opcional que especifica si la configuración TLS no segura especificada se va a invalidar en el proyecto de compilación. La configuración de TLS no segura determina si deben omitirse las advertencias de TLS al conectarse al código fuente del proyecto. Esta sustitución se aplica únicamente si el origen de la compilación es GitHub Enterprise Server.
   + *privilegedModeOverride*: valor booleano opcional. Si se establece en true, la compilación sustituye el modo privilegiado en el proyecto de compilación.
   +  *queuedTimeoutInMinutesOverride*: Número entero opcional que especifica el número de minutos que se permite en cola una compilación antes de que transcurra el tiempo de espera. Su valor mínimo es de cinco minutos y su valor máximo es 480 minutos (ocho horas). 
   + *reportBuildStatusOverride*: valor booleano opcional que especifica si se debe enviar al proveedor de código fuente el estado de inicio y finalización de una compilación. Si define este valor con un proveedor de código fuente distinto de GitHub, GitHub Enterprise Server o Bitbucket, se genera una excepción invalidInputException.
   + *sourceAuthOverride*: cadena opcional. Un tipo de autorización para esta compilación que sustituye la definida en el proyecto de compilación. Esta sustitución se aplica únicamente si el origen del proyecto de compilación es Bitbucket o GitHub.
   + *sourceLocationOverride*: cadena opcional. Una ubicación que sustituye la ubicación de código fuente de este proyecto por la definida en el proyecto de compilación.
   + *serviceRoleOverride*: cadena opcional. El nombre de un rol de servicio para esta compilación que sustituye el especificado en el proyecto de compilación.
   + *sourceTypeOverride*: cadena opcional. Un tipo de entrada de código fuente para esta compilación que sustituye la entrada de código fuente definida en el proyecto de compilación. Las cadenas válidas son `NO_SOURCE`, `CODECOMMIT`, `CODEPIPELINE`, `GITHUB`, `S3`, `BITBUCKET` y `GITHUB_ENTERPRISE`.
   + *timeoutInMinutesOverride*: número opcional. El número de minutos de tiempo de espera de la compilación que invalida el definido en el proyecto de compilación para esta compilación. 

   Le recomendamos que almacene una variable de entorno con un valor confidencial, como un ID de clave de acceso de AWS, una clave de acceso secreta de AWS o una contraseña, como un parámetro en el almacén de parámetros de Amazon EC2 Systems Manager. CodeBuild puede utilizar un parámetro almacenado en el almacén de parámetros de Amazon EC2 Systems Manager solo si el nombre del parámetro comienza por `/CodeBuild/` (por ejemplo, `/CodeBuild/dockerLoginPassword`). Puede utilizar la consola de CodeBuild para crear un parámetro en Amazon EC2 Systems Manager. Elija **Crear un parámetro** y siga las instrucciones. (En ese cuadro de diálogo, en **Clave de KMS**, puede especificar si lo desea el ARN de una clave de AWS KMS de su cuenta. Amazon EC2 Systems Manager utiliza esta clave para cifrar el valor del parámetro durante el almacenamiento y descifrarlo durante la recuperación). Si usa la consola de CodeBuild para crear un parámetro, la consola asigna `/CodeBuild/` al principio del parámetro cuando lo almacena. Sin embargo, si utiliza la consola del almacén de parámetros de Amazon EC2 Systems Manager para crear un parámetro, el nombre del parámetro debe comenzar por `/CodeBuild/` y debe establecer **Tipo** en **Cadena segura**. Para obtener más información, consulte [Almacenamiento de parámetros de AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) y [Tutorial : Crear y probar un parámetro de cadena de caracteres (consola)](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-console.html) en la *Guía del usuario de Amazon EC2 Systems Manager*.

   Si el proyecto de compilación hace referencia a parámetros almacenados en el almacén de parámetros de Amazon EC2 Systems Manager, el rol de servicio del proyecto de compilación debe permitir la acción `ssm:GetParameters`. Si se ha seleccionado **Crear un nuevo rol de servicio en su cuenta** anteriormente, CodeBuild incluye esta acción en el rol de servicio predeterminado del proyecto de compilación automáticamente. Sin embargo, si se ha seleccionado **Seleccionar un rol de servicio existente de su cuenta**, debe incluir esta acción en su rol de servicio por separado.

   Las variables de entorno que defina reemplazan las variables de entorno existentes. Por ejemplo, si la imagen de Docker ya contiene una variable de entorno denominada `MY_VAR` con un valor de `my_value` y establece una variable de entorno denominada `MY_VAR` con un valor de `other_value`, `my_value` se reemplaza por `other_value`. Asimismo, si la imagen de Docker ya contiene una variable de entorno denominada `PATH` con un valor de `/usr/local/sbin:/usr/local/bin` y establece una variable de entorno denominada `PATH` con un valor de `$PATH:/usr/share/ant/bin`, `/usr/local/sbin:/usr/local/bin` se reemplaza por el valor literal `$PATH:/usr/share/ant/bin`. 

   No establezca variables de entorno con un nombre que empiece por `CODEBUILD_`. Este prefijo se reserva para uso interno.

   Si se define una variable de entorno con el mismo nombre en varios lugares, el valor de la variable de entorno se determina de la siguiente manera:
   + El valor de la llamada a la operación de inicio de la compilación tiene la máxima prioridad.
   + El valor de la definición del proyecto de compilación es el siguiente en orden de prioridad.
   + El valor en la declaración del archivo buildspec tiene la prioridad más baja.

   Para obtener información sobre los valores válidos para estos marcadores de posición, consulte [Crear un proyecto de compilación (AWS CLI)](create-project.md#create-project-cli). Para obtener una lista de las últimas opciones de configuración de un proyecto de compilación, consulte [Visualización de los detalles de un proyecto de compilación](view-project-details.md).

1. Cambie al directorio que contiene el archivo que acaba de guardar y ejecute de nuevo el comando `start-build`.

   ```
   aws codebuild start-build --cli-input-json file://start-build.json
   ```

1. Si el comando se ejecuta correctamente, aparecerán datos similares a los que se describen en el procedimiento [Para ejecutar la compilación](getting-started-overview.md#getting-started-run-build-cli) en el resultado.

Para trabajar con información detallada acerca de esta compilación, anote el valor de `id` en la salida y después consulte [Ver detalles de las compilaciones (AWS CLI)](view-build-details.md#view-build-details-cli).

# Ejecutar una compilación por lotes (AWS CLI)
<a name="run-batch-build-cli"></a>

1. Ejecute el comando `start-build-batch` de una de las siguientes formas:

   ```
   aws codebuild start-build-batch --project-name <project-name>
   ```

   Utilice esta opción si desea ejecutar una compilación que utilice la última versión del artefacto de entrada de la compilación y la configuración existente del proyecto de compilación.

   ```
   aws codebuild start-build-batch --generate-cli-skeleton > <json-file>
   ```

   Utilice esta opción si desea ejecutar una versión de compilación con una versión anterior del artefacto de entrada de compilación o si desea anular la configuración de los artefactos de salida de compilación, variables de entorno, especificación de compilación o período de tiempo de espera de compilación predeterminado.

1. Si ejecuta el comando **start-build-batch** con la opción `--project-name`, sustituya *<project-name>* por el nombre del proyecto de compilación y vaya al paso 6 de este procedimiento. Para obtener una lista de proyectos de compilación, consulte [Visualización de los nombres de los proyectos de compilación](view-project-list.md).

1. Si ejecuta el comando **start-build-batch** con la opción `--idempotency-token`, se incluye un identificador único en el que se distingue entre mayúsculas y minúsculas, o token, con la solicitud de `start-build-batch`. El token es válido durante 5 minutos después de la solicitud. Si repite la solicitud `start-build-batch` con el mismo token, pero cambia un parámetro, CodeBuild devuelve un error de coincidencia de parámetros.

1. Si ejecuta el comando **start-build-batch** con la opción `--generate-cli-skeleton`, se envían datos en formato JSON al archivo *<json-file>*. Este archivo es similar al esqueleto producido por el comando **start-build**, con la incorporación del objeto siguiente. Para obtener más información acerca de los objetos comunes, consulte [Ejecutar una compilación (AWS CLI)](run-build-cli.md).

   Modifique este archivo para añadir cualquier modificación a la compilación y guarde los resultados.

   ```
     "buildBatchConfigOverride": {
       "combineArtifacts": combineArtifacts,
       "restrictions": {
         "computeTypesAllowed": [
           allowedComputeTypes
         ],
         "maximumBuildsAllowed": maximumBuildsAllowed
       },
       "serviceRole": "batchServiceRole",
       "timeoutInMins": batchTimeout
     }
   ```

   El objeto `buildBatchConfigOverride` es una estructura [ProjectBuildBatchConfig](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectBuildBatchConfig.html) que contiene las modificaciones a la configuración de compilación por lotes para esta compilación.  
*combineArtifacts*  
Especifica si los artefactos de compilación para la compilación por lotes se deben combinar en una única ubicación de artefactos.  
*allowedComputeTypes*  
Una matriz de cadenas que especifican los tipos de computación permitidos para la compilación por lotes. Consulte los valores en [Tipos de computación del entorno de compilación](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html).   
*maximumBuildsAllowed*  
Especifica el número máximo de compilaciones permitidas.  
*batchServiceRole*  
Especifica el ARN del rol de servicio para el proyecto de compilación por lotes.  
*batchTimeout*  
Especifica la cantidad máxima de tiempo, en minutos, en que se debe completar la compilación por lotes.

1. Cambie al directorio que contiene el archivo que acaba de guardar y ejecute de nuevo el comando `start-build-batch`.

   ```
   aws codebuild start-build-batch --cli-input-json file://start-build.json
   ```

1. Si se ejecuta correctamente, la salida de la consola muestra la representación en JSON de un objeto [BuildBatch](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_BuildBatch.html). Consulte [Sintaxis de respuesta de StartBuildBatch](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_StartBuildBatch.html#API_StartBuildBatch_ResponseSyntax) para ver un ejemplo de estos datos.

# Iniciar la ejecución de compilaciones automáticamente (AWS CLI)
<a name="run-build-cli-auto-start"></a>

Si tu código fuente está almacenado en un repositorio de GitHub Enterprise Server GitHub o en uno de Enterprise Server, puedes usar GitHub webhooks para AWS CodeBuild reconstruir tu código fuente cada vez que se introduzca un cambio de código en el repositorio.

Ejecute el comando **create-webhook** de la siguiente manera:

```
aws codebuild create-webhook --project-name <project-name>
```

*<project-name>*es el nombre del proyecto de compilación que contiene el código fuente que se va a reconstruir.

Pues GitHub, en el resultado aparece información similar a la siguiente:

```
{
  "webhook": {
    "url": "<url>"
  }
}
```

*<url>*es la URL del GitHub webhook.

En el GitHub caso de Enterprise Server, en el resultado aparece información similar a la siguiente:

![\[Información de la salida del ejemplo.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/create-webhook-ghe.png)


1. Copie la URL de carga y la clave secreta de la salida. Los necesita para añadir un webhook en GitHub Enterprise Server. 

1. En GitHub Enterprise Server, elige el repositorio en el que está almacenado tu CodeBuild proyecto. Elija **Settings (Configuración)**, elija **Hooks & services (Enlaces y servicios)** y, a continuación, elija **Add webhook (Añadir webhook)**. 

1. Introduzca la URL de carga y la clave secreta, acepte los valores predeterminados para el resto de los campos y elija **Add webhook**.

# Detener la ejecución de compilaciones automáticamente (AWS CLI)
<a name="run-build-cli-auto-stop"></a>

Si tu código fuente está almacenado en un repositorio de GitHub Enterprise Server GitHub o en uno de Enterprise Server, puedes configurar GitHub webhooks para que AWS CodeBuild reconstruyan tu código fuente cada vez que se introduzca un cambio de código en el repositorio. Para obtener más información, consulte [Iniciar la ejecución de compilaciones automáticamente (AWS CLI)](run-build-cli-auto-start.md).

Si ha activado este comportamiento, puede desactivarlo ejecutando los comandos `delete-webhook` como se indica a continuación:

```
aws codebuild delete-webhook --project-name <project-name>
```
+ donde *<project-name>* es el nombre del proyecto de compilación que contiene el código fuente que se va a reconstruir.

Si este comando se ejecuta correctamente, no aparecerá información ni errores en el resultado.

**nota**  
Esto elimina el webhook únicamente de tu CodeBuild proyecto. También debes eliminar el webhook de tu repositorio GitHub o de GitHub Enterprise Server.

# Ejecutar una compilación (AWS SDKs)
<a name="run-build-sdks"></a>

 CodePipeline Para ejecutar una compilación con AWS CodeBuild, omita estos pasos y, en [Úselo AWS CodeBuild con AWS CodePipeline para probar el código y ejecutar compilaciones](how-to-create-pipeline.md) su lugar, siga las instrucciones que aparecen en él.

Para obtener información sobre su uso CodeBuild con AWS SDKs, consulte la[AWS SDKs y referencia de herramientas](sdk-ref.md).

# Ejecute compilaciones en el AWS Lambda cómputo
<a name="lambda"></a>

AWS Lambda Compute ofrece velocidades de inicio optimizadas para sus compilaciones. AWS Lambda admite compilaciones más rápidas debido a una latencia de inicio más baja. AWS Lambda también se escala automáticamente, por lo que las compilaciones no tienen que hacer cola para ejecutarse. Sin embargo, hay algunos casos de uso que AWS Lambda no son compatibles y, si le afectan, utilice el procesamiento de EC2. Para obtener más información, consulte [Limitaciones de AWS Lambda cómputo](#lambda.limitations).

**Topics**
+ [¿Qué herramientas y entornos de tiempo de ejecución se incluyen en las imágenes de Docker del entorno de tiempo de ejecución seleccionado que se ejecuta en AWS Lambda?](#lambda.tools)
+ [¿Qué pasa si la imagen seleccionada no incluye las herramientas que necesito?](#lambda.custom)
+ [¿En qué regiones se admite la AWS Lambda computación? CodeBuild](#lambda.regions)
+ [Limitaciones de AWS Lambda cómputo](#lambda.limitations)
+ [Implemente una función Lambda con AWS SAM CodeBuild Lambda Java](sample-lambda-sam-gradle.md)
+ [Cree una aplicación React de una sola página con CodeBuild Lambda Node.js](sample-lambda-react-nodejs.md)
+ [Actualizar la configuración de una función Lambda con CodeBuild Lambda Python](sample-lambda-boto3-python.md)

## ¿Qué herramientas y entornos de tiempo de ejecución se incluyen en las imágenes de Docker del entorno de tiempo de ejecución seleccionado que se ejecuta en AWS Lambda?
<a name="lambda.tools"></a>

AWS Lambda admite las siguientes herramientas: AWS CLI v2, AWS SAM CLI, git, go, Java, Node.js, Python, pip, Ruby y.NET.

## ¿Qué pasa si la imagen seleccionada no incluye las herramientas que necesito?
<a name="lambda.custom"></a>

Si la imagen seleccionada no incluye las herramientas que necesita, puede proporcionar una imagen de Docker de entorno personalizado que sí las incluya.

**nota**  
Lambda no admite funciones que utilizan imágenes de contenedor de varias arquitecturas. Para obtener más información, consulte [Creación de una función de Lambda con una imagen de contenedor](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#images-reqs) en la *Guía para desarrolladores de AWS Lambda *.

Tenga en cuenta que necesita los siguientes permisos de Amazon ECR para utilizar imágenes personalizadas para la computación de Lambda:

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecr:GetAuthorizationToken"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ecr:BatchCheckLayerAvailability",
                "ecr:GetDownloadUrlForLayer",
                "ecr:BatchGetImage"
            ],
            "Resource": "arn:aws:ecr:us-east-1:111122223333:repository/image-repo"
        }
    ]
}
```

------

Tenga en cuenta también que debe haber instalado `curl` o `wget` para poder utilizar imágenes personalizadas.

## ¿En qué regiones se admite la AWS Lambda computación? CodeBuild
<a name="lambda.regions"></a>

En CodeBuild, la AWS Lambda computación se admite en los siguientes lugares Regiones de AWS: EE.UU. Este (Norte de Virginia), EE.UU. Este (Ohio), EE.UU. Oeste (Oregón), Asia Pacífico (Bombay), Asia Pacífico (Singapur), Asia Pacífico (Sídney), Asia Pacífico (Tokio), Europa (Fráncfort), Europa (Irlanda) y Sudamérica (São Paulo). Para obtener más información sobre Regiones de AWS dónde CodeBuild está disponible, consulta [AWS Servicios por región](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).

## Limitaciones de AWS Lambda cómputo
<a name="lambda.limitations"></a>

Hay algunos casos de uso que AWS Lambda no son compatibles y, si le afectan, utilice el procesamiento de EC2:
+ AWS Lambda no admite herramientas que requieren permisos de root. En el caso de herramientas como `yum` o `rpm`, utilice el tipo de computación EC2 u otras herramientas que no requieran permisos de root.
+ AWS Lambda no admite compilaciones ni ejecuciones de Docker.
+ AWS Lambda no admite la escritura en archivos externos`/tmp`. Los administradores de paquetes incluidos están configurados para usar el directorio `/tmp` de forma predeterminada para descargar paquetes y hacer referencia a ellos.
+ AWS Lambda no admite este tipo de entorno `LINUX_GPU_CONTAINER` y no es compatible con Windows Server Core 2019.
+ AWS Lambda no admite el almacenamiento en caché, los tiempos de espera de compilación personalizados, los tiempos de espera de cola, las insignias de compilación, el modo privilegiado, los entornos de ejecución personalizados ni los tiempos de ejecución de más de 15 minutos.
+ AWS Lambda no admite la conectividad de VPC, un rango fijo de direcciones IP de CodeBuild origen, EFS, certificados de instalación ni acceso SSH con Session Manager.

# Implemente una función Lambda con AWS SAM CodeBuild Lambda Java
<a name="sample-lambda-sam-gradle"></a>

The AWS Serverless Application Model (AWS SAM) es un marco de código abierto para crear aplicaciones sin servidor. Para obtener más información, consulte el [AWS Serverless Application Model repositorio](https://github.com/aws/serverless-application-model) en. GitHub En el siguiente ejemplo de Java, se usa Gradle para crear y probar una AWS Lambda función. Después de lo cual, la AWS SAM CLI se usa para implementar la CloudFormation plantilla y el paquete de implementación. Al usar CodeBuild Lambda, los pasos de compilación, prueba e implementación se gestionan automáticamente, lo que permite que la infraestructura se actualice rápidamente sin intervención manual en una sola compilación.

## Configure su repositorio AWS SAM
<a name="sample-lambda-sam-gradle.set-up-repo"></a>

Cree un AWS SAM `Hello World` proyecto mediante la AWS SAM CLI.

**Para crear su AWS SAM proyecto**

1. Siga las instrucciones de la *Guía del AWS Serverless Application Model desarrollador* para [instalar la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) en su máquina local.

1. Ejecute `sam init` y seleccione la siguiente configuración del proyecto.

   ```
   Which template source would you like to use?: 1 - AWS Quick Start Templates
   Choose an AWS Quick Start application template: 1 - Hello World Example
   Use the most popular runtime and package type? (Python and zip) [y/N]: N
   Which runtime would you like to use?: 8 - java21
   What package type would you like to use?: 1 - Zip
   Which dependency manager would you like to use?: 1 - gradle
   Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: N
   Would you like to enable monitoring using CloudWatch Application Insights? [y/N]: N
   Would you like to set Structured Logging in JSON format on your Lambda functions? [y/N]:  N
   Project name [sam-app]: <insert project name>
   ```

1. Cargue la carpeta AWS SAM del proyecto en un repositorio de código fuente compatible. Para obtener una lista de los tipos de fuentes compatibles, consulte [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Creación de un CodeBuild proyecto Java Lambda
<a name="sample-lambda-sam-gradle.create-project"></a>

Cree un proyecto Java AWS CodeBuild Lambda y configure los permisos de IAM necesarios para la compilación.

**Para crear su proyecto CodeBuild Lambda Java**

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

1.  Si aparece una página de CodeBuild información, elija **Crear** proyecto de compilación. De lo contrario, en el panel de navegación, expanda **Compilar**, elija **Proyectos de compilación** y, a continuación, elija **Crear proyecto de compilación**. 

1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación. Los nombres de los proyectos de compilación deben ser únicos en cada AWS cuenta. También puede introducir una descripción opcional del proyecto de compilación para ayudar a otros usuarios a entender para qué se utiliza el proyecto.

1. En **Fuente**, selecciona el repositorio de origen en el que se encuentra tu AWS SAM proyecto.

1. En **Environment (Entorno)**:
   + En **Computación**, seleccione **Lambda**.
   + En **Tiempo(s) de ejecución**, seleccione **Java**.
   + En **Imagen**, seleccione **aws/codebuild/amazonlinux-x86\$164-lambda-standard:corretto21**.
   + En **Rol de servicio**, seleccione **Nuevo rol de servicio**. Anote el **Nombre del rol**. Esto será necesario cuando actualice los permisos de IAM del proyecto más adelante en este ejemplo.

1. Elija **Crear el proyecto de compilación**.

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 

1. En el panel de navegación, elija **Roles** y seleccione el rol de servicio asociado a su proyecto. ******Para encontrar su función en el proyecto, seleccione el proyecto de construcción, elija Edición, Entorno y, a continuación, la función CodeBuild de servicio.******

1. Elija la pestaña **Relaciones de confianza** y, a continuación, **Editar política de confianza**.

1. Agregue la siguiente política insertada al rol de IAM. Esto se utilizará para implementar su AWS SAM infraestructura más adelante. Para obtener más información, consulta [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "",
               "Effect": "Allow",
               "Action": [
                   "cloudformation:*",
                   "lambda:*",
                   "iam:*",
                   "apigateway:*",
                   "s3:*"
               ],
               "Resource": "arn:aws:iam::*:role/Service*"
           }
       ]
   }
   ```

------

## Configuración de la especificación de compilación del proyecto
<a name="sample-lambda-sam-gradle.set-up-buildspec"></a>

Para crear, probar e implementar la función Lambda, CodeBuild lee y ejecuta los comandos de compilación desde una especificación de compilación.

**Para configurar la especificación de compilación del proyecto**

1. ****En la CodeBuild consola, selecciona tu proyecto de compilación y, a continuación, selecciona Editar y Buildspec.****

1. En **Especificación de compilación**, elija **Insertar comandos de compilación** y, a continuación, **Cambiar al editor**.

1. Elimine los comandos de compilación rellenados previamente y pegue la siguiente especificación de compilación.

   ```
   version: 0.2
   env:
     variables:
       GRADLE_DIR: "HelloWorldFunction"
   phases:
     build:
       commands:
         - echo "Running unit tests..."
         - cd $GRADLE_DIR; gradle test; cd ..
         - echo "Running build..."
         - sam build --template-file template.yaml
         - echo "Running deploy..."
         - sam package --output-template-file packaged.yaml --resolve-s3 --template-file template.yaml
         - yes | sam deploy
   ```

1. Seleccione **Update buildspec (Actualizar buildspec)**.

## Implemente su AWS SAM infraestructura Lambda
<a name="sample-lambda-sam-gradle.deploy"></a>

Utilice CodeBuild Lambda para implementar automáticamente su infraestructura Lambda

**Para implementar su infraestructura de Lambda**

1. Seleccione **Iniciar la compilación**. Esto creará, probará e implementará automáticamente la AWS SAM aplicación para AWS Lambda utilizarla. CloudFormation

1. Una vez finalizada la compilación, diríjase a la AWS Lambda consola y busque la nueva función Lambda en el nombre del AWS SAM proyecto.

1. Pruebe la función de Lambda; para ello, seleccione **API Gateway** en la información general de **Función** y, a continuación, haga clic en la URL de **Punto de conexión de API**. Debería aparecer una página abierta con el mensaje `"message": "hello world"`.

## Limpieza de la infraestructura
<a name="sample-lambda-sam-gradle.clean-up"></a>

Para evitar que se le cobre más por los recursos que utilizó durante este tutorial, elimine los recursos creados por la AWS SAM plantilla y CodeBuild.

**Para limpiar la infraestructura**

1. Navegue hasta la CloudFormation consola y seleccione`aws-sam-cli-managed-default`.

1. En **Recursos**, vacíe el bucket de implementación `SamCliSourceBucket`.

1. Elimine la pila de `aws-sam-cli-managed-default`.

1. Elimine la CloudFormation pila asociada a su AWS SAM proyecto. Esta pila debe tener el mismo nombre que tu AWS SAM proyecto.

1. Ve a la CloudWatch consola y elimina los grupos de CloudWatch registros asociados a tu CodeBuild proyecto.

1. Ve a la CodeBuild consola y elimina tu CodeBuild proyecto seleccionando **Eliminar proyecto de compilación**.

# Cree una aplicación React de una sola página con CodeBuild Lambda Node.js
<a name="sample-lambda-react-nodejs"></a>

[Create React App](https://create-react-app.dev/) es una forma de crear aplicaciones React de una sola página. El siguiente ejemplo de Node.js lo utiliza para compilar los artefactos de origen desde Create React App y devuelve los artefactos de compilación.

## Configuración del repositorio de origen y el bucket de artefactos
<a name="sample-lambda-react-nodejs.set-up-repo"></a>

Cree un repositorio de origen para su proyecto con yarn y Create React App.

**Para configurar el repositorio de origen y el bucket de artefactos**

1. Ejecute `yarn create react-app <app-name>` en su máquina local para crear una aplicación React sencilla.

1. Cargue la carpeta del proyecto de la aplicación React en un repositorio de origen admitido. Para obtener una lista de los tipos de fuentes compatibles, consulte [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Crear un proyecto CodeBuild Lambda Node.js
<a name="sample-lambda-react-nodejs.create-project"></a>

Cree un AWS CodeBuild proyecto Lambda Node.js.

**Para crear su proyecto CodeBuild Lambda Node.js**

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

1.  Si aparece una página de CodeBuild información, elija **Crear** proyecto de compilación. De lo contrario, en el panel de navegación, expanda **Compilar**, elija **Proyectos de compilación** y, a continuación, elija **Crear proyecto de compilación**. 

1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación. Los nombres de los proyectos de compilación deben ser únicos en cada AWS cuenta. También puede introducir una descripción opcional del proyecto de compilación para ayudar a otros usuarios a entender para qué se utiliza el proyecto.

1. En **Fuente**, selecciona el repositorio de origen en el que se encuentra tu AWS SAM proyecto.

1. En **Environment (Entorno)**:
   + En **Computación**, seleccione **Lambda**.
   + En **Tiempo(s) de ejecución**, seleccione **Node.js**.
   + En **Imagen**, selecciona **aws/codebuild/amazonlinux-x86\$164-lambda-standard:nodejs20**.

1. En **Artifacts (Artefactos)**:
   + En **Tipo**, seleccione **Amazon S3**.
   + En **Nombre del bucket**, seleccione el bucket de artefactos del proyecto que ha creado anteriormente.
   + En **Empaquetado de artefactos**, seleccione **Zip**.

1. Elija **Crear el proyecto de compilación**.

## Configuración de la especificación de compilación del proyecto
<a name="sample-lambda-react-nodejs.set-up-buildspec"></a>

Para crear tu aplicación React, lee y ejecuta los comandos de compilación desde un archivo buildspec. CodeBuild 

**Para configurar la especificación de compilación del proyecto**

1. ****En la CodeBuild consola, selecciona tu proyecto de compilación y, a continuación, selecciona Editar y Buildspec.****

1. En **Especificación de compilación**, elija **Insertar comandos de compilación** y, a continuación, **Cambiar al editor**.

1. Elimine los comandos de compilación rellenados previamente y pegue la siguiente especificación de compilación.

   ```
   version: 0.2
   phases:
     build:
       commands:
         - yarn
         - yarn add --dev jest-junit @babel/plugin-proposal-private-property-in-object
         - yarn run build
         - yarn run test -- --coverage --watchAll=false --testResultsProcessor="jest-junit" --detectOpenHandles
   artifacts:
     name: "build-output"
     files:
       - "**/*"
   reports:
     test-report:
       files:
         - 'junit.xml'
       file-format: 'JUNITXML'
     coverage-report:
       files:
         - 'coverage/clover.xml'
       file-format: 'CLOVERXML'
   ```

1. Seleccione **Update buildspec (Actualizar buildspec)**.

## Compilación y ejecución de la aplicación React
<a name="sample-lambda-react-nodejs.build"></a>

Cree la aplicación React en CodeBuild Lambda, descargue los artefactos de compilación y ejecute la aplicación React localmente.

**Para compilar y ejecutar su aplicación React**

1. Seleccione **Iniciar la compilación**.

1. Una vez finalizada la compilación, navegue hasta el bucket de artefactos del proyecto de Amazon S3 y descargue el artefacto de la aplicación React.

1. Descomprima el artefacto de compilación de React y ejecute `run npm install -g serve && serve -s build` en la carpeta del proyecto.

1. El comando `serve` ofrecerá el sitio estático en un puerto local e imprimirá la salida en su terminal. Puede visitar la URL de localhost en `Local:` en la salida del terminal para ver su aplicación React.

Para obtener más información sobre cómo controlar la implementación de un servidor basado en React, consulte [Create React App Deployment](https://create-react-app.dev/docs/deployment/).

## Limpieza de la infraestructura
<a name="sample-lambda-react-nodejs.clean-up"></a>

Para evitar cargos adicionales por los recursos que utilizó durante este tutorial, elimine los recursos creados para su CodeBuild proyecto.

**Para limpiar la infraestructura**

1. Eliminación del bucket de Amazon S3 de artefactos del proyecto

1. Navegue a la CloudWatch consola y elimine los grupos de CloudWatch registros asociados a su CodeBuild proyecto.

1. Ve a la CodeBuild consola y elimina tu CodeBuild proyecto seleccionando **Eliminar proyecto de compilación**.

# Actualizar la configuración de una función Lambda con CodeBuild Lambda Python
<a name="sample-lambda-boto3-python"></a>

En el siguiente ejemplo de Python, se utilizan [Boto3](https://aws.amazon.com/sdk-for-python/) y Lambda CodeBuild Python para actualizar la configuración de una función Lambda. Este ejemplo se puede ampliar para gestionar otros recursos mediante programación. AWS Para obtener más información, consulte la [documentación de Boto3](https://aws.amazon.com/sdk-for-python/).

## Requisitos previos
<a name="sample-lambda-boto3-python.prerequisites"></a>

Cree o busque una función de Lambda en su cuenta.

En este ejemplo se supone que ya ha creado una función Lambda en su cuenta y que la utilizará CodeBuild para actualizar las variables de entorno de la función Lambda. Para obtener más información sobre cómo configurar una función Lambda mediante CodeBuild, consulte el [Implemente una función Lambda con AWS SAM CodeBuild Lambda Java](sample-lambda-sam-gradle.md) ejemplo o visite. [AWS Lambda](https://aws.amazon.com/lambda/)

## Configuración del repositorio de origen
<a name="sample-lambda-boto3-python.set-up-repo"></a>

Cree un repositorio de origen para almacenar su script de Boto3 para Python.

**Para configurar el repositorio de origen**

1. Copie el siguiente script de Python en un archivo nuevo denominado `update_lambda_environment_variables.py`.

   ```
   import boto3
   from os import environ
   
   
   def update_lambda_env_variable(lambda_client):
       lambda_function_name = environ['LAMBDA_FUNC_NAME']
       lambda_env_variable = environ['LAMBDA_ENV_VARIABLE']
       lambda_env_variable_value = environ['LAMBDA_ENV_VARIABLE_VALUE']
       print("Updating lambda function " + lambda_function_name + " environment variable "
             + lambda_env_variable + " to " + lambda_env_variable_value)
       lambda_client.update_function_configuration(
           FunctionName=lambda_function_name,
           Environment={
               'Variables': {
                   lambda_env_variable: lambda_env_variable_value
               }
           },
       )
   
   
   if __name__ == "__main__":
       region = environ['AWS_REGION']
       client = boto3.client('lambda', region)
       update_lambda_env_variable(client)
   ```

1. Cargue el archivo de python a un repositorio de origen compatible. Para obtener una lista de los tipos de fuentes compatibles, consulte [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Crear un proyecto de CodeBuild Python Lambda
<a name="sample-lambda-boto3-python.create-project"></a>

Cree un proyecto de CodeBuild Python Lambda.

**Para crear su proyecto CodeBuild Lambda Java**

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

1.  Si aparece una página de CodeBuild información, elija **Crear** proyecto de compilación. De lo contrario, en el panel de navegación, expanda **Compilar**, elija **Proyectos de compilación** y, a continuación, elija **Crear proyecto de compilación**. 

1. En **Project name (Nombre de proyecto)**, escriba un nombre para este proyecto de compilación. Los nombres de los proyectos de compilación deben ser únicos en cada AWS cuenta. También puede introducir una descripción opcional del proyecto de compilación para ayudar a otros usuarios a entender para qué se utiliza el proyecto.

1. En **Fuente**, selecciona el repositorio de origen en el que se encuentra tu AWS SAM proyecto.

1. En **Environment (Entorno)**:
   + En **Computación**, seleccione **Lambda**.
   + En **Tiempo(s) de ejecución**, elija **Python**.
   + En **Imagen**, selecciona **aws/codebuild/amazonlinux-x86\$164-lambda-standard:python3.12**.
   + En **Rol de servicio**, seleccione **Nuevo rol de servicio**. Anote el **Nombre del rol**. Esto será necesario cuando actualice los permisos de IAM del proyecto más adelante en este ejemplo.

1. Elija **Crear el proyecto de compilación**.

1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 

1. En el panel de navegación, elija **Roles** y seleccione el rol de servicio asociado a su proyecto. ******Para encontrar su función en el proyecto, seleccione el proyecto de construcción, elija Edición, Entorno y, a continuación, la función de servicio CodeBuild .******

1. Elija la pestaña **Relaciones de confianza** y, a continuación, **Editar política de confianza**.

1. Agregue la siguiente política insertada al rol de IAM. Esto se utilizará para implementar su AWS SAM infraestructura más adelante. Para obtener más información, consulta [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la *Guía del usuario de IAM*.

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Sid": "UpdateLambdaPermissions",
               "Effect": "Allow",
               "Action": [
                   "lambda:UpdateFunctionConfiguration"
               ],
               "Resource": [
                   "*"
               ]
           }
       ]
   }
   ```

------

## Configuración de la especificación de compilación del proyecto
<a name="sample-lambda-boto3-python.set-up-buildspec"></a>

Para actualizar la función de Lambda, el script lee las variables de entorno de la especificación de compilación y busca el nombre de la función de Lambda, el nombre de la variable de entorno y el valor de la variable de entorno.

**Para configurar la especificación de compilación del proyecto**

1. En la CodeBuild consola, selecciona tu proyecto de compilación y, a continuación, selecciona **Editar** y **Buildspec**.

1. En **Especificación de compilación**, elija **Insertar comandos de compilación** y, a continuación, **Cambiar al editor**.

1. Elimine los comandos de compilación rellenados previamente y pegue la siguiente especificación de compilación.

   ```
   version: 0.2
   env:
     variables:
       LAMBDA_FUNC_NAME: "<lambda-function-name>"
       LAMBDA_ENV_VARIABLE: "FEATURE_ENABLED"
       LAMBDA_ENV_VARIABLE_VALUE: "true"
   phases:
     install:
       commands:
          - pip3 install boto3
     build:
       commands:
          - python3 update_lambda_environment_variables.py
   ```

1. Seleccione **Update buildspec (Actualizar buildspec)**.

## Actualización de la configuración de Lambda
<a name="sample-lambda-boto3-python.update"></a>

Utilice CodeBuild Lambda Python para actualizar automáticamente la configuración de la función Lambda.

**Para actualizar la configuración de la función de Lambda**

1. Seleccione **Iniciar la compilación**.

1. Una vez finalizada la compilación, navegue hasta su función de Lambda.

1. Seleccione **Configuración** y, a continuación, elija las variables de **Entorno**. Debería aparecer una nueva variable de entorno con la clave `FEATURE_ENABLED` y el valor `true`.

## Limpieza de la infraestructura
<a name="sample-lambda-boto3-python.clean-up"></a>

Para evitar cargos adicionales por los recursos que utilizó durante este tutorial, elimine los recursos creados para su CodeBuild proyecto.

**Para limpiar la infraestructura**

1. Navegue a la CloudWatch consola y elimine los grupos de CloudWatch registros asociados a su CodeBuild proyecto.

1. Ve a la CodeBuild consola y elimina tu CodeBuild proyecto seleccionando **Eliminar proyecto de compilación**.

1. Si ha creado una función de Lambda para usarla en este ejemplo, elija **Acciones** y **Eliminar la función** para limpiar la función de Lambda.

## Extensiones
<a name="sample-lambda-boto3-python.extensions"></a>

Si desea ampliar este ejemplo para gestionar otros AWS recursos mediante AWS CodeBuild Lambda Python:
+ Actualice el script de Python para modificar los nuevos recursos con Boto3.
+ Actualice la función de IAM asociada a su CodeBuild proyecto para tener permisos para los nuevos recursos.
+ Agregue cualquier variable de entorno nueva asociada a los nuevos recursos a su especificación de compilación.

# Ejecución de compilaciones en flotas de capacidad reservada
<a name="fleets"></a>

CodeBuild ofrece las siguientes flotas informáticas:
+ Flotas bajo demanda
+ Flotas de capacidad reservada

Con flotas bajo demanda, CodeBuild proporciona procesamiento para sus compilaciones. Las máquinas se destruyen cuando finaliza la compilación. Las flotas bajo demanda están completamente administradas e incluyen capacidades de escalado automático para gestionar los picos de demanda.

**nota**  
Las flotas bajo demanda no son compatibles con macOS.

CodeBuild también ofrece flotas de capacidad reservada que contienen instancias impulsadas por Amazon EC2 que son mantenidas por. CodeBuild Con las flotas de capacidad reservada, configura un conjunto de instancias dedicadas para su entorno de compilación. Estas máquinas permanecen inactivas, listas para procesar compilaciones o pruebas de forma inmediata y reducen la duración de las compilaciones. Con flotas de capacidad reservada, sus máquinas estarán siempre en funcionamiento y seguirán incurriendo en costos mientras estén aprovisionadas.

**importante**  
Independientemente del tiempo que se ejecute una instancia, las flotas de capacidad reservada incurren en un cargo inicial por instancia, tras el cual puede haber costos adicionales asociados. Para obtener más información, consulte [https://aws.amazon.com/codebuild/pricing/](https://aws.amazon.com/codebuild/pricing/).

**Topics**
+ [Creación de una flota de capacidad reservada](#fleets.how-to)
+ [Prácticas recomendadas](#fleets.best-practices)
+ [¿Puedo compartir una flota de capacidad reservada en varios CodeBuild proyectos?](#fleets.share)
+ [¿Cómo funciona el trabajo de computación basado en atributos?](#fleets.attribute-compute)
+ [¿Puedo especificar manualmente una instancia de Amazon EC2 para mi flota?](#fleets.manual-input-compute)
+ [¿Qué regiones admiten flotas con capacidad reservada?](#fleets.regions)
+ [¿Cómo se puede configurar una flota de macOS con capacidad reservada?](#fleets.configure-macos)
+ [¿Cómo puedo configurar una imagen de máquina de Amazon (AMI) personalizada para una flota de capacidad reservada?](#fleets.custom-ami)
+ [Limitaciones de las flotas de capacidad reservada](#fleets.limitations)
+ [Propiedades de flota con capacidad reservada](fleets.reserved-capacity-fleets.md)
+ [Muestras de capacidad reservadas con AWS CodeBuild](reserved-capacity-samples.md)

## Creación de una flota de capacidad reservada
<a name="fleets.how-to"></a>

Siga las instrucciones a continuación para crear una flota de capacidad reservada.

**Para crear una flota de capacidad reservada**

1. [Inicie sesión en la AWS CodeBuild consola Consola de administración de AWS y ábrala en https://console.aws.amazon.com/codesuite/ codebuild/home.](https://console.aws.amazon.com/codesuite/codebuild/home)

1. En el panel de navegación, elija **Flotas de computación** y, a continuación, **Crear flota**.

1. En el campo de texto **Nombre de la flota de computación**, introduzca el nombre de su flota.

1. En el menú desplegable **Sistema operativo**, elija el sistema operativo.

1. En el menú desplegable **Arquitectura**, elija la arquitectura.

1. (Opcional) Seleccione **Usar modo de ejecución de instancias: opcional** para ejecutar directamente en una instancia de Amazon EC2 en lugar de en un contenedor de Docker. A continuación, elija una **Versión principal** y una **Versión secundaria**.

1. (Opcional) En **Configuración adicional**, haga lo siguiente:
   + Seleccione **Configurar VPC: opcional** para conectar la flota a una VPC y acceder a los recursos privados durante el uso.
     + En el menú desplegable de **VPC**, selecciona una VPC a la que accederá tu CodeBuild flota.
     + En el menú desplegable **Subredes**, selecciona las subredes que CodeBuild debes usar para configurar la VPC.
     + En el menú desplegable **Grupos de seguridad**, seleccione los grupos de seguridad que se CodeBuild deben usar para trabajar con la VPC.
     + En el campo **Rol de servicio de la flota**, elija un rol de servicio existente.
**nota**  
Asegúrese de que el rol de la flota tiene los permisos necesarios. Para obtener más información, consulte [Cómo permitir a un usuario agregar una política de permisos para un rol de servicio de flota](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).
     + Si ha elegido el sistema operativo Amazon Linux, seleccione **Definir configuraciones de proxy (opcional)** para aplicar control de acceso a la red a las instancias de capacidad reservada.
     + En **Comportamiento predeterminado**, elija permitir o denegar el tráfico saliente a todos los destinos de forma predeterminada.
     + En **Reglas de proxy**, selecciona **Agregar regla de proxy** para especificar los dominios de destino o IPs para permitir o denegar el control de acceso a la red.
   + Seleccione **Configurar AMI personalizada: opcional** para usar una imagen de máquina de Amazon (AMI) personalizada.
     + En el menú desplegable **AMI**, seleccione una Imagen de máquina de Amazon (AMI) para su flota.
     + En el campo **Rol de servicio de la flota**, elija un rol de servicio existente.
**nota**  
Asegúrese de que el rol de la flota tiene los permisos necesarios. Para obtener más información, consulte [Cómo permitir a un usuario agregar una política de permisos para un rol de servicio de flota](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).

1. En **Configuración de capacidad**, en **Modo de selección de computación**, elija una de las siguientes opciones:
   + Si elige **Selección guiada**, haga lo siguiente:
     + En **Computación**, elija el tipo de instancias incluidas en esta flota.
     + En el campo de texto **Capacidad**, introduzca el número mínimo de instancias de la flota.
     + (Opcional) En **Configuración adicional**, haga lo siguiente:
       + Seleccione **Configurar escalado: opcional** para escalar automáticamente la flota en función de esta configuración. En el menú desplegable **Modo de escalado: opcional**, elija el comportamiento cuando la demanda supere la capacidad de la flota.
   + Si elige **Instancia personalizada**, haga lo siguiente:
     + En el menú desplegable **Tipo de instancia de computación**, seleccione el tipo de instancias incluidas en esta flota.
     + En el campo de texto **Tamaño de volumen de EBS adicional: opcional**, introduzca el volumen adicional a los 64 GB de espacio en disco proporcionados.
     + En el campo de texto **Capacidad**, introduzca el número mínimo de instancias de la flota.
     + (Opcional) En **Configuración adicional**, haga lo siguiente:
       + Seleccione **Configurar escalado: opcional** para escalar automáticamente la flota en función de esta configuración. En el menú desplegable **Modo de escalado: opcional**, elija el comportamiento cuando la demanda supere la capacidad de la flota.

1. Elija **Crear flota de computación**.

1. Una vez creada la flota de procesamiento, cree un CodeBuild proyecto nuevo o edite uno existente. En **Entorno**, elija **Capacidad reservada** en el **Modelo de aprovisionamiento** y, a continuación, elija la flota especificada en **Nombre de flota**.

## Prácticas recomendadas
<a name="fleets.best-practices"></a>

Cuando utilice flotas de capacidad reservada, recomendamos que siga estas prácticas recomendadas.
+ Recomendamos utilizar el modo de caché de origen para ayudar a mejorar el rendimiento de la compilación mediante el almacenamiento en caché del origen.
+ Recomendamos utilizar el almacenamiento en caché de capas de Docker para mejorar el rendimiento de la compilación mediante el almacenamiento en caché de las capas de Docker existentes.

## ¿Puedo compartir una flota de capacidad reservada en varios CodeBuild proyectos?
<a name="fleets.share"></a>

Sí, puede maximizar la utilización de la capacidad de una flota utilizándola en varios proyectos.

**importante**  
Cuando se usa la característica de capacidad reservada, otros proyectos de la misma cuenta pueden acceder a los datos almacenados en caché en las instancias de flota (incluidos los archivos de origen, las capas de Docker y los directorios almacenados en caché que se indican en la especificación de compilación). Esto es así por diseño y permite que los proyectos de la misma cuenta compartan instancias de flotas.

## ¿Cómo funciona el trabajo de computación basado en atributos?
<a name="fleets.attribute-compute"></a>

Si elige `ATTRIBUTE_BASED_COMPUTE` como `computeType` de la flota, puede especificar los atributos en un nuevo campo llamado `computeConfiguration`. Estos atributos incluyen vCPUs, memoria, espacio en disco y`machineType`. Este `machineType` es `GENERAL` o `NVME`. Después de especificar uno o algunos de los atributos disponibles, CodeBuild elegirá un tipo de procesamiento entre los tipos de instancias compatibles disponibles como finalizados`computeConfiguration`.

**nota**  
CodeBuild elegirá la instancia más económica que cumpla con todos los requisitos de entrada. La memoriaCPUs, v y el espacio en disco de las instancias elegidas serán superiores o iguales a los requisitos de entrada. Puede comprobar la `computeConfiguration` resuelta en la flota creada o actualizada.

Si ingresas un `computeConfiguration` valor que no puedas cumplir CodeBuild, recibirás una excepción de validación. Tenga en cuenta también que el comportamiento de desbordamiento de la flota bajo demanda se sustituirá por el comportamiento de la cola si la `computeConfiguration` no está disponible bajo demanda.

## ¿Puedo especificar manualmente una instancia de Amazon EC2 para mi flota?
<a name="fleets.manual-input-compute"></a>

Sí, puede introducir directamente la instancia de Amazon EC2 que desee en la consola seleccionando **Instancia personalizada** o configurando el parámetro de API, `InstanceType`. Este campo se usa en lo siguiente APIs: CreateFleet UpdateFleet, CreateProject, UpdateProject y StartBuild. Para obtener más información, consulte [Compute instance type](fleets.reserved-capacity-fleets.md#compute).

## ¿Qué regiones admiten flotas con capacidad reservada?
<a name="fleets.regions"></a>

Las flotas Amazon Linux y Windows con capacidad reservada son compatibles en las siguientes áreas Regiones de AWS: EE.UU. Este (Norte de Virginia), EE.UU. Este (Ohio), EE.UU. Oeste (Oregón), Asia Pacífico (Bombay), Asia Pacífico (Singapur), Asia Pacífico (Sídney), Asia Pacífico (Tokio), Europa (Fráncfort), Europa (Irlanda) y Sudamérica (São Paulo). Para obtener más información sobre Regiones de AWS dónde CodeBuild está disponible, consulte [AWS Servicios por región.](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)

Las flotas de macOS Medium con capacidad reservada son compatibles con las siguientes áreas Regiones de AWS: EE.UU. Este (Norte de Virginia), EE.UU. Este (Ohio), EE.UU. Oeste (Oregón), Asia-Pacífico (Sídney) y Europa (Fráncfort). Capacidad reservada Las flotas macOS Large son compatibles con las siguientes áreas Regiones de AWS: EE.UU. Este (Norte de Virginia), EE.UU. Este (Ohio), EE.UU. Oeste (Oregón) y Asia-Pacífico (Sídney).

## ¿Cómo se puede configurar una flota de macOS con capacidad reservada?
<a name="fleets.configure-macos"></a>

**Para configurar una flota de macOS con capacidad reservada**

1. Inicia sesión en Consola de administración de AWS [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home) y ábrela AWS CodeBuild desde la consola.

1. En el panel de navegación, elija **Flotas de computación** y, a continuación, **Crear flota**.

1. En el campo de texto **Nombre de la flota de computación**, introduzca el nombre de su flota.

1. En el menú desplegable **Sistema operativo**, seleccione **macOS**.

1. En el campo **Compute**, selecciona uno de los siguientes tipos de máquinas informáticas: **Apple M2, 24 GB de memoria, 8 v CPUs** o **Apple M2, 32 GB de memoria,** 12 v. CPUs

1. En el campo de texto **Capacidad**, introduzca el número mínimo de instancias de la flota.

1. (Opcional) Para usar una imagen personalizada para la flota, consulte [¿Cómo puedo configurar una imagen de máquina de Amazon (AMI) personalizada para una flota de capacidad reservada?](#fleets.custom-ami) para garantizar que la Imagen de máquina de Amazon (AMI) cumpla los requisitos previos.

1. (Opcional) Para configurar una VPC con su flota, en **Configuración adicional**, haga lo siguiente:
   + En el menú desplegable **VPC (opcional)**, selecciona una VPC a la que accederá tu CodeBuild flota.
   + En el menú desplegable **Subredes**, selecciona las subredes que CodeBuild debes usar para configurar la VPC.
   + En el menú desplegable **Grupos de seguridad**, seleccione los grupos de seguridad que se CodeBuild deben usar para trabajar con la VPC.
   + En el campo **Rol de servicio de la flota**, elija un rol de servicio existente.
**nota**  
Asegúrese de que el rol de la flota tiene los permisos necesarios. Para obtener más información, consulte [Cómo permitir a un usuario agregar una política de permisos para un rol de servicio de flota](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).

1. Elija **Crear flota de computación** y espere a que se lance la instancia de flota. Una vez lanzada`n/n`, la capacidad se ubicará en el lugar donde *n* se encuentra la capacidad proporcionada.

1. Una vez lanzada la flota informática, cree un nuevo CodeBuild proyecto o edite uno existente. En **Entorno**, elija **Capacidad reservada** en el **Modelo de aprovisionamiento** y, a continuación, elija la flota especificada en **Nombre de flota**.

## ¿Cómo puedo configurar una imagen de máquina de Amazon (AMI) personalizada para una flota de capacidad reservada?
<a name="fleets.custom-ami"></a>

**Cómo configurar una imagen de máquina de Amazon (AMI) personalizada para una flota de capacidad reservada**

1. Inicia sesión en la AWS CodeBuild consola Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. En el panel de navegación, elija **Flotas de computación** y, a continuación, **Crear flota**.

1. En el campo de texto **Nombre de la flota de computación**, introduzca el nombre de su flota.

1. Elija **Imagen personalizada** para su flota y asegúrese de que su imagen de máquina de Amazon (AMI) cumpla los siguientes requisitos previos:
   + Si el tipo de entorno es `MAC_ARM`, asegúrese de que la **Arquitectura** de la AMI sea `Mac-Arm` de 64 bits.
   + Si el tipo de entorno es `LINUX_EC2`, asegúrese de que la **Arquitectura** de la AMI sea `x86` de 64 bits.
   + Si el tipo de entorno es `ARM_EC2`, asegúrese de que la **Arquitectura** de la AMI sea `Arm` de 64 bits.
   + Si el tipo de entorno es `WINDOWS_EC2`, asegúrese de que la **Arquitectura** de la AMI sea `x86` de 64 bits.
   + La AMI permite el ARN de la **organización** de CodeBuild servicios. Para obtener una lista de las organizaciones ARNs, consulte[Amazon Machine Images (AMI)](fleets.reserved-capacity-fleets.md#ami).
   + Si la AMI está cifrada con una AWS KMS clave, la AWS KMS clave también debe permitir el **ID de la organización** del CodeBuild servicio. Para obtener una lista de las organizaciones IDs, consulte[Amazon Machine Images (AMI)](fleets.reserved-capacity-fleets.md#ami). Para obtener más información sobre AWS KMS las claves, consulte [Permitir OUs a las organizaciones y usar una clave de KMS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/share-amis-with-organizations-and-OUs.html#allow-org-ou-to-use-key) en la Guía del *usuario de Amazon EC2*. Para conceder permiso a CodeBuild la organización para usar una clave de KMS, añada la siguiente declaración a la política de claves:

     ```
     {
         "Sid": "Allow access for organization root",
         "Effect": "Allow",
         "Principal": "*",
         "Action": [
             "kms:Describe*",
             "kms:List*",
             "kms:Get*",
             "kms:Encrypt",
             "kms:Decrypt",
             "kms:ReEncrypt*",
             "kms:GenerateDataKey*",
             "kms:CreateGrant"
         ],
         "Resource": "*",
         "Condition": {
             "StringEquals": {
                 "aws:PrincipalOrgID": "o-123example"
             }
         }
     }
     ```
   + En el campo **Rol de servicio de la flota**, conceda los siguientes permisos de Amazon EC2:

------
#### [ JSON ]

****  

     ```
     {
         "Version":"2012-10-17",		 	 	 
         "Statement": [
             {
                 "Effect": "Allow",
                 "Action": [
                    "ec2:DescribeImages",
                    "ec2:DescribeSnapshots"
                 ],
                 "Resource": "*"
             }
         ]
     }
     ```

------

## Limitaciones de las flotas de capacidad reservada
<a name="fleets.limitations"></a>

Hay algunos casos de uso que las flotas de capacidad reservada no admiten. En casi de que le afectan, utilice flotas bajo demanda:
+ Las flotas de capacidad reservada no admiten métricas de utilización de compilaciones.
+ Las flotas de macOS con capacidad reservada no admiten la sesión de depuración.

Para obtener más información sobre las límites y las cuotas, consulte [Flotas de computación](limits.md#fleet-limits).

# Propiedades de flota con capacidad reservada
<a name="fleets.reserved-capacity-fleets"></a>

Una flota de capacidad reservada contiene las siguientes propiedades. Para obtener más información sobre las flotas de capacidad reservada, consulte [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md). 

**Sistema operativo**  
El sistema operativo. A continuación, se muestran los sistemas operativos disponibles:  
+ Amazon Linux
+ macOS
+ Windows Server 2019
+ Windows Server 2022

**Arquitectura**  
Arquitectura del procesador. Están disponibles las siguientes arquitecturas:  
+ x86\$164
+ Arm64

**Tipo de entorno**  
Los tipos de entorno disponibles cuando se seleccione **Amazon Linux**. A continuación, se muestran los tipos de entorno disponibles:  
+ Linux EC2
+ Linux GPU

**Tipo de instancia de cómputo**  
Las configuraciones de computación de las instancias de flota.    
**Selección guiada**  
Especifique diferentes tipos de computación seleccionando la configuración de vCPU, memoria y espacio en disco. Para obtener más información acerca de la disponibilidad de tipo de computación por región, consulte [Acerca de los tipos de entorno de capacidad reservada](build-env-ref-compute-types.md#environment-reserved-capacity.types).  
**Instancia personalizada**  
Especifique manualmente el tipo de instancia deseado.

**Capacidad**  
El número inicial de máquinas asignadas a la flota, que define el número de compilaciones que pueden funcionar en paralelo.

**Comportamiento de desbordamiento**  
Define el comportamiento cuando el número de compilaciones supera la capacidad de la flota.    
**Bajo demanda**  
Las compilaciones de Overflow se ejecutan bajo CodeBuild demanda.  
Si decide establecer el comportamiento de desbordamiento como bajo demanda al crear una flota conectada a VPC, asegúrese de agregar los permisos de VPC necesarios a su rol de servicio del proyecto. Para obtener más información, consulte [Ejemplo de declaración de política para permitir el CodeBuild acceso a AWS los servicios necesarios para crear una interfaz de red de VPC](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-create-vpc-network-interface).
Si decide configurar su comportamiento de desbordamiento como bajo demanda, tenga en cuenta que las compilaciones de desbordamiento se facturarán por separado, de manera similar a Amazon EC2 bajo demanda. Para obtener más información, consulte [https://aws.amazon.com/codebuild/pricing/](https://aws.amazon.com/codebuild/pricing/).  
**Cola**  
Las ejecuciones de compilaciones se colocan en una cola hasta que haya una máquina disponible. Esto limita los costos adicionales, ya que no se asignan máquinas adicionales.

**Imágenes de máquina de Amazon (AMI)**  
Las propiedades de Imagen de máquina de Amazon (AMI) de su flota. Las siguientes propiedades son compatibles CodeBuild con:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/fleets.reserved-capacity-fleets.html)

**Configuración adicional**    
**VPC (opcional)**  
La VPC a la que accederá su CodeBuild flota. Para obtener más información, consulte [Úselo AWS CodeBuild con Amazon Virtual Private Cloud](vpc-support.md).  
Si se especifica una anulación de flota al llamar a la StartBuild API, CodeBuild ignorará la configuración de la VPC del proyecto.  
**Subredes**  
Las subredes de VPC que se CodeBuild utilizan para configurar la configuración de la VPC. Tenga en cuenta que las flotas de capacidad reservada solo admiten una subred en una única zona de disponibilidad. Además, asegúrese de que las subredes incluyan una puerta de enlace de NAT.  
**Grupos de seguridad**  
Los grupos de seguridad de VPC que se CodeBuild utilizan con su VPC. Asegúrese de que sus grupos de seguridad permitan conexiones salientes.  
**Rol de servicio de la flota**  
Define el rol de servicio de su flota a partir de un rol de servicio existente en su cuenta.  
**Definir configuraciones de proxy (opcional)**  
Configuraciones de proxy que aplican el control de acceso a la red a las instancias de capacidad reservada. Para obtener más información, consulte [AWS CodeBuild Utilícelo con un servidor proxy gestionado](run-codebuild-in-managed-proxy-server.md).  
Las configuraciones de proxy no admiten VPC, Windows ni macOS.  
**Comportamiento predeterminado**  
Define el comportamiento del tráfico saliente.    
**Permitir**  
Permite el tráfico saliente a todos los destinos de forma predeterminada.  
**Denegar**  
Deniega el tráfico saliente a todos los destinos de forma predeterminada.  
**Reglas de proxy**  
Especifica los dominios de destino o IPs a los que permitir o denegar el control de acceso a la red.

# Muestras de capacidad reservadas con AWS CodeBuild
<a name="reserved-capacity-samples"></a>

Estos ejemplos se pueden utilizar para experimentar con flotas de capacidad reservada. CodeBuild

**Topics**
+ [Ejemplo de almacenamiento en caché con capacidad reservada](#reserved-capacity-samples.caching)

## Ejemplo de almacenamiento en caché con capacidad reservada
<a name="reserved-capacity-samples.caching"></a>

Una caché puede almacenar fragmentos reutilizables del entorno de compilación y utilizarlos en diferentes compilaciones. En este ejemplo se muestra cómo habilitar el almacenamiento en caché dentro de su proyecto de compilación utilizando la capacidad reservada. Para obtener más información, consulte [Almacenamiento de las compilaciones en caché para mejorar el rendimiento](build-caching.md).

Puede empezar por especificar uno o varios modos de caché en la configuración de su proyecto:

```
Cache:
        Type: LOCAL
        Modes:
          - LOCAL_CUSTOM_CACHE
          - LOCAL_DOCKER_LAYER_CACHE
          - LOCAL_SOURCE_CACHE
```

**nota**  
Asegúrese de habilitar el modo con privilegios para utilizar la caché de capas de Docker.

La configuración de la especificación de compilación de su proyecto debe tener el aspecto siguiente:

```
version: 0.2
      phases:
        build:
          commands:
            - echo testing local source cache
            - touch /codebuild/cache/workspace/foobar.txt
            - git checkout -b cached_branch
            - echo testing local docker layer cache
            - docker run alpine:3.14 2>&1 | grep 'Pulling from' || exit 1
            - echo testing local custom cache
            - touch foo
            - mkdir bar && ln -s foo bar/foo2
            - mkdir bar/bar && touch bar/bar/foo3 && touch bar/bar/foo4
            - "[ -f foo ] || exit 1"
            - "[ -L bar/foo2 ] || exit 1"
            - "[ -f bar/bar/foo3 ] || exit 1"
            - "[ -f bar/bar/foo4 ] || exit 1"
      cache:
        paths:
           - './foo'
           - './bar/**/*'
           - './bar/bar/foo3'
```

Puede empezar por ejecutar una compilación con el nuevo proyecto para propagar la caché. Una vez hecho esto, debe empezar otra compilación con una especificación de compilación de anulación, similar a la siguiente:

```
version: 0.2
      phases:
        build:
          commands:
            - echo testing local source cache
            - git branch | if grep 'cached_branch'; then (exit 0); else (exit 1); fi
            - ls /codebuild/cache/workspace | if grep 'foobar.txt'; then (exit 0); else (exit 1); fi
            - echo testing local docker layer cache
            - docker run alpine:3.14 2>&1 | if grep 'Pulling from'; then (exit 1); else (exit 0); fi
            - echo testing local custom cache
            - "[ -f foo ] || exit 1"
            - "[ -L bar/foo2 ] || exit 1"
            - "[ -f bar/bar/foo3 ] || exit 1"
            - "[ -f bar/bar/foo4 ] || exit 1"
      cache:
        paths:
           - './foo'
           - './bar/**/*'
           - './bar/bar/foo3'
```

# Ejecución de compilaciones en lotes
<a name="batch-build"></a>

Se puede utilizar AWS CodeBuild para ejecutar compilaciones simultáneas y coordinadas de un proyecto con compilaciones por lotes. 

**Topics**
+ [Rol de seguridad](#batch_security_role)
+ [Tipos de compilación por lotes](#batch_build_types)
+ [Modo de informe por lotes](#batch-report-mode)
+ [Más información](#batch_more_info)

## Rol de seguridad
<a name="batch_security_role"></a>

Las compilaciones por lotes introducen un nuevo rol de seguridad en la configuración por lotes. Este nuevo rol es obligatorio`StartBuild`, `StopBuild` ya que CodeBuild debes poder ejecutar las compilaciones y `RetryBuild` acciones en tu nombre para ejecutar compilaciones como parte de un lote. Los clientes deberían utilizar un nuevo rol, y no el mismo rol que utilizan para su compilación, por dos motivos:
+ Al asignar los permisos de `StartBuild`, `StopBuild` y `RetryBuild` en el rol de compilación, una sola compilación podría iniciar más compilaciones a través de la especificación de compilación.
+ CodeBuild Las compilaciones por lotes proporcionan restricciones que restringen la cantidad de compilaciones y tipos de procesamiento que se pueden usar para las compilaciones del lote. Si la función de compilación tiene estos permisos, es posible que las propias compilaciones puedan eludir estas restricciones.

## Tipos de compilación por lotes
<a name="batch_build_types"></a>

CodeBuild admite los siguientes tipos de compilación por lotes:

**Topics**
+ [Grafo de compilación](#batch_build_graph)
+ [Lista de compilación](#batch_build_list)
+ [Matriz de compilación](#batch_build_matrix)
+ [Distribución ramificada de compilación](#batch_build_fanout)

### Grafo de compilación
<a name="batch_build_graph"></a>

Un grafo de compilación define un conjunto de tareas que dependen de otras tareas del lote. 

En el siguiente ejemplo, se define un grafo de compilación que crea una cadena de dependencias. 

```
batch:
  fast-fail: false
  build-graph:
    - identifier: build1
      env:
        variables:
          BUILD_ID: build1
      ignore-failure: false
    - identifier: build2
      buildspec: build2.yml
      env:
        variables:
          BUILD_ID: build2
      depend-on:
        - build1
    - identifier: build3
      env:
        variables:
          BUILD_ID: build3
      depend-on:
        - build2
    - identifier: build4
      env:
        compute-type: ARM_LAMBDA_1GB
    - identifier: build5
      env:
        fleet: fleet_name
```

En este ejemplo:
+ `build1` se ejecuta primero porque no tiene dependencias.
+ `build2` depende de `build1`, por lo que `build2` se ejecuta después de completar `build1`.
+ `build3` depende de `build2`, por lo que `build3` se ejecuta después de completar `build2`.

Para obtener más información acerca de la sintaxis del grafo de especificación de compilación, consulte [`batch/build-graph`](batch-build-buildspec.md#build-spec.batch.build-graph).

### Lista de compilación
<a name="batch_build_list"></a>

Una lista de compilación define una serie de tareas que se ejecutan en paralelo. 

En el ejemplo siguiente se define una lista de compilación. Las compilaciones `build1` y `build2` se ejecutarán en paralelo.

```
batch:
  fast-fail: false
  build-list:
    - identifier: build1
      env:
        variables:
          BUILD_ID: build1
      ignore-failure: false
    - identifier: build2
      buildspec: build2.yml
      env:
        variables:
          BUILD_ID: build2
      ignore-failure: true
    - identifier: build3
      env:
        compute-type: ARM_LAMBDA_1GB
    - identifier: build4
      env:
        fleet: fleet_name
    - identifier: build5
      env:
        compute-type: GENERAL_LINUX_XLAGRE
```

Para obtener más información acerca de la sintaxis de la lista de especificación de compilación, consulte [`batch/build-list`](batch-build-buildspec.md#build-spec.batch.build-list).

### Matriz de compilación
<a name="batch_build_matrix"></a>

Una matriz de compilación define las tareas con diferentes configuraciones que se ejecutan en paralelo. CodeBuild crea una compilación independiente para cada combinación de configuraciones posible. 

El ejemplo siguiente muestra una matriz de compilación con dos archivos de especificaciones de compilación y tres valores de una variable de entorno.

```
batch:
  build-matrix:
    static:
      ignore-failure: false
    dynamic:
      buildspec: 
        - matrix1.yml
        - matrix2.yml
      env:
        variables:
          MY_VAR:
            - VALUE1
            - VALUE2
            - VALUE3
```

En este ejemplo, CodeBuild crea seis compilaciones:
+ `matrix1.yml` por `$MY_VAR=VALUE1`
+ `matrix1.yml` por `$MY_VAR=VALUE2`
+ `matrix1.yml` por `$MY_VAR=VALUE3`
+ `matrix2.yml` por `$MY_VAR=VALUE1`
+ `matrix2.yml` por `$MY_VAR=VALUE2`
+ `matrix2.yml` por `$MY_VAR=VALUE3`

Cada compilación tendrá la configuración siguiente:
+ `ignore-failure` es `false`.
+ `env/type` es `LINUX_CONTAINER`.
+ `env/image` es `aws/codebuild/amazonlinux-x86_64-standard:4.0`.
+ `env/privileged-mode` es `true`.

Estas compilaciones se ejecutan en paralelo.

Para obtener más información acerca de la sintaxis de la matriz de especificación de compilación, consulte [`batch/build-matrix`](batch-build-buildspec.md#build-spec.batch.build-matrix).

### Distribución ramificada de compilación
<a name="batch_build_fanout"></a>

Una distribución ramificada de compilación define una tarea que se dividirá en varias compilaciones en el lote. Esto se puede utilizar para ejecutar pruebas en paralelo. CodeBuild crea una compilación independiente para cada fragmento de casos de prueba en función del valor establecido en el `parallelism` campo.

En el siguiente ejemplo, se define una distribución ramificada de compilación que crea cinco compilaciones que se ejecutan en paralelo.

```
version: 0.2

batch:
   fast-fail: false 
   build-fanout:
     parallelism: 5
     ignore-failure: false

phases:
  install:
    commands:
      - npm install
   build:
    commands:
      - mkdir -p test-results
      - cd test-results
      - |
        codebuild-tests-run \
         --test-command 'npx jest --runInBand --coverage' \
         --files-search "codebuild-glob-search '**/test/**/*.test.js'" \
         --sharding-strategy 'equal-distribution'
```

En este ejemplo, suponiendo que hay 100 pruebas que deben ejecutarse, CodeBuild crea cinco compilaciones, cada una de las cuales ejecuta 20 pruebas en paralelo.

Para obtener más información acerca de la sintaxis del grafo de especificación de compilación, consulte [`batch/build-fanout`](batch-build-buildspec.md#build-spec.batch.build-fanout).

## Modo de informe por lotes
<a name="batch-report-mode"></a>

Si el proveedor de origen de tu proyecto es Bitbucket o GitHub Enterprise y tu proyecto está configurado para informar de los estados de compilación al proveedor de origen, puedes seleccionar cómo quieres que se envíen los estados de compilación por lotes al proveedor de origen. GitHub Es posible seleccionar que los estados se envíen como un único informe de estado agregado para el lote o que se notifique el estado de cada compilación de lote por separado.

Para obtener más información, consulte los temas siguientes:
+ [Configuración por lotes (crear)](create-project.md#create-project-console-batch-config)
+ [Configuración por lotes (actualizar)](change-project.md#change-project-console-batch-config)

## Más información
<a name="batch_more_info"></a>

Para obtener más información, consulte los temas siguientes:
+ [Referencia de especificaciones de compilación para compilación por lotes](batch-build-buildspec.md)
+ [Configuración de lotes](create-project.md#create-project-console-batch-config)
+ [Ejecutar una compilación por lotes (AWS CLI)](run-batch-build-cli.md)
+ [Detención de las compilaciones por lotes en AWS CodeBuild](stop-batch-build.md)

# Ejecución de pruebas paralelas en compilaciones por lotes
<a name="parallel-test"></a>

Se puede utilizar AWS CodeBuild para ejecutar pruebas paralelas en compilaciones por lotes. La ejecución de pruebas paralelas es un método de prueba en el que varios casos de prueba se ejecutan simultáneamente en diferentes entornos, equipos o navegadores, en lugar de ejecutarse secuencialmente. Este método puede reducir significativamente el tiempo total de ejecución de las pruebas y mejorar su eficiencia. En CodeBuild, puedes dividir tus pruebas en varios entornos y ejecutarlas simultáneamente.

Las principales ventajas de la ejecución de pruebas paralelas son:

1. **Tiempo de ejecución reducido**: pruebas que tardarían horas de forma secuencial pueden completarse en minutos.

1. **Mejor utilización de los recursos**: hace un uso eficiente de los recursos informáticos disponibles.

1. **Comentarios más rápidos**: la realización más rápida de las pruebas permite obtener comentarios más rápidamente a los desarrolladores.

1. **Rentable**: ahorra tiempo y costos de computación a largo plazo.

Al implementar la ejecución de pruebas paralelas se suelen considerar dos enfoques principales: entornos separados y multiproceso. Si bien ambos métodos buscan conseguir la ejecución de pruebas simultáneas, difieren significativamente en su implementación y efectividad. Los entornos separados crean instancias aisladas en las que cada conjunto de pruebas se ejecuta de forma independiente, mientras que el multiproceso ejecuta varias pruebas simultáneamente dentro del mismo espacio de proceso utilizando diferentes subprocesos.

Las principales ventajas de los entornos separados en comparación con el multiproceso son:

1. **Aislamiento**: cada prueba se ejecuta en un entorno completamente aislado, lo que evita la interferencia entre pruebas.

1. **Conflictos de recursos**: no hay competencia por recursos compartidos, algo que suele producirse en el multiproceso.

1. **Estabilidad**: es menos propenso a condiciones de carrera y a problemas de sincronización.

1. **Depuración más sencilla**: cuando fallan las pruebas, es más fácil identificar la causa, ya que cada entorno es independiente.

1. **Administración del estado**: administre fácilmente problemas de estado compartidos que afectan habitualmente a las pruebas multiproceso.

1. **Mejor escalabilidad**: puede agregar fácilmente más entornos sin complejidad.

**Topics**
+ [Support en AWS CodeBuild](#parallel-test-support)
+ [Habilitación de la ejecución de pruebas paralelas en compilaciones por lotes](parallel-test-enable.md)
+ [Uso del comando `codebuild-tests-run` de la CLI](parallel-test-tests-run.md)
+ [Uso del comando `codebuild-glob-search` de la CLI](parallel-test-glob-search.md)
+ [Acerca de la división de pruebas](parallel-test-splitting.md)
+ [Combine automáticamente informes de compilación individuales](parallel-test-auto-merge.md)
+ [Ejemplo de ejecución de pruebas paralelas para varios marcos de prueba](sample-parallel-test.md)

## Support en AWS CodeBuild
<a name="parallel-test-support"></a>

AWS CodeBuild proporciona un soporte sólido para la ejecución de pruebas en paralelo a través de su función de compilación por lotes, diseñada específicamente para aprovechar la ejecución de entornos separados. Esta implementación se alinea perfectamente con los beneficios de los entornos de pruebas aislados.

**Compilación por lotes con distribución de pruebas**  
CodeBuildSu funcionalidad de compilación por lotes permite la creación de varios entornos de compilación que se ejecutan simultáneamente. Cada entorno funciona como una unidad completamente aislada, con sus propios recursos de computación, entorno de tiempo de ejecución y dependencias. A través de la configuración de compilación por lotes puede especificar cuántos entornos paralelos necesitan y cómo deben distribuirse las pruebas entre ellos.

**Prueba de CLI de partición**  
CodeBuild incluye un mecanismo de distribución de pruebas integrado a través de su herramienta CLI`codebuild-tests-run`, que divide automáticamente las pruebas en diferentes entornos.

**Agregación de informes**  
Uno de los puntos fuertes clave de su implementación CodeBuild es su capacidad para gestionar la agregación de los resultados de las pruebas sin problemas. Si bien las pruebas se ejecutan en entornos separados, recopila y combina CodeBuild automáticamente los informes de prueba de cada entorno en un informe de prueba unificado a nivel de compilación por lotes. Esta consolidación proporciona una vista integral de los resultados de las pruebas y, al mismo tiempo, mantiene los beneficios de eficiencia de la ejecución paralela.

El siguiente diagrama explica el concepto completo de ejecución de pruebas paralelas en AWS CodeBuild.

![\[Diagrama conceptual de la ejecución de pruebas paralelas.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/parallel-test.png)


# Habilitación de la ejecución de pruebas paralelas en compilaciones por lotes
<a name="parallel-test-enable"></a>

Para ejecutar pruebas en paralelo, actualice el archivo buildspec de compilación por lotes para incluir el campo build-fanout y el número de compilaciones paralelas para dividir el conjunto de pruebas en el campo `parallelism`, como se muestra a continuación. El campo `parallelism` especifica cuántos ejecutores independientes están configurados para ejecutar el conjunto de pruebas.

Para ejecutar las pruebas en varios entornos de ejecución paralela, establezca el campo `parallelism` en un valor mayor que cero. En el ejemplo siguiente, `parallelism` se establece en cinco, lo que significa que CodeBuild inicia cinco compilaciones idénticas que ejecutan una parte del conjunto de pruebas en paralelo.

Puede usar el comando [codebuild-tests-run](parallel-test-tests-run.md)CLI para dividir y ejecutar las pruebas. Los archivos de prueba se dividirán y una parte de las pruebas se ejecutará en cada compilación. Esto reduce el tiempo total necesario para ejecutar todo el conjunto de pruebas. En el siguiente ejemplo, las pruebas se dividirán en cinco y los puntos de división se calcularán en función del nombre de las pruebas.

```
version: 0.2

batch:
  fast-fail: false 
  build-fanout:
    parallelism: 5
    ignore-failure: false
    
phases:
  install:
    commands:
      - npm install jest-junit --save-dev
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - |
        codebuild-tests-run \
         --test-command 'npx jest --runInBand --coverage' \
         --files-search "codebuild-glob-search '**/_tests_/**/*.test.js'" \
         --sharding-strategy 'equal-distribution'

  post_build:
    commands:
      - codebuild-glob-search '**/*.xml'  
      - echo "Running post-build steps..."
      - echo "Build completed on `date`"

reports:
  test-reports:
    files:
      - '**/junit.xml'               
    base-directory: .
    discard-paths: yes           
    file-format: JUNITXML
```

Si los informes están configurados para compilar de forma dispersa, los informes de prueba se generan para cada compilación por separado, y se pueden ver en la pestaña **Informes** de las compilaciones correspondientes de la consola. AWS CodeBuild 

Para obtener más información sobre cómo ejecutar pruebas paralelas por lotes, consulte [Ejemplo de ejecución de pruebas paralelas para varios marcos de prueba](sample-parallel-test.md).

# Uso del comando `codebuild-tests-run` de la CLI
<a name="parallel-test-tests-run"></a>

AWS CodeBuild proporciona una CLI que tomará el comando de prueba y la ubicación del archivo de prueba como entrada. La CLI con estas entradas dividirá las pruebas en el número de particiones especificado en el campo `parallelism` basándose en los nombres de los archivos de prueba. La asignación de archivos de prueba a la partición se decide mediante la estrategia de partición.

```
codebuild-tests-run \
    --files-search "codebuild-glob-search '**/__tests__/*.js'" \
    --test-command 'npx jest --runInBand --coverage' \
    --sharding-strategy 'equal-distribution'
```

En la siguiente tabla se describen los capos del comando `codebuild-tests-run` de la CLI.


| Nombre del campo | Tipo | Obligatorio u opcional | Definición | 
| --- | --- | --- | --- | 
|  `test-command`  |  Cadena  |  Obligatorio  |  Este comando se usa para ejecutar las pruebas.  | 
|  `files-search`  |  Cadena  |  Obligatorio  |  Este comando proporciona una lista de archivos de prueba. Puede utilizar el comando [codebuild-glob-search](parallel-test-glob-search.md)CLI AWS CodeBuild proporcionado o cualquier otra herramienta de búsqueda de archivos que prefiera.  Asegúrese de que el comando `files-search` muestre los nombres de archivo, cada uno de ellos separado por una línea.   | 
|  `sharding-strategy`  |  Enum  |  Opcional  |  Valores válidos: `equal-distribution`, (predeterminado), `stability` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/parallel-test-tests-run.html) Para obtener más información, consulte [Acerca de la división de pruebas](parallel-test-splitting.md).  | 

La `codebuild-tests-run` CLI trabaja primero para identificar la lista de archivos de prueba mediante el comando proporcionado en el parámetro `files-search`. A continuación, determina un subconjunto de archivos de prueba designados para la partición (entorno) actual mediante la estrategia de partición especificada. Por último, este subconjunto de archivos de prueba se formatea en una lista separada por espacios y se añade al final del comando proporcionado en el parámetro `test-command` antes de que se ejecute.

Para los marcos de prueba que no aceptan listas separadas por espacios, la `codebuild-tests-run` CLI proporciona una alternativa flexible a través de la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES`. Esta variable contiene una lista separada por líneas de rutas de archivos de prueba designadas para la partición de compilación actual. Aprovechando esta variable de entorno, puede adaptarse fácilmente a varios requisitos del marco de pruebas y adaptarse a aquellos que requieren formatos de entrada diferentes de listas separadas por espacios. Además, también puede formatear los nombres de los archivos de prueba según las necesidades del marco de prueba. A continuación se ofrece un ejemplo de uso de `CODEBUILD_CURRENT_SHARD_FILES` en Linux con el marco Django. Aquí se usa `CODEBUILD_CURRENT_SHARD_FILES` para obtener rutas de archivo de *notación de puntos* compatibles con Django:

```
codebuild-tests-run \
    —files-search "codebuild-glob-search '/tests/test_.py'" \
    —test-command 'python3 manage.py test $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed -E "s/\//__/g; s/\.py$//; s/__/./g")' \
    —sharding-strategy 'equal-distribution'
```

**nota**  
Tenga en cuenta que la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES` solo se puede utilizar dentro del ámbito de la `codebuild-tests-run` CLI.  
Además, si utiliza `CODEBUILD_CURRENT_SHARD_FILES` dentro de test-command, escriba `CODEBUILD_CURRENT_SHARD_FILES` entre comillas dobles como se muestra en el ejemplo anterior.

# Uso del comando `codebuild-glob-search` de la CLI
<a name="parallel-test-glob-search"></a>

AWS CodeBuild proporciona una herramienta CLI integrada denominada `codebuild-glob-search` que le permite buscar archivos en el directorio de trabajo en función de uno o más patrones globales. Esta herramienta puede resultar especialmente útil cuando desee ejecutar pruebas en archivos o directorios específicos del proyecto.

## De uso
<a name="parallel-test-glob-search.usage"></a>

La `codebuild-glob-search` CLI tiene la siguiente sintaxis de uso:

```
codebuild-glob-search <glob_pattern1> [<glob_pattern2> ...]
```
+ `<glob_pattern1>`, `<glob_pattern2>`, etc.: uno o más patrones globales para compararlos con los archivos del directorio de trabajo.
+ `*`: coincide con cualquier secuencia de caracteres (excepto los separadores de ruta).
+ `**`: coincide con cualquier secuencia de caracteres (incluidos los separadores de ruta).

**nota**  
Asegúrese de que la cadena global vaya entre comillas. Para comprobar los resultados de la coincidencia de patrones, utilice el comando `echo`.  

```
version: 0.2

phases:
  build:
    commands:
      - echo $(codebuild-glob-search '**/__tests__/*.js')
      - codebuild-glob-search '**/__tests__/*.js' | xargs -n 1 echo
```

## Output
<a name="parallel-test-glob-search.output"></a>

La CLI generará una nueva lista de rutas de archivo separadas por líneas que coincidan con los patrones globales proporcionados. Las rutas de archivo devueltas serán relativas al directorio de trabajo.

Si no se encuentra ningún archivo que coincida con los patrones proporcionados, la CLI generará un mensaje que indica que no se ha encontrado ningún archivo.

Tenga en cuenta que los directorios que se encuentren debido a un patrón determinado se excluirán de los resultados de la búsqueda.

## Ejemplo
<a name="parallel-test-glob-search.example"></a>

Si desea buscar solo archivos dentro del directorio tests y sus subdirectorios con extensión `.js`, puede usar el siguiente comando con la `codebuild-glob-search` CLI:

```
codebuild-glob-search '**/__tests__/*.js'
```

Este comando buscará todos los archivos con extensión `.js` dentro del directorio `__tests__` y sus subdirectorios, como indica el patrón.

# Acerca de la división de pruebas
<a name="parallel-test-splitting"></a>

La función de división de pruebas de AWS CodeBuild le permite paralelizar la ejecución del conjunto de pruebas en varias instancias de computación, lo que reduce el tiempo total de ejecución de las pruebas. Esta función se habilita mediante la configuración por lotes en los ajustes CodeBuild del proyecto y la `codebuild-tests-run` utilidad del archivo buildspec.

Las pruebas se dividen en función de la estrategia de fragmentación especificada. CodeBuild proporciona dos estrategias de fragmentación, tal como se especifica a continuación:

Equal-distribution  
La estrategia de partición `equal-distribution` divide las pruebas en compilaciones paralelas por orden alfabético de los nombres de los archivos de prueba. Este método ordena primero los archivos de prueba y, a continuación, emplea un método basado en fragmentos para distribuirlos, lo que garantiza que archivos similares se agrupen para las pruebas. Se recomienda cuando se trata de un conjunto relativamente pequeño de archivos de prueba. Si bien este método tiene como objetivo asignar aproximadamente el mismo número de archivos a cada partición, con una diferencia máxima de uno, no garantiza la estabilidad. Cuando se agregan o quitan archivos de prueba en compilaciones posteriores, la distribución de los archivos existentes puede cambiar, lo que podría provocar una reasignación entre particiones.

Stability  
La estrategia de partición `stability` emplea un algoritmo de hash coherente para dividir las pruebas entre particiones, lo que garantiza que la distribución de los archivos se mantenga estable. Cuando se agregan o eliminan nuevos archivos, este enfoque garantiza que las file-to-shard asignaciones existentes permanezcan prácticamente sin cambios. En el caso de conjuntos de pruebas de gran tamaño, se recomienda utilizar la opción de estabilidad para distribuir uniformemente las pruebas entre particiones. Este mecanismo tiene como objetivo proporcionar una distribución casi equitativa, lo que garantiza que cada partición reciba una cantidad similar de archivos, con una variación mínima. Si bien la estrategia de estabilidad no garantiza una distribución equitativa ideal, ofrece una distribución casi equitativa que mantiene la coherencia en las asignaciones de archivos entre las compilaciones, incluso cuando se agregan o eliminan archivos.

Para habilitar la división de pruebas, debe configurar la sección de lotes en los ajustes CodeBuild del proyecto, especificando el `parallelism` nivel deseado y otros parámetros relevantes. Además, deberá incluir la utilidad `codebuild-tests-run` en el archivo buildspec, junto con los comandos de prueba y el método de división adecuados.

# Combine automáticamente informes de compilación individuales
<a name="parallel-test-auto-merge"></a>

En las compilaciones por lotes distribuidas, AWS CodeBuild admite la fusión automática de informes de compilación individuales en un informe consolidado a nivel de lote. Esta característica proporciona una vista completa de los resultados de las pruebas y cobertura de código en todas las compilaciones de un lote.

## Funcionamiento
<a name="parallel-test-auto-merge.how"></a>

[Al ejecutar compilaciones `fanout` por lotes, cada compilación individual genera informes de prueba.](test-reporting.md) CodeBuild a continuación, consolida automáticamente los informes idénticos de diferentes compilaciones en un informe unificado, que se adjunta a la compilación por lotes. Se puede acceder fácilmente a estos informes consolidados a través del `reportArns` campo de la [ BatchGetBuildBatches](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_BatchGetBuildBatches.html#CodeBuild-BatchGetBuildBatches-response-buildBatches)API y también se pueden ver en la pestaña **Informes** de la consola. Esta capacidad de combinación se extiende también a los informes de detección automática.

Los informes consolidados se crean en [grupos de informes](test-report-group.md) que se especifican en la especificación de compilación o los detectan automáticamente. CodeBuild Puede analizar tendencias de los informes combinados directamente en estos grupos de informes, lo que proporciona información valiosa sobre el rendimiento general de la compilación y las métricas de calidad en compilaciones históricas del mismo proyecto de compilación por lotes.

Para cada compilación individual del lote, crea CodeBuild automáticamente grupos de informes independientes. Estos siguen una convención de nomenclatura específica que combina el nombre del grupo de informes de creación por lotes con un sufijo de `BuildFanoutShard<shard_number>`, donde el `shard_number` representa el número de partición en el que se crea el grupo de informes. Esta organización le permite realizar un seguimiento y analizar tendencias tanto en el nivel de compilación consolidada como individual, lo que proporciona flexibilidad a la hora de monitorear y evaluar sus procesos de compilación.

El informe de creación por lotes sigue la misma estructura que los [informes de compilación individuales](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_Report.html). Los siguientes campos clave de la pestaña **Informe** son específicos de los informes de compilación por lotes:

**Estado de informe de compilación por lotes**  
El estado de los informes de creación por lotes sigue reglas específicas según el tipo de informe:  
+ Informes de pruebas:
  + Correcto: el estado se establece como correcto cuando todos los informes de compilación individuales se han realizado correctamente.
  + Error: el estado se establece como fallido si ha fallado algún informe de compilación individual.
  + Incompleto: el estado se marca como incompleto si falta algún informe de compilación individual o tiene un estado incompleto.
+ Informes de cobertura de código:
  + Completo: el estado se establece como completo cuando se han completado todos los informes de compilación individuales.
  + Error: el estado se establece como fallido si ha fallado algún informe de compilación individual.
  + Incompleto: el estado se marca como incompleto si falta algún informe de compilación individual o tiene un estado incompleto.

**Resumen de pruebas**  
El informe de prueba combinado consolida los siguientes campos de todos los informes de compilación individuales:  
+ duration-in-nano-seconds: Tiempo máximo de duración de la prueba en nanosegundos entre todos los informes de compilación individuales.
+ total: recuento combinado de todos los casos de prueba, sumando el número total de pruebas de cada compilación.
+ status-counts: proporciona una vista consolidada de estados de las pruebas, como superadas, fallidas u omitidas, que se calcula sumando el recuento de cada tipo de estado en todas las compilaciones individuales.

**Resumen de cobertura de código**  
El informe combinado de cobertura de código combina campos de todas las compilaciones individuales utilizando los siguientes cálculos:  
+ branches-covered: suma de todas las ramificaciones cubiertas de informes individuales.
+ branches-missed: suma de todas las ramificaciones omitidas de informes individuales.
+ branch-coverage-percentage: `(Total covered branches / Total branches) * 100`
+ lines-covered: suma de todas las líneas cubiertas de informes individuales.
+ lines-missed: suma de todas las líneas omitidas de informes individuales.
+ lines-coverage-percentage: `(Total covered lines / Total lines) * 100`

**ID de ejecución**  
ARN de compilación por lotes.

**Casos de prueba**  
El informe combinado contiene una lista consolidada de todos los casos de prueba de compilaciones individuales, a la que se puede acceder a través de la [DescribeTestCases](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeTestCases.html)API y del informe de compilación por lotes de la consola.

**Coberturas de código**  
El informe de cobertura de código combinado proporciona información consolidada sobre la cobertura de líneas y sucursales de cada archivo en todas las compilaciones individuales, a la que se puede acceder a través de la [DescribeCodeCoverages](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeCodeCoverages.html)API y del informe de compilación por lotes de la consola. Nota: En el caso de los archivos cubiertos por varios archivos de prueba distribuidos en diferentes particiones, el informe combinado sigue estos criterios de selección:  

1. La selección principal se basa en la cobertura de línea más alta entre las particiones.

1. Si la cobertura de línea es igual en varias particiones, se seleccione la partición con mayor cobertura de ramificación.

# Ejemplo de ejecución de pruebas paralelas para varios marcos de prueba
<a name="sample-parallel-test"></a>

Puede utilizar el comando `codebuild-tests-run` de la CLI para dividir y ejecutar pruebas en entornos de ejecución paralelos. En la siguiente sección, se proporcionan ejemplos de `buildspec.yml` para varios marcos que ilustran el uso del comando `codebuild-tests-run`.
+ Cada uno de los siguientes ejemplos incluye un nivel de `parallelism` de cinco, lo que significa que se crearán cinco entornos de ejecución idénticos para dividir las pruebas. Puede elegir un nivel de `parallelism` que se ajuste a su proyecto modificando el valor de `parallelism` en la sección `build-fanout`.
+ En cada uno de los ejemplos siguientes se muestra la configuración de las pruebas para que se dividan por nombre del archivo de prueba, que es el predeterminado. Esto distribuye las pruebas de manera uniforme entre los entornos de ejecución paralelos.

Antes de empezar, consulte [Ejecución de pruebas paralelas en compilaciones por lotes](parallel-test.md) para obtener más información.

Para obtener una lista completa de opciones al utilizar el comando `codebuild-tests-run` de la CLI, consulte [Uso del comando `codebuild-tests-run` de la CLI](parallel-test-tests-run.md).

**Topics**
+ [Configuración de pruebas paralelas con Django](sample-parallel-test-django.md)
+ [Configuración de pruebas paralelas con Elixir](sample-parallel-test-elixir.md)
+ [Configuración de pruebas paralelas con Go](sample-parallel-test-go.md)
+ [Configuración de pruebas paralelas con Java (Maven)](sample-parallel-test-java-maven.md)
+ [Configuración de pruebas paralelas con Javascript (Jest)](sample-parallel-test-javascript.md)
+ [Configuración de pruebas paralelas con Kotlin](sample-parallel-test-kotlin.md)
+ [Configuración de pruebas paralelas con PHPUnit](sample-parallel-test-phpunit.md)
+ [Configuración de pruebas paralelas con Pytest](sample-parallel-test-python.md)
+ [Configuración de pruebas paralelas con Ruby (Cucumber)](sample-parallel-test-ruby-cucumber.md)
+ [Configuración de pruebas paralelas con Ruby (Cucumber)](sample-parallel-test-ruby.md)

# Configuración de pruebas paralelas con Django
<a name="sample-parallel-test-django"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Django en una plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - sudo yum install -y python3 python3-pip 
      - python3 -m ensurepip --upgrade 
      - python3 -m pip install django
  pre_build:
    commands:
      - echo 'Prebuild'
  build:
    commands:
      - echo 'Running Django Tests'
      - |
        codebuild-tests-run \
         --test-command 'python3 manage.py test $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed -E "s/\//__/g; s/\.py$//; s/__/./g")' \ 
         --files-search "codebuild-glob-search '**/tests/*test_*.py'" \
         --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo 'Test execution completed'
```

El ejemplo anterior muestra el uso de la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES`. Aquí `CODEBUILD_CURRENT_SHARD_FILES` se usa para obtener rutas de archivo de notación de puntos de recuperación compatibles con Django. Use `CODEBUILD_CURRENT_SHARD_FILES` entre comillas dobles como se muestra arriba.

# Configuración de pruebas paralelas con Elixir
<a name="sample-parallel-test-elixir"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Elixir en una plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5

phases:
  install:
    commands:
      - echo 'Installing Elixir dependencies'
      - sudo apt update
      - sudo DEBIAN_FRONTEND=noninteractive apt install -y elixir
      - elixir --version
      - mix --version
  pre_build:
    commands:
      - echo 'Prebuild'
  build:
    commands:
      - echo 'Running Elixir Tests'
      - |
        codebuild-tests-run \
         --test-command 'mix test' \
         --files-search "codebuild-glob-search '**/test/**/*_test.exs'" \ 
         --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```

# Configuración de pruebas paralelas con Go
<a name="sample-parallel-test-go"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Go en una plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Fetching Go version'
      - go version
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running go Tests'
      - go mod init calculator
      - cd calc
      - |
        codebuild-tests-run \
         --test-command "go test -v calculator.go" \
         --files-search "codebuild-glob-search '**/*test.go'"
  post_build:
    commands:
      - echo "Test execution completed"
```

En el ejemplo anterior, la función `calculator.go` contiene funciones matemáticas simples para probar todos los archivos de prueba y el archivo `calculator.go` está en una carpeta `calc`.

# Configuración de pruebas paralelas con Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Java en una plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false 
  build-fanout:
    parallelism: 5
    ignore-failure: false
    
phases:
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo "Running mvn test"
      - |
        codebuild-tests-run \
          --test-command 'mvn test -Dtest=$(echo "$CODEBUILD_CURRENT_SHARD_FILES" | sed "s|src/test/java/||g; s/\.java//g; s|/|.|g; s/ /,/g" | tr "\n" "," | sed "s/,$//")' \
          --files-search "codebuild-glob-search '**/test/**/*.java'"
         
  post_build:
    commands:
      - echo "Running post-build steps..."
      - echo "Test execution completed"
```

En el ejemplo dado, la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES` contiene archivos de prueba en la partición actual, separados por líneas. Estos archivos se convierten en una lista de nombres de clases separados por comas en el formato aceptado por el parámetro `-Dtest` para Maven.

# Configuración de pruebas paralelas con Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Javascript en una plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: true
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Node.js dependencies'
      - apt-get update
      - apt-get install -y nodejs
      - npm install
      - npm install --save-dev jest-junit
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running JavaScript Tests'
      - |
         codebuild-tests-run \
          --test-command "npx jest" \
          --files-search "codebuild-glob-search '**/test/**/*.test.js'" \
          --sharding-strategy 'stability'
    post_build:
      commands:
        - echo 'Test execution completed'
```

# Configuración de pruebas paralelas con Kotlin
<a name="sample-parallel-test-kotlin"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Kotlin en una plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 2
    ignore-failure: false

phases:
  install:
    runtime-versions:
      java: corretto11 
    commands:
      - echo 'Installing dependencies'
      - KOTLIN_VERSION="1.8.20" # Replace with your desired version
      - curl -o kotlin-compiler.zip -L "https://github.com/JetBrains/kotlin/releases/download/v${KOTLIN_VERSION}/kotlin-compiler-${KOTLIN_VERSION}.zip"
      - unzip kotlin-compiler.zip -d /usr/local
      - export PATH=$PATH:/usr/local/kotlinc/bin
      - kotlin -version
      - curl -O https://repo1.maven.org/maven2/org/junit/platform/junit-platform-console-standalone/1.8.2/junit-platform-console-standalone-1.8.2.jar
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running Kotlin Tests'
      - |
        codebuild-tests-run \
          --test-command 'kotlinc src/main/kotlin/*.kt $(echo "$CODEBUILD_CURRENT_SHARD_FILES" | tr "\n" " ") -d classes -cp junit-platform-console-standalone-1.8.2.jar' \
          --files-search "codebuild-glob-search 'src/test/kotlin/*.kt'"
      - |
        codebuild-tests-run \
          --test-command '
            java -jar junit-platform-console-standalone-1.8.2.jar --class-path classes \
              $(for file in $CODEBUILD_CURRENT_SHARD_FILES; do
                 class_name=$(basename "$file" .kt)
                 echo "--select-class $class_name"
               done)
          ' \
          --files-search "codebuild-glob-search 'src/test/kotlin/*.kt'"
  post_build:
    commands:
      - echo "Test execution completed"
```

En el ejemplo anterior, la `codebuild-tests-run` CLI se usa dos veces. Durante la primera ejecución, kotlinc compila los archivos. La variable `CODEBUILD_CURRENT_SHARD_FILES` recupera los archivos de prueba asignados a la partición actual, que luego se convierten en una lista separada por espacios. En la segunda ejecución, JUnit ejecuta las pruebas. Una vez más, `CODEBUILD_CURRENT_SHARD_FILES` recupera los archivos de prueba asignados a la partición actual, pero esta vez se convierten en nombres de clases.

# Configuración de pruebas paralelas con PHPUnit
<a name="sample-parallel-test-phpunit"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con PHPUnit en una plataforma Linux:

```
version: 0.2
 
batch:
   fast-fail: false
   build-fanout:
     parallelism: 5
     ignore-failure: false
 
phases:
   install:
     commands:
       - echo 'Install dependencies'
       - composer require --dev phpunit/phpunit
   pre_build:
     commands:
       - echo 'prebuild'
   build:
     commands:
       - echo 'Running phpunit Tests'
       - composer dump-autoload
       - | 
         codebuild-tests-run \
          --test-command "./vendor/bin/phpunit --debug" \ 
          --files-search "codebuild-glob-search '**/tests/*Test.php'"
   post_build:
       commands:
         - echo 'Test execution completed'
```

# Configuración de pruebas paralelas con Pytest
<a name="sample-parallel-test-python"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Pytest en una plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - apt-get update
      - apt-get install -y python3 python3-pip
      - pip3 install --upgrade pip
      - pip3 install pytest
  build:
    commands:
      - echo 'Running Python Tests'
      - |
         codebuild-tests-run \
          --test-command 'python -m pytest' \
          --files-search "codebuild-glob-search 'tests/test_*.py'" \
          --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Pytest en una plataforma Windows:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Python dependencies'
      - pip install pytest
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running pytest'
      - |
        & codebuild-tests-run `
         --test-command 'pytest @("$env:CODEBUILD_CURRENT_SHARD_FILES" -split \"`r?`n\")'  `
         --files-search "codebuild-glob-search '**/test_*.py' '**/*_test.py'" `
         --sharding-strategy 'equal-distribution' 
  post_build:
    commands:
      - echo "Test execution completed"
```

En el ejemplo anterior, la variable de entorno `CODEBUILD_CURRENT_SHARD_FILES` se utiliza para recuperar los archivos de prueba asignados a la partición actual y pasarlos como matriz al comando pytest.

# Configuración de pruebas paralelas con Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con Cucumber en una plataforma Linux:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Ruby dependencies'
      - gem install bundler
      - bundle install
  pre_build:
    commands:
      - echo 'prebuild'
  build:
    commands:
      - echo 'Running Cucumber Tests'
      - cucumber --init
      - |
        codebuild-tests-run \
         --test-command "cucumber" \
         --files-search "codebuild-glob-search '**/*.feature'"
  post_build:
    commands:
      - echo "Test execution completed"
```

# Configuración de pruebas paralelas con Ruby (Cucumber)
<a name="sample-parallel-test-ruby"></a>

A continuación se ofrece un ejemplo de `buildspec.yml` que muestra la ejecución de pruebas paralelas con RSpec en una plataforma Ubuntu:

```
version: 0.2

batch:
  fast-fail: false
  build-fanout:
    parallelism: 5
    ignore-failure: false

phases:
  install:
    commands:
      - echo 'Installing Ruby dependencies'
      - apt-get update
      - apt-get install -y ruby ruby-dev build-essential
      - gem install bundler
      - bundle install
  build:
    commands:
      - echo 'Running Ruby Tests'
      - |
         codebuild-tests-run \
          --test-command 'bundle exec rspec' \
          --files-search "codebuild-glob-search 'spec/**/*_spec.rb'" \
          --sharding-strategy 'equal-distribution'
  post_build:
    commands:
      - echo "Test execution completed"
```

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

# Depurar compilaciones AWS CodeBuild
<a name="debug-builds"></a>

AWS CodeBuild proporciona dos métodos para depurar las compilaciones durante el desarrollo y la solución de problemas. Puede usar el entorno CodeBuild Sandbox para investigar problemas y validar las correcciones en tiempo real, o puede usar el administrador de sesiones de AWS Systems Manager para conectarse al contenedor de compilación y ver su estado.

## Depure compilaciones con sandbox CodeBuild
<a name="debug-codebuild-sandbox"></a>

El entorno CodeBuild sandbox proporciona una sesión de depuración interactiva en un entorno seguro y aislado. Puede interactuar con el entorno directamente a través del Consola de administración de AWS o AWS CLI, ejecutar comandos y validar el proceso de compilación paso a paso. Utiliza un modelo de facturación por segundo rentable y admite la misma integración nativa con los proveedores y AWS servicios de origen que su entorno de compilación. También puedes conectarte a un entorno aislado mediante clientes SSH o desde tus entornos de desarrollo integrados (). IDEs

[Para obtener más información sobre los precios de CodeBuild sandbox, consulta la CodeBuild documentación de precios.](https://aws.amazon.com/codebuild/pricing/#Sandbox) Para obtener instrucciones detalladas, consulte la documentación de [Depurar compilaciones con sandbox CodeBuild](sandbox.md).

## Depuración de compilaciones con Administrador de sesiones
<a name="debug-codebuild-session-manager"></a>

AWS El administrador de sesiones de Systems Manager permite el acceso directo a las compilaciones en ejecución en su entorno de ejecución real. Este método le permite conectarse a contenedores de compilación activos e inspeccionar el proceso de compilación en tiempo real. Puede examinar el sistema de archivos, supervisar los procesos en ejecución y solucionar problemas a medida que se produzcan.

Para obtener instrucciones detalladas, consulte la documentación de [Depuración de compilaciones con Administrador de sesiones](session-manager.md).

# Depurar compilaciones con sandbox CodeBuild
<a name="sandbox"></a>

En AWS CodeBuild, puedes depurar una compilación mediante CodeBuild sandbox para ejecutar comandos personalizados y solucionar los problemas de la compilación.

**Topics**
+ [Requisitos previos](#sandbox-prereq)
+ [Depure compilaciones con CodeBuild sandbox (consola)](#sandbox-console)
+ [Depura compilaciones con sandbox () CodeBuild AWS CLI](#sandbox-cli)
+ [Tutorial: Conexión a un entorno de pruebas mediante SSH](sandbox-ssh-tutorial.md)
+ [Solución de problemas AWS CodeBuild de conexión SSH en entornos aislados](sandbox-troubleshooting.md)

## Requisitos previos
<a name="sandbox-prereq"></a>

Antes de usar un CodeBuild entorno aislado, asegúrate de que tu rol de CodeBuild servicio tenga la siguiente política de SSM:

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ssmmessages:CreateControlChannel",
                "ssmmessages:CreateDataChannel",
                "ssmmessages:OpenControlChannel",
                "ssmmessages:OpenDataChannel"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ssm:StartSession"
            ],
            "Resource": [
                "arn:aws:codebuild:us-east-1:111122223333:build/*",
                "arn:aws:ssm:us-east-1::document/AWS-StartSSHSession"
            ]
        }
    ]
}
```

------

## Depure compilaciones con CodeBuild sandbox (consola)
<a name="sandbox-console"></a>

Usa las siguientes instrucciones para ejecutar comandos y conectar tu cliente SSH con el CodeBuild sandbox de la consola.

### Ejecuta comandos con CodeBuild sandbox (consola)
<a name="sandbox-console.commands"></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. En el panel de navegación, elija **Proyectos de compilación**. Elija el proyecto de compilación y, a continuación, elija **Iniciar depuración**.  
![\[Página de detalles de depuración del proyecto de compilación en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/sandbox-debug-build.png)

1. En la pestaña **Ejecutar comando**, introduzca comandos personalizados y, a continuación, elija **Ejecutar comando**.  
![\[Página de detalles de ejecución de comandos en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/debug-build-run.png)

1. Luego, tu CodeBuild sandbox se inicializará y empezará a ejecutar tus comandos personalizados. El resultado se mostrará en la pestaña **Salida** cuando se haya completado.   
![\[Página de salida de ejecución de comandos en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/debug-build-run-output.png)

1. Cuando se haya completado la solución de problemas, puede detener el entorno de pruebas seleccionando **Detener entorno de pruebas**. A continuación, seleccione **Detener** para confirmar que el entorno de pruebas se detendrá.  
![\[Cuadro de diálogo de detención del entorno de pruebas.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/stop-sandbox.png)  
![\[Página de salida de ejecución de comandos con un entorno de pruebas detenido en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/stopped-sandbox.png)

### Conéctate a tu cliente SSH con CodeBuild sandbox (consola)
<a name="sandbox-console.ssh"></a>

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

1. En el panel de navegación, elija **Proyectos de compilación**. Elija el proyecto de compilación y, a continuación, elija **Iniciar depuración**.  
![\[Página de detalles de depuración del proyecto de compilación en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/sandbox-debug-build.png)

1. En la pestaña **Cliente de SSH**, seleccione **Iniciar entorno de pruebas**.  
![\[Página del entorno de pruebas del cliente de SSH en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/ssh-client-sandbox.png)

1. Cuando el CodeBuild sandbox comience a funcionar, sigue las instrucciones de la consola para conectar tu cliente SSH al sandbox.  
![\[Página del entorno de pruebas del cliente de SSH en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/ssh-client-sandbox-terminal.png)

1. Cuando se haya completado la solución de problemas, puede detener el entorno de pruebas seleccionando **Detener entorno de pruebas**. A continuación, seleccione **Detener** para confirmar que el entorno de pruebas se detendrá.  
![\[Cuadro de diálogo de detención del entorno de pruebas.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/stop-sandbox-2.png)  
![\[Página de salida de ejecución de comandos con un entorno de pruebas detenido en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/stopped-sandbox-2.png)

## Depura compilaciones con sandbox () CodeBuild AWS CLI
<a name="sandbox-cli"></a>

Usa las siguientes instrucciones para ejecutar comandos y conectar tu cliente SSH con sandbox. CodeBuild 

### Inicia un CodeBuild sandbox ()AWS CLI
<a name="sandbox-cli.start-sandbox"></a>

------
#### [ CLI command ]

```
aws codebuild start-sandbox --project-name $PROJECT_NAME
```
+ `--project-name`: nombre CodeBuild del proyecto

------
#### [ Sample request ]

```
aws codebuild start-sandbox --project-name "project-name"
```

------
#### [ Sample response ]

```
{
    "id": "project-name",
    "arn": "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name",
    "projectName": "project-name",
    "requestTime": "2025-02-06T11:24:15.560000-08:00",
    "status": "QUEUED",
    "source": {
        "type": "S3",
        "location": "arn:aws:s3:::cofa-e2e-test-1-us-west-2-beta-default-build-sources/eb-sample-jetty-v4.zip",
        "insecureSsl": false
    },
    "environment": {
        "type": "LINUX_CONTAINER",
        "image": "aws/codebuild/standard:6.0",
        "computeType": "BUILD_GENERAL1_SMALL",
        "environmentVariables": [{
                "name": "foo",
                "value": "bar",
                "type": "PLAINTEXT"
            },
            {
                "name": "bar",
                "value": "baz",
                "type": "PLAINTEXT"
            }
        ],
        "privilegedMode": false,
        "imagePullCredentialsType": "CODEBUILD"
    },
    "timeoutInMinutes": 10,
    "queuedTimeoutInMinutes": 480,
    "logConfig": {
        "cloudWatchLogs": {
            "status": "ENABLED",
            "groupName": "group",
            "streamName": "stream"
        },
        "s3Logs": {
            "status": "ENABLED",
            "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
            "encryptionDisabled": false
        }
    },
    "encryptionKey": "arn:aws:kms:us-west-2:962803963624:alias/SampleEncryptionKey",
    "serviceRole": "arn:aws:iam::962803963624:role/BuildExecutionServiceRole",
    "currentSession": {
        "id": "0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
        "currentPhase": "QUEUED",
        "status": "QUEUED",
        "startTime": "2025-02-06T11:24:15.626000-08:00",
        "logs": {
            "groupName": "group",
            "streamName": "stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream$252F0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz?region=us-west-2",
            "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz",
            "cloudWatchLogs": {
                "status": "ENABLED",
                "groupName": "group",
                "streamName": "stream"
            },
            "s3Logs": {
                "status": "ENABLED",
                "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                "encryptionDisabled": false
            }
        }
    }
}
```

------

### Obtención de información sobre el estado del entorno de pruebas (AWS CLI)
<a name="sandbox-cli.batch-get-sandboxes"></a>

------
#### [ CLI command ]

```
aws codebuild batch-get-sandboxes --ids $SANDBOX_IDs
```

------
#### [ Sample request ]

```
aws codebuild stop-sandbox --id "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name"
```
+ `--ids`: lista separada por comas de `sandboxIds` o `sandboxArns`.

Puede proporcionar un ID de entorno de pruebas o un ARN de entorno de pruebas:
+ ID de entorno de pruebas: `<codebuild-project-name>:<UUID>`

  Por ejemplo, `project-name:d25be134-05cb-404a-85da-ac5f85d2d72c`.
+ ARN de sandbox: arn:aws:codebuild: ::sandbox/*<region>*: *<account-id>* *<codebuild-project-name>* *<UUID>*

  Por ejemplo, `arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name:d25be134-05cb-404a-85da-ac5f85d2d72c`.

------
#### [ Sample response ]

```
{
    "sandboxes": [{
        "id": "project-name",
        "arn": "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name",
        "projectName": "project-name",
        "requestTime": "2025-02-06T11:24:15.560000-08:00",
        "endTime": "2025-02-06T11:39:21.587000-08:00",
        "status": "STOPPED",
        "source": {
            "type": "S3",
            "location": "arn:aws:s3:::cofa-e2e-test-1-us-west-2-beta-default-build-sources/eb-sample-jetty-v4.zip",
            "insecureSsl": false
        },
        "environment": {
            "type": "LINUX_CONTAINER",
            "image": "aws/codebuild/standard:6.0",
            "computeType": "BUILD_GENERAL1_SMALL",
            "environmentVariables": [{
                    "name": "foo",
                    "value": "bar",
                    "type": "PLAINTEXT"
                },
                {
                    "name": "bar",
                    "value": "baz",
                    "type": "PLAINTEXT"
                }
            ],
            "privilegedMode": false,
            "imagePullCredentialsType": "CODEBUILD"
        },
        "timeoutInMinutes": 10,
        "queuedTimeoutInMinutes": 480,
        "logConfig": {
            "cloudWatchLogs": {
                "status": "ENABLED",
                "groupName": "group",
                "streamName": "stream"
            },
            "s3Logs": {
                "status": "ENABLED",
                "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                "encryptionDisabled": false
            }
        },
        "encryptionKey": "arn:aws:kms:us-west-2:962803963624:alias/SampleEncryptionKey",
        "serviceRole": "arn:aws:iam::962803963624:role/BuildExecutionServiceRole",
        "currentSession": {
            "id": "0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "currentPhase": "COMPLETED",
            "status": "STOPPED",
            "startTime": "2025-02-06T11:24:15.626000-08:00",
            "endTime": "2025-02-06T11:39:21.600000-08:00",
            "phases": [{
                    "phaseType": "SUBMITTED",
                    "phaseStatus": "SUCCEEDED",
                    "startTime": "2025-02-06T11:24:15.577000-08:00",
                    "endTime": "2025-02-06T11:24:15.606000-08:00",
                    "durationInSeconds": 0
                },
                {
                    "phaseType": "QUEUED",
                    "phaseStatus": "SUCCEEDED",
                    "startTime": "2025-02-06T11:24:15.606000-08:00",
                    "endTime": "2025-02-06T11:24:16.067000-08:00",
                    "durationInSeconds": 0
                },
                {
                    "phaseType": "PROVISIONING",
                    "phaseStatus": "SUCCEEDED",
                    "startTime": "2025-02-06T11:24:16.067000-08:00",
                    "endTime": "2025-02-06T11:24:20.519000-08:00",
                    "durationInSeconds": 4,
                    "contexts": [{
                        "statusCode": "",
                        "message": ""
                    }]
                },
                {
                    "phaseType": "DOWNLOAD_SOURCE",
                    "phaseStatus": "SUCCEEDED",
                    "startTime": "2025-02-06T11:24:20.519000-08:00",
                    "endTime": "2025-02-06T11:24:22.238000-08:00",
                    "durationInSeconds": 1,
                    "contexts": [{
                        "statusCode": "",
                        "message": ""
                    }]
                },
                {
                    "phaseType": "RUNNING_SANDBOX",
                    "phaseStatus": "TIMED_OUT",
                    "startTime": "2025-02-06T11:24:22.238000-08:00",
                    "endTime": "2025-02-06T11:39:21.560000-08:00",
                    "durationInSeconds": 899,
                    "contexts": [{
                        "statusCode": "BUILD_TIMED_OUT",
                        "message": "Build has timed out. "
                    }]
                },
                {
                    "phaseType": "COMPLETED",
                    "startTime": "2025-02-06T11:39:21.560000-08:00"
                }
            ],
            "logs": {
                "groupName": "group",
                "streamName": "stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
                "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream$252F0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
                "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz?region=us-west-2",
                "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
                "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz",
                "cloudWatchLogs": {
                    "status": "ENABLED",
                    "groupName": "group",
                    "streamName": "stream"
                },
                "s3Logs": {
                    "status": "ENABLED",
                    "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                    "encryptionDisabled": false
                }
            }
        }
    }],
    "sandboxesNotFound": []
}
```

------

### Detención de un entorno de pruebas (AWS CLI)
<a name="sandbox-cli.stop-sandbox"></a>

------
#### [ CLI command ]

```
aws codebuild stop-sandbox --id $SANDBOX-ID
```
+ `--id`: `sandboxId` o `sandboxArn`.

------
#### [ Sample request ]

```
aws codebuild stop-sandbox --id "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name"
```

------
#### [ Sample response ]

```
{
    "id": "project-name",
    "arn": "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name",
    "projectName": "project-name",
    "requestTime": "2025-02-06T11:24:15.560000-08:00",
    "status": "STOPPING",
    "source": {
        "type": "S3",
        "location": "arn:aws:s3:::cofa-e2e-test-1-us-west-2-beta-default-build-sources/eb-sample-jetty-v4.zip",
        "insecureSsl": false
    },
    "environment": {
        "type": "LINUX_CONTAINER",
        "image": "aws/codebuild/standard:6.0",
        "computeType": "BUILD_GENERAL1_SMALL",
        "environmentVariables": [{
                "name": "foo",
                "value": "bar",
                "type": "PLAINTEXT"
            },
            {
                "name": "bar",
                "value": "baz",
                "type": "PLAINTEXT"
            }
        ],
        "privilegedMode": false,
        "imagePullCredentialsType": "CODEBUILD"
    },
    "timeoutInMinutes": 10,
    "queuedTimeoutInMinutes": 480,
    "logConfig": {
        "cloudWatchLogs": {
            "status": "ENABLED",
            "groupName": "group",
            "streamName": "stream"
        },
        "s3Logs": {
            "status": "ENABLED",
            "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
            "encryptionDisabled": false
        }
    },
    "encryptionKey": "arn:aws:kms:us-west-2:962803963624:alias/SampleEncryptionKey",
    "serviceRole": "arn:aws:iam::962803963624:role/BuildExecutionServiceRole",
    "currentSession": {
        "id": "0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
        "currentPhase": "RUN_SANDBOX",
        "status": "STOPPING",
        "startTime": "2025-02-06T11:24:15.626000-08:00",
        "phases": [{
                "phaseType": "SUBMITTED",
                "phaseStatus": "SUCCEEDED",
                "startTime": "2025-02-08T14:33:26.144000-08:00",
                "endTime": "2025-02-08T14:33:26.173000-08:00",
                "durationInSeconds": 0
            },
            {
                "phaseType": "QUEUED",
                "phaseStatus": "SUCCEEDED",
                "startTime": "2025-02-08T14:33:26.173000-08:00",
                "endTime": "2025-02-08T14:33:26.702000-08:00",
                "durationInSeconds": 0
            },
            {
                "phaseType": "PROVISIONING",
                "phaseStatus": "SUCCEEDED",
                "startTime": "2025-02-08T14:33:26.702000-08:00",
                "endTime": "2025-02-08T14:33:30.530000-08:00",
                "durationInSeconds": 3,
                "contexts": [{
                    "statusCode": "",
                    "message": ""
                }]
            },
            {
                "phaseType": "DOWNLOAD_SOURCE",
                "phaseStatus": "SUCCEEDED",
                "startTime": "2025-02-08T14:33:30.530000-08:00",
                "endTime": "2025-02-08T14:33:33.478000-08:00",
                "durationInSeconds": 2,
                "contexts": [{
                    "statusCode": "",
                    "message": ""
                }]
            },
            {
                "phaseType": "RUN_SANDBOX",
                "startTime": "2025-02-08T14:33:33.478000-08:00"
            }
        ],
        "logs": {
            "groupName": "group",
            "streamName": "stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream$252F0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz?region=us-west-2",
            "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream/0103e0e7-52aa-4a3d-81dd-bfc27226fa54",
            "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/0103e0e7-52aa-4a3d-81dd-bfc27226fa54.gz",
            "cloudWatchLogs": {
                "status": "ENABLED",
                "groupName": "group",
                "streamName": "stream"
            },
            "s3Logs": {
                "status": "ENABLED",
                "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                "encryptionDisabled": false
            }
        }
    }
}
```

------

### Inicio de la ejecución de un comando (AWS CLI)
<a name="sandbox-cli.start-command-execution"></a>

------
#### [ CLI command ]

```
aws codebuild start-command-execution --command $COMMAND --type $TYPE --sandbox-id $SANDBOX-ID
```
+ `--command`: comando que debe ejecutarse.
+ `--sandbox-id`: `sandboxId` o `sandboxArn`.
+ `--type`: tipo de comando, `SHELL`.

------
#### [ Sample request ]

```
aws codebuild start-command-execution --command "echo "Hello World"" --type SHELL --sandbox-id "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name
```

------
#### [ Sample response ]

```
{
    "id": "e1c658c2-02bb-42a8-9abb-94835241fcd6",
    "sandboxId": "f7126a4a-b0d5-452f-814c-fea73718f805",
    "submitTime": "2025-02-06T20:12:02.683000-08:00",
    "status": "SUBMITTED",
    "command": "echo \"Hello World\"",
    "type": "SHELL",
    "logs": {
        "groupName": "group",
        "streamName": "stream",
        "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream",
        "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/f7126a4a-b0d5-452f-814c-fea73718f805.gz?region=us-west-2",
        "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream",
        "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/f7126a4a-b0d5-452f-814c-fea73718f805.gz",
        "cloudWatchLogs": {
            "status": "ENABLED",
            "groupName": "group",
            "streamName": "stream"
        },
        "s3Logs": {
            "status": "ENABLED",
            "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
            "encryptionDisabled": false
        }
    }
}
```

------

### Obtención de información sobre las ejecuciones de comandos (AWS CLI)
<a name="sandbox-cli.batch-get-command-executions"></a>

------
#### [ CLI command ]

```
aws codebuild batch-get-command-executions --command-execution-ids $COMMAND-IDs --sandbox-id $SANDBOX-IDs
```
+ `--command-execution-ids`: lista separada por comas de `commandExecutionIds`.
+ `--sandbox-id`: `sandboxId` o `sandboxArn`.

------
#### [ Sample request ]

```
aws codebuild batch-get-command-executions --command-execution-ids"c3c085ed-5a8f-4531-8e95-87d547f27ffd" --sandbox-id "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name"
```

------
#### [ Sample response ]

```
{
    "commandExecutions": [{
        "id": "c3c085ed-5a8f-4531-8e95-87d547f27ffd",
        "sandboxId": "cd71e456-2a4c-4db4-ada5-da892b0bba05",
        "submitTime": "2025-02-10T20:18:17.118000-08:00",
        "startTime": "2025-02-10T20:18:17.939000-08:00",
        "endTime": "2025-02-10T20:18:17.976000-08:00",
        "status": "SUCCEEDED",
        "command": "echo \"Hello World\"",
        "type": "SHELL",
        "exitCode": "0",
        "standardOutputContent": "Hello World\n",
        "logs": {
            "groupName": "group",
            "streamName": "stream",
            "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream",
            "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz?region=us-west-2",
            "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream",
            "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz",
            "cloudWatchLogs": {
                "status": "ENABLED",
                "groupName": "group",
                "streamName": "stream"
            },
            "s3Logs": {
                "status": "ENABLED",
                "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                "encryptionDisabled": false
            }
        }
    }],
    "commandExecutionsNotFound": []
}
```

------

### Lista de ejecuciones de comandos para un entorno de pruebas (AWS CLI)
<a name="sandbox-cli.list-command-executions-for-sandbox"></a>

------
#### [ CLI command ]

```
aws codebuild list-command-executions-for-sandbox --sandbox-id $SANDBOX-ID --next-token $NEXT_TOKEN --max-results $MAX_RESULTS --sort-order $SORT_ORDER
```
+ `--next-token`: siguiente token, si lo hay, para obtener resultados paginados. Obtendrá este valor de la ejecución anterior de entornos de pruebas de la lista.
+ `--max-results`: (opcional) número máximo de registros del entorno de pruebas que se recuperará.
+ `--sort-order`: orden en el que se deben recuperar los registros del entorno de pruebas.

------
#### [ Sample request ]

```
aws codebuild list-command-executions-for-sandbox --sandbox-id "arn:aws:codebuild:us-west-2:962803963624:sandbox/project-name"
```

------
#### [ Sample response ]

```
{
    "commandExecutions": [{
            "id": "aad6687e-07bc-45ab-a1fd-f5440229b528",
            "sandboxId": "cd71e456-2a4c-4db4-ada5-da892b0bba05",
            "submitTime": "2025-02-10T20:18:35.304000-08:00",
            "startTime": "2025-02-10T20:18:35.615000-08:00",
            "endTime": "2025-02-10T20:18:35.651000-08:00",
            "status": "FAILED",
            "command": "fail command",
            "type": "SHELL",
            "exitCode": "127",
            "standardErrContent": "/codebuild/output/tmp/script.sh: 4: fail: not found\n",
            "logs": {
                "groupName": "group",
                "streamName": "stream",
                "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream",
                "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz?region=us-west-2",
                "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream",
                "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz",
                "cloudWatchLogs": {
                    "status": "ENABLED",
                    "groupName": "group",
                    "streamName": "stream"
                },
                "s3Logs": {
                    "status": "ENABLED",
                    "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                    "encryptionDisabled": false
                }
            }
        },
        {
            "id": "c3c085ed-5a8f-4531-8e95-87d547f27ffd",
            "sandboxId": "cd71e456-2a4c-4db4-ada5-da892b0bba05",
            "submitTime": "2025-02-10T20:18:17.118000-08:00",
            "startTime": "2025-02-10T20:18:17.939000-08:00",
            "endTime": "2025-02-10T20:18:17.976000-08:00",
            "status": "SUCCEEDED",
            "command": "echo \"Hello World\"",
            "type": "SHELL",
            "exitCode": "0",
            "standardOutputContent": "Hello World\n",
            "logs": {
                "groupName": "group",
                "streamName": "stream",
                "deepLink": "https://console.aws.amazon.com/cloudwatch/home?region=us-west-2#logsV2:log-groups/log-group/group/log-events/stream",
                "s3DeepLink": "https://s3.console.aws.amazon.com/s3/object/codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz?region=us-west-2",
                "cloudWatchLogsArn": "arn:aws:logs:us-west-2:962803963624:log-group:group:log-stream:stream",
                "s3LogsArn": "arn:aws:s3:::codefactory-test-pool-1-us-west-2-beta-default-build-logs/cd71e456-2a4c-4db4-ada5-da892b0bba05.gz",
                "cloudWatchLogs": {
                    "status": "ENABLED",
                    "groupName": "group",
                    "streamName": "stream"
                },
                "s3Logs": {
                    "status": "ENABLED",
                    "location": "codefactory-test-pool-1-us-west-2-beta-default-build-logs",
                    "encryptionDisabled": false
                }
            }
        }
    ]
}
```

------

### Lista de entornos de pruebas (AWS CLI)
<a name="sandbox-cli.list-sandboxes"></a>

------
#### [ CLI command ]

```
aws codebuild list-sandboxes --next-token $NEXT_TOKEN --max-results $MAX_RESULTS --sort-order $SORT_ORDER
```

------
#### [ Sample request ]

```
aws codebuild list-sandboxes
```

------
#### [ Sample response ]

```
{
    "ids": [
        "s3-log-project-integ-test-temp173925062814985d64e0f-7880-41df-9a3c-fb6597a266d2:827a5243-0841-4b69-a720-4438796f6967",
        "s3-log-project-integ-test-temp1739249999716bbd438dd-8bb8-47bd-ba6b-0133ac65b3d3:e2fa4eab-73af-42e3-8903-92fddaf9f378",
        "s3-log-project-integ-test-temp17392474779450fbdacc2-2d6e-4190-9ad5-28f891bb7415:cd71e456-2a4c-4db4-ada5-da892b0bba05",
        "s3-log-project-integ-test-temp17392246284164301421c-5030-4fa1-b4d3-ca15e44771c5:9e26ab3f-65e4-4896-a19c-56b1a95e630a",
        "s3-log-project-integ-test-temp173921367319497056d8d-6d8e-4f5a-a37c-a62f5686731f:22d91b06-df1e-4e9c-a664-c0abb8d5920b",
        "s3-log-project-integ-test-temp1739213439503f6283f19-390c-4dc8-95a9-c8480113384a:82cc413e-fc46-47ab-898f-ae23c83a613f",
        "s3-log-project-integ-test-temp1739054385570b1f1ddc2-0a23-4062-bd0c-24e9e4a99b99:c02562f3-2396-42ec-98da-38e3fe5da13a",
        "s3-log-project-integ-test-temp173905400540237dab1ac-1fde-4dfb-a8f5-c0114333dc89:d2f30493-f65e-4fa0-a7b6-08a5e77497b9",
        "s3-log-project-integ-test-temp17390534055719c534090-7bc4-48f1-92c5-34acaec5bf1e:df5f1c8a-f017-43b7-91ba-ad2619e2c059",
        "s3-log-project-integ-test-temp1739052719086a61813cc-ebb9-4db4-9391-7f43cc984ee4:d61917ec-8037-4647-8d52-060349272c4a",
        "s3-log-project-integ-test-temp173898670094078b67edb-c42f-42ed-9db2-4b5c1a5fc66a:ce33dfbc-beeb-4466-8c99-a3734a0392c7",
        "s3-log-project-integ-test-temp17389863425584d21b7cd-32e2-4f11-9175-72c89ecaffef:046dadf0-1f3a-4d51-a2c0-e88361924acf",
        "s3-log-project-integ-test-temp1738985884273977ccd23-394b-46cc-90d3-7ab94cf764dc:0370dc41-9339-4b0a-91ed-51929761b244",
        "s3-log-project-integ-test-temp1738985365972241b614f-8e41-4387-bd25-2b8351fbc9e0:076c392a-9630-47d8-85a9-116aa34edfff",
        "s3-log-project-integ-test-temp1738985043988a51a9e2b-09d6-4d24-9c3c-1e6e21ac9fa8:6ea3949c-435b-4177-aa4d-614d5956244c",
        "s3-log-project-integ-test-temp1738984123354c68b31ad-49d1-4f4b-981d-b66c00565ff6:6c3fff6c-815b-48b5-ada3-737400a6dee8",
        "s3-log-project-integ-test-temp1738977263715d4d5bf6c-370a-48bf-8ea6-905358a6cf92:968a0f54-724a-42d1-9207-6ed854b2fae8",
        "s3-log-project-integ-test-temp173897358796816ce8d7d-2a5e-41ef-855b-4a94a8d2795d:80f9a7ce-930a-402e-934e-d8b511d68b04",
        "s3-log-project-integ-test-temp17389730633301af5e452-0966-467c-b684-4e36d47f568c:cabbe989-2e8a-473c-af25-32edc8c28646",
        "s3-log-project-integ-test-temp1738901503813173fd468-b723-4d7b-9f9f-82e88d17f264:f7126a4a-b0d5-452f-814c-fea73718f805",
        "s3-log-project-integ-test-temp1738890502472c13616fb-bd0f-4253-86cc-28b74c97a0ba:c6f197e5-3a53-45b6-863e-0e6353375437",
        "s3-log-project-integ-test-temp17388903044683610daf3-8da7-43c6-8580-9978432432ce:d20aa317-8838-4966-bbfc-85b908213df1",
        "s3-log-project-integ-test-temp173888857196780b5ab8b-e54b-44fd-a222-c5a374fffe96:ab4b9970-ffae-47a0-b3a8-7b6790008cad",
        "s3-log-project-integ-test-temp1738888336931c11d378d-e74d-49a4-a723-3b92e6f7daac:4922f0e8-9b7d-4119-9c9f-115cd85e703e",
        "s3-log-project-integ-test-temp17388881717651612a397-c23f-4d88-ba87-2773cd3fc0c9:be91c3fc-418e-4feb-8a3a-ba58ff8f4e8a",
        "s3-log-project-integ-test-temp17388879727174c3c62ed-6195-4afb-8a03-59674d0e1187:a48826a8-3c0d-43c5-a1b5-1c98a0f978e9",
        "s3-log-project-integ-test-temp1738885948597cef305e4-b8b4-46b0-a65b-e2d0a7b83294:c050e77d-e3f8-4829-9a60-46149628fe96",
        "s3-log-project-integ-test-temp173888561463001a7d2a8-e4e4-4434-94db-09d3da9a9e17:8c3ac3f5-7111-4297-aec9-2470d3ead873",
        "s3-log-project-integ-test-temp1738869855076eb19cafd-04fe-41bd-8aa0-40826d0c0d27:d25be134-05cb-404a-85da-ac5f85d2d72c",
        "s3-project-integ-test-temp1738868157467148eacfc-d39b-49fc-a137-e55381cd2978:4909557b-c221-4814-b4b6-7d9e93d37c35",
        "s3-project-integ-test-temp1738820926895abec0af2-e33d-473c-9cf4-2122dd9d6876:8f5cf218-71d6-40a4-a4be-6cacebd7765f",
        "s3-project-integ-test-temp173881998877574f969a6-1c2e-4441-b463-ab175b45ce32:04396851-c901-4986-9117-585528e3877f",
        "s3-project-integ-test-temp17388189812309abd2604-29ba-4cf6-b6bf-073207b7db9c:540075c7-f5ec-41e8-9341-2233c09247eb",
        "s3-project-integ-test-temp1738818843474d3ea9ac1-b609-461b-bbdb-2da245c9bc96:865d4c3c-fbfe-4ece-9c92-d0c928341404",
        "s3-project-integ-test-temp1738818542236006e9169-e6d9-4344-9b59-f557e7aec619:1f9ffa87-da15-4290-83e2-eebdd877497b",
        "s3-project-integ-test-temp173881809557486ad11fd-7931-48d7-81d5-499cea52a6bc:c4c2efc4-685f-4e13-8b0f-1ef85ec300b1",
        "s3-project-integ-test-temp173881794103322941020-3f0b-49c3-b836-fcd818ec9484:0344cfba-de48-456d-b2a8-6566bd4a5d6e",
        "s3-project-integ-test-temp1738817680747b93d0d0b-ea16-497f-9559-af25ee6dcfdf:654a3a55-d92a-4dc6-8da8-56fd4d40d7e1",
        "s3-project-integ-test-temp17388174027191255c3da-086c-4270-b047-acac0b7bee0d:b7e82740-2c69-42fc-ab5a-dbf15bc016a1",
        "s3-project-integ-test-temp1738817099799016e7fa3-b9b5-46a2-bcd5-0888c646743f:8705a6a4-79ff-427a-a1c3-85c4e8fe462e",
        "s3-project-integ-test-temp1738816479281bb0c3606-5ebf-4623-bed5-12b60e9d3512:f23fc74b-a981-4835-8e28-375fcd4c99e4",
        "s3-project-integ-test-temp1738816263585c939a133-4d37-482c-9238-1dbff34b7674:ca28e234-0045-4ae6-8732-938b17597f50",
        "s3-project-integ-test-temp173881580873072d18733-8fe4-43b1-83f7-95f25bb27ccf:c6f0f55b-5736-47c7-a3aa-1b8461a6d5ed"
    ]
}
```

------

# Tutorial: Conexión a un entorno de pruebas mediante SSH
<a name="sandbox-ssh-tutorial"></a>

En este tutorial, se muestra cómo conectarse a un sandbox mediante un cliente SSH. CodeBuild 

Para completar este tutorial, primero debe:
+ Asegúrese de tener un proyecto existente AWS CodeBuild .
+ Configure los permisos de IAM adecuados para su función de CodeBuild proyecto. 
+ Instale y configure AWS CLI en su máquina local.

## Paso 1: inicio de un entorno de pruebas
<a name="sandbox-ssh-tutorial.start-sandbox"></a>

**Para iniciar un CodeBuild sandbox en la consola**

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

1. En el panel de navegación, elija **Proyectos de compilación**. Elija el proyecto de compilación y, a continuación, elija **Iniciar depuración**.  
![\[Página de detalles del proyecto de compilación en la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/project-debug-build.png)

1. En la pestaña **Cliente de SSH**, seleccione **Iniciar entorno de pruebas**.  
![\[Pestaña “Cliente de SSH” en la consola con el botón “Iniciar entorno de pruebas”.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/ssh-client-sandbox.png)

1. El proceso de inicialización del entorno de pruebas puede tardar un poco. Puede conectarse al entorno de pruebas cuando su estado cambie a `RUN_SANDDBOX`.  
![\[Conexión del entorno de pruebas de SSH después de que el estado cambie a “RUN_SANDDBOX”.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/run-sandbox.png)

## Paso 2: modificación de la configuración de SSH local
<a name="sandbox-ssh-tutorial.modify-ssh"></a>

Si es la primera vez que se conecta a un entorno de pruebas, debe realizar un proceso de configuración único siguiendo estos pasos:

**Cómo modificar la configuración de SSH local en la consola**

1. Busque los comandos de configuración correspondientes a su sistema operativo.

1. Abra el terminal local y, a continuación, copie y ejecute los comandos proporcionados para descargar y ejecutar el script para configurar la configuración de SSH local. Por ejemplo, si el sistema operativo es macOS, utilice el siguiente comando:  
![\[Los comandos de macOS para la conexión SSH al CodeBuild sandbox de la consola.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/modify-ssh-macOS.png)

1. El script de configuración agregará las configuraciones necesarias para conectarse a los entornos de pruebas. Se le pedirá que acepte estos cambios.

1. Si la configuración se realiza correctamente, se creará una nueva entrada de configuración de SSH para el CodeBuild entorno aislado.  
![\[Conexión correcta del entorno de pruebas de SSH.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/ssh-terminal-success.png)

## Paso 3: conexión con el entorno de pruebas
<a name="sandbox-ssh-tutorial.connect-sandbox"></a>

**Cómo modificar la configuración de SSH local en la consola**

1. Configure AWS CLI la autenticación y asegúrese de que su AWS CLI usuario tenga el `codebuild:StartSandboxConnection` permiso. Para obtener más información, consulte [Autenticación con credenciales de usuario de IAM para la AWS CLI](https://docs.aws.amazon.com/cli/v1/userguide/cli-authentication-user.html) en la *Guía del usuario de Interfaz de línea de comandos de AWS de la versión 1*.

1. Conéctese al entorno de pruebas con el siguiente comando:

   ```
   ssh codebuild-sandbox-ssh=arn:aws:codebuild:us-east-1:<account-id>:sandbox/<sandbox-id>
   ```
**nota**  
Para solucionar problemas de conexión, use la marca `-v` para habilitar la salida detallada. Por ejemplo, `ssh -v codebuild-sandbox-ssh=arn:aws:codebuild:us-east-1:<account-id>:sandbox/<sandbox-id>`.  
Para obtener sugerencias adicionales para la solución de problemas, consulte [Solución de problemas AWS CodeBuild de conexión SSH en entornos aislados](sandbox-troubleshooting.md).

## Paso 4: Revise los resultados
<a name="sandbox-ssh-tutorial.review-results"></a>

Una vez conectado, puede depurar errores de compilación, probar comandos de compilación, experimentar con cambios de configuración y verificar variables de entorno y dependencias con el entorno de pruebas.

# Solución de problemas AWS CodeBuild de conexión SSH en entornos aislados
<a name="sandbox-troubleshooting"></a>

Usa la información de este tema para ayudarte a identificar, diagnosticar y solucionar los problemas de conexión SSH CodeBuild en entornos aislados.

**Topics**
+ [`StartSandboxConnection``InvalidInputException`error al usar SSH en un entorno sandbox CodeBuild](#sandbox-troubleshooting.invalid-input)
+ [Error: «No se encuentran las credenciales» cuando se utiliza SSH en CodeBuild un entorno sandbox](#sandbox-troubleshooting.credentials)
+ [`StartSandboxConnection``AccessDeniedException`error al usar SSH en un CodeBuild entorno sandbox](#sandbox-troubleshooting.access-denied)
+ [Error: «ssh: no se ha podido resolver el nombre de host» cuando se utiliza SSH en un entorno aislado CodeBuild](#sandbox-troubleshooting.hostname)

## `StartSandboxConnection``InvalidInputException`error al usar SSH en un entorno sandbox CodeBuild
<a name="sandbox-troubleshooting.invalid-input"></a>

**Problema:** al intentar conectarse a un entorno CodeBuild sandbox mediante el comando`ssh codebuild-sandbox-ssh=<sandbox-arn>`, es posible que se produzca un `InvalidInputException` error como el siguiente:

```
An error occurred (InvalidInputException) when calling the StartSandboxConnection 
operation: Failed to start SSM session for {sandbox-arn}
User: arn:aws:sts::<account-ID>:assumed-role/<service-role-name>/AWSCodeBuild-<UUID> 
is not authorized to perform: ssm:StartSession on resource.
```

```
An error occurred (InvalidInputException) when calling the StartSandboxConnection 
operation: Failed to start SSM session for 
sandbox <sandbox-arn>: codebuild:<UUID> is not connected.
```

**Causa posible:**
+ Falta el agente de Systems Manager de Amazon EC2: la imagen de compilación no tiene el agente de SSM instalado o configurado correctamente.
+ Permisos insuficientes: el rol de servicio CodeBuild del proyecto carece de los permisos de SSM necesarios.

**Solución recomendada:** si utiliza una imagen personalizada para la compilación, haga lo siguiente.

1. Instalar el SSM Agent de . Para obtener más información, consulte [Instalación y desinstalación manual de SSM Agent en instancias de Amazon EC2 para Linux](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-linux.html) en **. La versión de SSM Agent debe ser `3.0.1295.0` o posterior.

1. Copie el archivo [ https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/7.0/amazon-ssm-agent.json](https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/7.0/amazon-ssm-agent.json) en el directorio de la imagen. `/etc/amazon/ssm/` De este modo se habilita **Modo de contenedor** en SSM Agent.

1. Asegúrese de que el rol de servicio de su CodeBuild proyecto tenga los siguientes permisos y, a continuación, reinicie el entorno sandbox:

   ```
   {
      "Effect": "Allow",
         "Action": [
            "ssmmessages:CreateControlChannel",
            "ssmmessages:CreateDataChannel",
            "ssmmessages:OpenControlChannel",
            "ssmmessages:OpenDataChannel"
         ],
         "Resource": "*"
    },
    {
       "Effect": "Allow",
       "Action": [
          "ssm:StartSession"
        ],
        "Resource": [
           "arn:aws:codebuild:region:account-id:build/*",
           "arn:aws:ssm:region::document/AWS-StartSSHSession"
        ]
    }
   ```

## Error: «No se encuentran las credenciales» cuando se utiliza SSH en CodeBuild un entorno sandbox
<a name="sandbox-troubleshooting.credentials"></a>

**Problema:** al intentar conectarse a un entorno CodeBuild aislado mediante el comando`ssh codebuild-sandbox-ssh=<sandbox-arn>`, es posible que aparezca el siguiente error de credenciales:

```
Unable to locate credentials. You can configure credentials by running 
"aws configure".
```

**Causa posible:** AWS las credenciales no se configuraron correctamente en su entorno local.

**Solución recomendada:** configure sus AWS CLI credenciales siguiendo la documentación oficial: [Configuración de los ajustes de la Guía del AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *usuario de la interfaz de línea de AWS comandos para la versión 2*.

## `StartSandboxConnection``AccessDeniedException`error al usar SSH en un CodeBuild entorno sandbox
<a name="sandbox-troubleshooting.access-denied"></a>

**Problema:** al intentar conectarse a un entorno CodeBuild sandbox mediante el comando`ssh codebuild-sandbox-ssh=<sandbox-arn>`, puede aparecer el siguiente error de permiso:

```
An error occurred (AccessDeniedException) when calling the StartSandboxConnection 
operation: 
User: arn:aws:sts::account-id:assumed-role/role-name
is not authorized to perform: codebuild:StartSandboxConnection on resource: 
sandbox-arn
because no identity-based policy allows the codebuild:StartSandboxConnection action
```

**Causa posible:** sus AWS credenciales carecen de los CodeBuild permisos necesarios para realizar esta operación.

**Solución recomendada:** asegúrese de que el usuario o rol de IAM asociado a sus AWS CLI credenciales tenga los siguientes permisos:

```
{
    "Effect": "Allow",
    "Action": [
       "codebuild:StartSandboxConnection"
     ],
     "Resource": [
        "arn:aws:codebuild:region:account-id:sandbox/*"
     ]
}
```

## Error: «ssh: no se ha podido resolver el nombre de host» cuando se utiliza SSH en un entorno aislado CodeBuild
<a name="sandbox-troubleshooting.hostname"></a>

**Problema:** al intentar conectarse a un entorno CodeBuild sandbox mediante el comando`ssh codebuild-sandbox-ssh=<sandbox-arn>`, aparece el siguiente error de resolución del nombre de host:

```
ssh: Could not resolve hostname
```

**Causa posible:** este error suele producirse cuando el script de conexión de CodeBuild espacio aislado requerido no se ha ejecutado correctamente en el entorno local.

**Solución recomendada:**

1. Descargue el script de conexión CodeBuild de sandbox.

1. Ejecute el script en el terminal para establecer la configuración de SSH necesaria.

1. Vuelva a intentar la conexión de SSH con el entorno de pruebas.

# Depuración de compilaciones con Administrador de sesiones
<a name="session-manager"></a>

En AWS CodeBuild, puedes pausar una compilación en ejecución y, a continuación, usar el Administrador de AWS Systems Manager sesiones para conectarte al contenedor de compilación y ver su estado.

**nota**  
Esta característica no está disponible en entornos Windows.

**Topics**
+ [Requisitos previos](#ssm.prerequisites)
+ [Pausar la compilación](#ssm-pause-build)
+ [Iniciar la compilación](#ssm-start-build)
+ [Conectarse al contenedor de compilación](#ssm-connect)
+ [Reanudar la compilación](#ssm-resume-build)

## Requisitos previos
<a name="ssm.prerequisites"></a>

Para permitir el uso de Session Manager con la sesión de compilación, es necesario habilitar la conexión de sesión para la compilación. Hay dos prerrequisitos:
+ CodeBuild Las imágenes seleccionadas estándar de Linux ya tienen el agente SSM instalado y el agente ContainerMode SSM activado. 

  Si va a utilizar una imagen personalizada para la compilación, haga lo siguiente:

  1. Instalar el SSM Agent de . Para obtener más información, consulte [Instalación manual de SSM Agent en instancias EC2 de Linux](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) en la Guía del usuario de AWS Systems Manager . La versión de SSM Agent debe ser 3.0.1295.0 o posterior.

  1. Copie el archivo [https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/5.0/amazon-ssm-agent.json](https://github.com/aws/aws-codebuild-docker-images/blob/master/ubuntu/standard/5.0/amazon-ssm-agent.json) en el directorio de la imagen. `/etc/amazon/ssm/` De este modo se habilita Modo de contenedor en SSM Agent.
**nota**  
Las imágenes personalizadas requieren el agente SSM más actualizado para que esta función funcione según lo esperado.
+ El rol de CodeBuild servicio debe tener la siguiente política de SSM:

------
#### [ JSON ]

****  

  ```
  {
     "Version":"2012-10-17",		 	 	  
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
            "ssmmessages:CreateControlChannel",
            "ssmmessages:CreateDataChannel",
            "ssmmessages:OpenControlChannel",
            "ssmmessages:OpenDataChannel"
         ],
         "Resource": "*"
       }
     ]
  }
  ```

------

  Puede hacer que la CodeBuild consola asocie automáticamente esta política a su función de servicio al iniciar la compilación. Como alternativa, puede adjuntar la política al rol de servicio manualmente.
+ Si tiene habilitada la **auditoría y el registro de la actividad de la sesión** en las preferencias de Systems Manager, la función de CodeBuild servicio también debe tener permisos adicionales. Los permisos varían según el lugar donde se almacenen los registros.  
CloudWatch Registros  
Si utiliza CloudWatch los registros para almacenar los registros, añada el siguiente permiso a la función CodeBuild de servicio:    
****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": "logs:DescribeLogGroups",
              "Resource": "arn:aws:logs:us-east-1:111122223333:log-group:*:*"
          },
          {
              "Effect": "Allow",
              "Action": [
                  "logs:CreateLogStream",
                  "logs:PutLogEvents"
              ],
              "Resource": "arn:aws:logs:us-east-1:111122223333:log-group:MyLogGroup:*"
          }
      ]
  }
  ```  
Amazon S3  
Si utiliza Amazon S3 para almacenar sus registros, añada el siguiente permiso al rol CodeBuild de servicio:    
****  

  ```
  {
    "Version":"2012-10-17",		 	 	 
    "Statement": [
      {
        "Effect": "Allow",
        "Action": [
          "s3:GetEncryptionConfiguration",
          "s3:PutObject"
        ],
        "Resource": [
          "arn:aws:s3:::<bucket-name>",
          "arn:aws:s3:::<bucket-name>/*"
        ]
      }
    ]
  }
  ```

  Para obtener más información, consulte [Actividad de auditoría y registro de sesión](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging-auditing.html) en la *Guía del usuario de AWS Systems Manager *.

## Pausar la compilación
<a name="ssm-pause-build"></a>

Para pausar la compilación, inserte el comando **codebuild-breakpoint** en cualquiera de las fases de compilación del archivo de especificación de compilación. La compilación se pausará en este punto, lo que permite conectar con el contenedor de compilación y ver el contenedor en su estado actual. 

Por ejemplo, añada lo siguiente a las fases de compilación del archivo de especificación de compilación.

```
phases:
  pre_build:
    commands:
      - echo Entered the pre_build phase...
      - echo "Hello World" > /tmp/hello-world
      - codebuild-breakpoint
```

Este código crea el archivo `/tmp/hello-world` y, a continuación, detiene la compilación en este punto.

## Iniciar la compilación
<a name="ssm-start-build"></a>

Para permitir el uso de Session Manager con la sesión de compilación, es necesario habilitar las conexiones de sesión para la compilación. Para hacerlo, al iniciar la compilación, siga estos pasos:

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

1. En el panel de navegación, elija **Proyectos de compilación**. Elija el proyecto de compilación y, a continuación, elija **Iniciar compilación con anulaciones**.

1. Seleccione **Advanced build overrides (Sustitución avanzada de compilaciones)**.

1. En la sección **Entorno**, elija la opción **Habilitar la conexión de sesión**. Si no se selecciona esta opción, se ignoran todos los comandos de **codebuild-breakpoint** y **codebuild-resume**.

1. Realice los demás cambios que desee y elija **Iniciar compilación**. 

1. Monitoriza el estado de la compilación en la consola. Cuando la sesión esté disponible, el enlace al **AWS Session Manager** aparecerá en la sección **Estado de compilación**.

## Conectarse al contenedor de compilación
<a name="ssm-connect"></a>

Es posible conectarse al contenedor de compilación de una de las dos formas siguientes:

CodeBuild consola  
En un navegador web, abra el enlace de **AWS Session Manager** para conectarse al contenedor de compilación. Se abre una sesión de terminal que le permite explorar y controlar el contenedor de compilación. 

AWS CLI  
Su máquina local debe tener instalado el complemento de Session Manager para realizar este procedimiento. Para obtener más información, consulte [Instalación del complemento Session Manager para la AWS CLI](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html) en la Guía del AWS Systems Manager usuario. 

1. Llame a la API de **batch-get-builds** con el ID de compilación para obtener información sobre la compilación, incluido el identificador de destino de la sesión. El nombre de la propiedad del identificador de destino de la sesión varía según el tipo de salida del comando `aws`. Por eso se añade `--output json` al comando.

   ```
   aws codebuild batch-get-builds --ids <buildID> --region <region> --output json
   ```

1. Copie el valor de la propiedad `sessionTarget`. El nombre de la propiedad `sessionTarget` puede variar en función del tipo de salida del comando `aws`. Por eso se añade `--output json` al comando en el paso anterior.

1. Utilice el comando siguiente para conectarse al contenedor de compilación.

   ```
   aws ssm start-session --target <sessionTarget> --region <region>
   ```

Para este ejemplo, comprueba que el archivo `/tmp/hello-world` exista y contiene el texto `Hello World`.

## Reanudar la compilación
<a name="ssm-resume-build"></a>

Después de examinar el contenedor de compilación, ejecute el comando **codebuild-resume** desde el intérprete de comandos del contenedor.

```
$ codebuild-resume
```

# Eliminación de compilaciones en AWS CodeBuild
<a name="delete-builds"></a>

Puede utilizar AWS CLI o los SDK de AWS para eliminar compilaciones en AWS CodeBuild.

**Topics**
+ [Eliminación de compilaciones (AWS CLI)](#delete-builds-cli)
+ [Eliminación de compilaciones (SDK de AWS)](#delete-builds-sdks)

## Eliminación de compilaciones (AWS CLI)
<a name="delete-builds-cli"></a>

Ejecute el comando `batch-delete-builds`:

```
aws codebuild batch-delete-builds --ids ids
```

En el comando anterior, sustituya el siguiente marcador de posición:
+ *ids*: cadena obligatoria. Los ID de las compilaciones que se van a eliminar. Para especificar varias compilaciones, separe cada ID de compilación con un espacio. Para obtener una lista de identificadores de compilación, consulte los siguientes temas:
  + [Ver una lista de build () IDs AWS CLI](view-build-list.md#view-build-list-cli)
  + [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

En caso de éxito, aparece una matriz `buildsDeleted` en la salida, que contiene el Nombre de recurso de Amazon (ARN) de cada compilación eliminada correctamente. La información sobre las compilaciones que no se eliminaron correctamente aparece en la salida dentro de la matriz `buildsNotDeleted`.

Por ejemplo, si ejecuta este comando:

```
aws codebuild batch-delete-builds --ids my-demo-build-project:f8b888d2-5e1e-4032-8645-b115195648EX my-other-demo-build-project:a18bc6ee-e499-4887-b36a-8c90349c7eEX
```

En la salida se muestra información similar a la siguiente:

```
{
  "buildsNotDeleted": [
    {
      "id": "arn:aws:codebuild:us-west-2:123456789012:build/my-demo-build-project:f8b888d2-5e1e-4032-8645-b115195648EX",
      "statusCode": "BUILD_IN_PROGRESS"
    }
  ], 
  "buildsDeleted": [
    "arn:aws:codebuild:us-west-2:123456789012:build/my-other-demo-build-project:a18bc6ee-e499-4887-b36a-8c90349c7eEX"
  ]
}
```

## Eliminación de compilaciones (SDK de AWS)
<a name="delete-builds-sdks"></a>

Para obtener información sobre cómo usar AWS CodeBuild con los SDK de AWS, consulte [AWS SDKs y referencia de herramientas](sdk-ref.md).

# Vuelve a intentar compilar manualmente AWS CodeBuild
<a name="retry-build"></a>

Puede usar la AWS CodeBuild consola o volver AWS SDKs a intentar manualmente una compilación única o una compilación por lotes. AWS CLI AWS CodeBuild

**Topics**
+ [Cómo reintentar hacer una compilación de forma manual (consola)](#retry-build-console)
+ [Cómo reintentar hacer una compilación de forma manual (AWS CLI)](#retry-build-cli)
+ [Cómo reintentar hacer una compilación de forma manual (AWS SDKs)](#retry-build-sdks)

## Cómo reintentar hacer una compilación de forma manual (consola)
<a name="retry-build-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. Realice una de las siguientes acciones:
   + **Si aparece la *build-ID* página ***build-project-name*:**, selecciona Reintentar compilar.**
   + En el panel de navegación, elija **Historial de compilaciones**. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Reintentar compilación**.
   + En el panel de navegación, elija **Proyectos de compilación**. En la lista de proyectos de compilación, en la columna **Name (Nombre)**, elija el enlace correspondiente al nombre del proyecto de compilación. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Reintentar compilación**.

**nota**  
De forma predeterminada, solo se muestran las 100 compilaciones o proyectos de compilación más recientes. Para ver más compilaciones o proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o **Projects per page (Proyectos por página)** o seleccione las flechas atrás y adelante.

## Cómo reintentar hacer una compilación de forma manual (AWS CLI)
<a name="retry-build-cli"></a>
+ Ejecute el comando **retry-build**:

  ```
  aws codebuild retry-build --id <build-id> --idempotency-token <idempotencyToken>
  ```

  En el comando anterior, sustituya el siguiente marcador de posición:
  + *<build-id>*: cadena requerida. ID de la compilación o compilación por lotes que se desea volver a intentar. Para obtener una lista de las IDs compilaciones, consulte los siguientes temas:
    + [Ver una lista de build () IDs AWS CLI](view-build-list.md#view-build-list-cli)
    + [Ver una lista de build IDs (AWS CLI) por lotes](view-build-list.md#view-batch-build-list-cli)
    + [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)
    + [Ver una lista de compilaciones por lotes IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-batch-builds-for-project-cli)
  + `--idempotency-token`: opcional. Si ejecuta el comando **retry-build** con la opción, se incluye un identificador único en el que se distingue entre mayúsculas y minúsculas, o token, con la solicitud de `retry-build`. El token es válido durante 5 minutos después de la solicitud. Si repites la `retry-build` solicitud con el mismo token, pero cambias un parámetro, se produce un error de CodeBuild discordancia entre los parámetros.

## Cómo reintentar hacer una compilación de forma manual (AWS SDKs)
<a name="retry-build-sdks"></a>

Para obtener más información sobre el uso AWS CodeBuild con AWS SDKs, consulte la[AWS SDKs y referencia de herramientas](sdk-ref.md).

# Cómo reintentar hacer una compilación de forma automática en la AWS CodeBuild
<a name="auto-retry-build"></a>

Puede usar la consola de AWS CodeBuild, la AWS CLI o los SDK de AWS para reintentar realizar sus compilaciones de forma automática en AWS CodeBuild. Si el reintento automático está habilitado, CodeBuild llamará de forma automática a `RetryBuild` con el rol de servicio del proyecto después de una compilación con errores hasta un límite especificado. Por ejemplo, si el límite de reintentos automáticos está establecido en dos, CodeBuild llamará a la API `RetryBuild` para reintentar la compilación de forma automática hasta dos veces más.

**nota**  
CodeBuild no admite el reintento automático para CodePipeline.

**Topics**
+ [Cómo reintentar hacer una compilación de forma automática (consola)](#auto-retry-build-console)
+ [Cómo reintentar hacer una compilación de forma automática (AWS CLI)](#auto-retry-build-cli)
+ [Cómo reintentar hacer una compilación de forma automática (SDK de AWS)](#auto-retry-build-sdks)

## Cómo reintentar hacer una compilación de forma automática (consola)
<a name="auto-retry-build-console"></a>

1. Abra la consola de AWS CodeBuild 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).
   +  En **Environment (Entorno)**: 
     +  En **Límite de reintentos automáticos**, especifique el número máximo de reintentos automáticos deseado tras una compilación con errores.

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

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

## Cómo reintentar hacer una compilación de forma automática (AWS CLI)
<a name="auto-retry-build-cli"></a>
+ Ejecute el comando **create-project**:

  ```
  aws codebuild create-project \
      --name "<project-name>" \
      --auto-retry-limit <auto-retry-limit> \
      --source "<source>" \
      --artifacts {<artifacts>} \
      --environment "{\"type\": \"environment-type>\",\"image\": \"image-type>\",\"computeType\": \"compute-type>\"}" \
      --service-role "service-role>"
  ```

  En el comando anterior, sustituya los siguientes marcadores de posición:
  + *<auto-retry-limit>*: establezca el límite de reintentos automáticos en el número máximo de reintentos automáticos deseado tras una compilación con errores.
  + *<project-name>*, *<source>*, *<artifacts>*, *environment-type>*, *image-type>*, *compute-type>* y *service-role>*: establezca la configuración de proyecto deseada.

## Cómo reintentar hacer una compilación de forma automática (SDK de AWS)
<a name="auto-retry-build-sdks"></a>

Para obtener más información sobre cómo usar AWS CodeBuild con los SDK de AWS, consulte [AWS SDKs y referencia de herramientas](sdk-ref.md).

# Detención de las compilaciones en AWS CodeBuild
<a name="stop-build"></a>

Puede usar la consola de AWS CodeBuild, la AWS CLI o los SDK de AWS para detener una compilación de AWS CodeBuild.

**Topics**
+ [Detener una compilación (consola)](#stop-build-console)
+ [Detener una compilación (AWS CLI)](#stop-build-cli)
+ [Detener una compilación (SDK de AWS)](#stop-build-sdks)

## Detener una compilación (consola)
<a name="stop-build-console"></a>

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

1. Realice una de las siguientes acciones:
   + Si aparece la página ***nombre-proyecto-compilación*:*ID-compilación***, elija **Stop build (Detener compilación)**.
   + En el panel de navegación, elija **Historial de compilaciones**. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Stop build (Detener compilación)**.
   + En el panel de navegación, elija **Proyectos de compilación**. En la lista de proyectos de compilación, en la columna **Name (Nombre)**, elija el enlace correspondiente al nombre del proyecto de compilación. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Stop build (Detener compilación)**.

**nota**  
De forma predeterminada, solo se muestran las 100 compilaciones o proyectos de compilación más recientes. Para ver más compilaciones o proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o **Projects per page (Proyectos por página)** o seleccione las flechas atrás y adelante.  
Si AWS CodeBuild no puede detener correctamente una compilación (por ejemplo, porque el proceso ya se ha completado), el botón **Stop (Detener)** estará desactivado o podría no aparecer.

## Detener una compilación (AWS CLI)
<a name="stop-build-cli"></a>
+ Ejecute el comando **stop-build**:

  ```
  aws codebuild stop-build --id id
  ```

  En el comando anterior, sustituya el siguiente marcador de posición:
  + *id*: cadena obligatoria. El ID de la compilación que desea detener. Para obtener una lista de identificadores de compilación, consulte los siguientes temas:
    + [Ver una lista de build () IDs AWS CLI](view-build-list.md#view-build-list-cli)
    + [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

  Si AWS CodeBuild detiene correctamente la compilación, el valor de `buildStatus` del objeto `build` de la salida será `STOPPED`.

  Si CodeBuild no puede detener correctamente la compilación (por ejemplo, porque la compilación ya se ha completado), el valor de `buildStatus` del objeto `build` de la salida es el estado final de la compilación (por ejemplo, `SUCCEEDED`).

## Detener una compilación (SDK de AWS)
<a name="stop-build-sdks"></a>

Para obtener más información sobre cómo usar AWS CodeBuild con los SDK de AWS, consulte [AWS SDKs y referencia de herramientas](sdk-ref.md).

# Detención de las compilaciones por lotes en AWS CodeBuild
<a name="stop-batch-build"></a>

Puede usar la consola de AWS CodeBuild, la AWS CLI o los SDK de AWS para detener una compilación por lotes de AWS CodeBuild.

**nota**  
Si utiliza computación Lambda en la compilación por lotes, la compilación Lambda en curso no se puede detener.

**Topics**
+ [Detener una compilación por lotes (consola)](#stop-batch-build-console)
+ [Detener una compilación por lotes (AWS CLI)](#stop-batch-build-cli)
+ [Detener una compilación por lotes (SDK de AWS)](#stop-batch-build-sdks)

## Detener una compilación por lotes (consola)
<a name="stop-batch-build-console"></a>

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

1. Realice una de las siguientes acciones:
   + Si aparece la página ***nombre-proyecto-compilación*:*ID-compilación***, elija **Stop build (Detener compilación)**.
   + En el panel de navegación, elija **Historial de compilaciones**. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Stop build (Detener compilación)**.
   + En el panel de navegación, elija **Proyectos de compilación**. En la lista de proyectos de compilación, en la columna **Name (Nombre)**, elija el enlace correspondiente al nombre del proyecto de compilación. En la lista de compilaciones, seleccione la casilla correspondiente a la compilación y después elija **Stop build (Detener compilación)**.

**nota**  
De forma predeterminada, solo se muestran las 100 compilaciones o proyectos de compilación más recientes. Para ver más compilaciones o proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o **Projects per page (Proyectos por página)** o seleccione las flechas atrás y adelante.

## Detener una compilación por lotes (AWS CLI)
<a name="stop-batch-build-cli"></a>
+ Ejecute el comando [https://docs.aws.amazon.com/cli/latest/reference/codebuild/stop-build-batch.html](https://docs.aws.amazon.com/cli/latest/reference/codebuild/stop-build-batch.html):

  ```
  aws codebuild stop-build-batch --id <batch-build-id>
  ```

  En el comando anterior, sustituya el siguiente marcador de posición:
  + *<batch-build-id>*: cadena obligatoria. Identificador del lote que se desea detener. Para obtener una lista de identificadores de compilación por lotes, consulte los temas siguientes:
    + [Ver una lista de build IDs (AWS CLI) por lotes](view-build-list.md#view-batch-build-list-cli)
    + [Ver una lista de compilaciones por lotes IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-batch-builds-for-project-cli)

## Detener una compilación por lotes (SDK de AWS)
<a name="stop-batch-build-sdks"></a>

Para obtener más información sobre cómo usar AWS CodeBuild con los SDK de AWS, consulte [AWS SDKs y referencia de herramientas](sdk-ref.md).

# Cómo desencadenar compilaciones de AWS CodeBuild de forma automática
<a name="build-triggers"></a>

Puede crear un desencadenador en un proyecto para programar una compilación una vez cada hora, día o semana. También puede editar un desencadenador para usar una regla personalizada con una expresión cron de Amazon CloudWatch. Por ejemplo, mediante una expresión cron puede programar una compilación en un momento específico todos los días de la semana. Para obtener información sobre cómo crear y editar desencadenadores, consulte [Crear desencadenadores de AWS CodeBuild](#trigger-create) y [Editar desencadenadores de AWS CodeBuild](triggers-edit.md).

**Topics**
+ [Crear desencadenadores de AWS CodeBuild](#trigger-create)
+ [Editar desencadenadores de AWS CodeBuild](triggers-edit.md)

## Crear desencadenadores de AWS CodeBuild
<a name="trigger-create"></a>

Puede crear un desencadenador en un proyecto para programar una compilación una vez cada hora, día o semana. También puede crear un desencadenador mediante una regla personalizada con una expresión cron de Amazon CloudWatch. Por ejemplo, mediante una expresión cron puede programar una compilación en un momento específico todos los días de la semana. 

**nota**  
No es posible iniciar una compilación por lotes a partir de un desencadenador de compilación, un evento de Amazon EventBridge o una tarea de AWS Step Functions.

**Topics**
+ [Creación de desencadenadores de AWS CodeBuild (consola)](#trigger-create-console)
+ [Creación de desencadenadores de AWS CodeBuild mediante programación](#trigger-create-code)

### Creación de desencadenadores de AWS CodeBuild (consola)
<a name="trigger-create-console"></a>

Utilice el siguiente procedimiento para crear desencadenadores mediante la Consola de administración de AWS.

**Cómo crear un desencadenador** 

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

1. En el panel de navegación, elija **Proyectos de compilación**.

1. Elija el enlace del proyecto de compilación al que desea agregar un disparador y, a continuación, elija la pestaña **Build triggers** (Disparadores de compilación).
**nota**  
De forma predeterminada, solo se muestran los 100 últimos proyectos de compilación. Para ver más proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Projects per page (Proyectos por página)** o use las flechas atrás y adelante.

1. Elija **Create trigger**.

1. Escriba un nombre en **Trigger name (Nombre del disparador)**.

1. En la lista desplegable **Frequency (Frecuencia)**, elija la frecuencia del disparador. Si desea crear la frecuencia con una expresión Cron, seleccione **Custom (Personalizado)**.

1. Especifique los parámetros de frecuencia del disparador. Puede introducir los primeros caracteres de su selección en el cuadro de texto para filtrar los elementos del menú desplegable.
**nota**  
 Las horas y minutos de inicio están basados en cero. El minuto de inicio es un número entre cero y 59. La hora de inicio es un número entre cero y 23. Por ejemplo, un desencadenador diario que comienza todos los días a las 12:15 PM, tiene 12 como hora de inicio y 15 como minuto de inicio. Un desencadenador diario que comienza cada día a medianoche tiene una hora de inicio 0 y un minuto de inicio 0. Un desencadenador diario que comienza todos los días a las 11:59 PM, tiene 23 como hora de inicio y 59. como minuto de inicio.   
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/build-triggers.html)

1.  Seleccione **Enable this trigger (Activar este disparador)**. 

1.  (Opcional) Expanda la sección **Advanced (Avanzado)**. En **Source version (Versión de código fuente)**, escriba una versión del código fuente. 
   +  En Amazon S3, introduzca el ID de versión que corresponda a la versión del artefacto de entrada que desea compilar. Si la **Source version (Versión del código fuente)** se deja en blanco, se usará la versión más reciente. 
   +  En AWS CodeCommit, especifique un ID de confirmación. Si **Source version (Versión del código fuente)** se deja en blanco, se utilizará el ID de confirmación HEAD de la ramificación predeterminada. 
   + En GitHub o GitHub Enterprise, especifique un ID de confirmación, un ID de solicitud de extracción, un nombre de ramificación o un nombre de etiqueta que se corresponda con la versión del código fuente que desea compilar. Si especifica un ID de solicitud de extracción, este debe tener el formato `pr/pull-request-ID` (por ejemplo, `pr/25`). Si especifica un nombre de ramificación, se usa el ID de confirmación HEAD de la ramificación. Si **Source version (Versión del código fuente)** se deja en blanco, se usa el ID de confirmación HEAD de la ramificación predeterminada.
   + En Bitbucket, especifique un ID de confirmación, un nombre de ramificación o un nombre de etiqueta que se corresponda con la versión de código fuente que desea compilar. Si especifica un nombre de ramificación, se usa el ID de confirmación HEAD de la ramificación. Si **Source version (Versión del código fuente)** se deja en blanco, se usa el ID de confirmación HEAD de la ramificación predeterminada.

1. (Opcional) Especifique un tiempo de espera entre 5 y 2160 minutos (36 horas). Este valor especifica durante cuánto tiempo AWS CodeBuild intenta ejecutar una compilación antes de detenerse. Si los campos **Hours (Horas)** y **Minutes (Minutos)** se dejan en blanco, se usa el valor de tiempo de espera predeterminado especificado en el proyecto. 

1. Elija **Create trigger**.

### Creación de desencadenadores de AWS CodeBuild mediante programación
<a name="trigger-create-code"></a>

CodeBuild utiliza reglas de Amazon EventBridge para desencadenadores de compilación. Es posible utilizar la API de EventBridge para crear desencadenadores de compilación para tus proyectos de CodeBuild mediante programación. Para obtener más información, consulte la [Referencia de las API de Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/APIReference/).

# Editar desencadenadores de AWS CodeBuild
<a name="triggers-edit"></a>

Puede editar un disparador en un proyecto para programar una compilación una vez cada hora, día o semana. También puede editar un desencadenador para usar una regla personalizada con una expresión cron de Amazon CloudWatch. Por ejemplo, mediante una expresión cron puede programar una compilación en un momento específico todos los días de la semana. Para obtener información acerca de la creación de un disparador, consulte [Crear desencadenadores de AWS CodeBuild](build-triggers.md#trigger-create).

**Topics**
+ [Edición de desencadenadores de AWS CodeBuild (consola)](#triggers-edit-console)
+ [Edición de desencadenadores de AWS CodeBuild mediante programación](#trigger-edit-code)

## Edición de desencadenadores de AWS CodeBuild (consola)
<a name="triggers-edit-console"></a>

Utilice el siguiente procedimiento para editar desencadenadores mediante la Consola de administración de AWS.

**Para editar un desencadenador**

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

1. En el panel de navegación, elija **Proyectos de compilación**.

1. Elija el enlace del proyecto de compilación que desea cambiar y, a continuación, seleccione la pestaña **Build triggers (Desencadenadores de compilación)**.
**nota**  
De forma predeterminada, solo se muestran los 100 últimos proyectos de compilación. Para ver más proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Projects per page (Proyectos por página)** o use las flechas atrás y adelante.

1. Elija el botón de opción junto al desencadenador que desea cambiar y, a continuación, elija **Edit (Editar)**.

1. En la lista desplegable **Frequency (Frecuencia)**, elija la frecuencia del disparador. Si desea crear la frecuencia con una expresión Cron, seleccione **Custom (Personalizado)**.

1. Especifique los parámetros de frecuencia del disparador. Puede introducir los primeros caracteres de su selección en el cuadro de texto para filtrar los elementos del menú desplegable.
**nota**  
 Las horas y minutos de inicio están basados en cero. El minuto de inicio es un número entre cero y 59. La hora de inicio es un número entre cero y 23. Por ejemplo, un desencadenador diario que comienza todos los días a las 12:15 PM, tiene 12 como hora de inicio y 15 como minuto de inicio. Un desencadenador diario que comienza cada día a medianoche tiene una hora de inicio 0 y un minuto de inicio 0. Un desencadenador diario que comienza todos los días a las 11:59 PM, tiene 23 como hora de inicio y 59. como minuto de inicio.   
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/triggers-edit.html)

1.  Seleccione **Enable this trigger (Activar este disparador)**. 

**nota**  
Puede utilizar la consola Amazon CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) para editar la versión de fuente, el tiempo de espera y otras opciones que no estén disponibles en AWS CodeBuild.

## Edición de desencadenadores de AWS CodeBuild mediante programación
<a name="trigger-edit-code"></a>

CodeBuild utiliza reglas de Amazon EventBridge para desencadenadores de compilación. Es posible utilizar la API de EventBridge para editar los activadores de compilación de los proyectos de CodeBuild mediante programación. Para obtener más información, consulte la [Referencia de las API de Amazon EventBridge](https://docs.aws.amazon.com/eventbridge/latest/APIReference/).

# Vea los detalles de la construcción en AWS CodeBuild
<a name="view-build-details"></a>

Puede usar la AWS CodeBuild consola o ver detalles sobre AWS SDKs las compilaciones administradas por CodeBuild. AWS CLI

**Topics**
+ [Ver detalles de las compilaciones (consola)](#view-build-details-console)
+ [Ver detalles de las compilaciones (AWS CLI)](#view-build-details-cli)
+ [Ver detalles de las compilaciones (AWS SDKs)](#view-build-details-sdks)
+ [Transiciones de fases de compilación](view-build-details-phases.md)

## Ver detalles de las compilaciones (consola)
<a name="view-build-details-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. Realice una de las siguientes acciones:
   + En el panel de navegación, elija **Historial de compilaciones**. En la lista de compilaciones, en la columna **Build run (Ejecución de compilación)**, elija el enlace de la compilación. 
   + En el panel de navegación, elija **Proyectos de compilación**. En la lista de proyectos de compilación, en la columna **Name (Nombre)**, elija el enlace del nombre del proyecto de compilación. A continuación, en la lista de compilaciones, en la columna **Build run (Ejecución de compilación)**, elija el enlace de la compilación.
**nota**  
De forma predeterminada, solo se muestran las diez compilaciones o proyectos de compilación más recientes. Para ver más compilaciones o proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o **Projects per page (Proyectos por página)** o seleccione las flechas atrás y adelante.

## Ver detalles de las compilaciones (AWS CLI)
<a name="view-build-details-cli"></a>

Para obtener más información sobre el uso del AWS CLI with AWS CodeBuild, consulta la. [Referencia de la línea de comandos](cmd-ref.md)

Ejecute el comando **batch-get-builds**:

```
aws codebuild batch-get-builds --ids ids
```

Reemplace el siguiente marcador de posición:
+ *ids*: Cadena obligatoria. Una o más compilaciones sobre IDs las que ver los detalles. Para especificar más de un ID de compilación, separe cada ID de compilación con un espacio. Puede especificar hasta 100 compilaciones IDs. Para obtener una lista de las IDs compilaciones, consulte los siguientes temas:
  + [Ver una lista de build () IDs AWS CLI](view-build-list.md#view-build-list-cli)
  + [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

Por ejemplo, si ejecuta este comando:

```
aws codebuild batch-get-builds --ids codebuild-demo-project:e9c4f4df-3f43-41d2-ab3a-60fe2EXAMPLE codebuild-demo-project:815e755f-bade-4a7e-80f0-efe51EXAMPLE my-other-project:813bb6c6-891b-426a-9dd7-6d8a3EXAMPLE
```

Si el comando tiene éxito, aparecen datos similares a los descritos en [Para ver la información resumida de la compilación](getting-started-overview.md#getting-started-cli-monitor-build-cli) en la salida.

## Ver detalles de las compilaciones (AWS SDKs)
<a name="view-build-details-sdks"></a>

Para obtener más información sobre su uso AWS CodeBuild con AWS SDKs, consulte la[AWS SDKs y referencia de herramientas](sdk-ref.md).

# Transiciones de fases de compilación
<a name="view-build-details-phases"></a>

Las compilaciones se AWS CodeBuild llevan a cabo en fases:



![\[Las CodeBuild fases.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/build-phases.png)




**importante**  
La fase `UPLOAD_ARTIFACTS` se intenta siempre, aunque la fase `BUILD` produzca un error.

# Ver una lista de elementos IDs incorporados AWS CodeBuild
<a name="view-build-list"></a>

Puede usar la AWS CodeBuild consola o AWS SDKs ver una lista de IDs compilaciones gestionadas por CodeBuild. AWS CLI

**Topics**
+ [Ver una lista de compilaciones IDs (consola)](#view-build-list-console)
+ [Ver una lista de build () IDs AWS CLI](#view-build-list-cli)
+ [Ver una lista de build IDs (AWS CLI) por lotes](#view-batch-build-list-cli)
+ [Ver una lista de build IDs (AWS SDKs)](#view-build-list-sdks)

## Ver una lista de compilaciones IDs (consola)
<a name="view-build-list-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. En el panel de navegación, elija **Historial de compilaciones**. 
**nota**  
De forma predeterminada, solo se muestran las diez compilaciones más recientes. Para ver más compilaciones, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o use las flechas atrás y adelante.

## Ver una lista de build () IDs AWS CLI
<a name="view-build-list-cli"></a>

Para obtener más información sobre el uso del AWS CLI with CodeBuild, consulta la[Referencia de la línea de comandos](cmd-ref.md).
+ Ejecute el comando **list-builds**:

  ```
  aws codebuild list-builds --sort-order sort-order --next-token next-token
  ```

  En el comando anterior, sustituya los siguientes marcadores de posición:
  + *sort-order*: Cadena opcional utilizada para indicar cómo enumerar la compilación IDs. Los valores válidos son `ASCENDING` y `DESCENDING`.
  + *next-token*: cadena opcional. Durante una ejecución anterior, si hubiera más de 100 elementos en la lista, solo se devolverían los 100 primeros, junto con una única cadena denominada *next token*. Para obtener el siguiente lote de elementos de la lista, ejecute de nuevo este comando añadiendo el siguiente token a la llamada. Para obtener todos los elementos de la lista, siga ejecutando el comando con cada uno de los siguientes tokens hasta que no se devuelvan más tokens.

  Por ejemplo, si ejecuta este comando:

  ```
  aws codebuild list-builds --sort-order ASCENDING
  ```

  Un resultado similar al siguiente podría aparecer en la salida:

  ```
  {
    "nextToken": "4AEA6u7J...The full token has been omitted for brevity...MzY2OA==",
    "ids": [
      "codebuild-demo-project:815e755f-bade-4a7e-80f0-efe51EXAMPLE"
      "codebuild-demo-project:84a7f3d1-d40e-4956-b4cf-7a9d4EXAMPLE"
      ... The full list of build IDs has been omitted for brevity ...
      "codebuild-demo-project:931d0b72-bf6f-4040-a472-5c707EXAMPLE"
    ]
  }
  ```

  Si ejecuta este comando de nuevo:

  ```
  aws codebuild list-builds --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
  ```

  Un resultado similar al siguiente podría aparecer en la salida:

  ```
  {
    "ids": [
      "codebuild-demo-project:49015049-21cf-4b50-9708-df115EXAMPLE",
      "codebuild-demo-project:543e7206-68a3-46d6-a4da-759abEXAMPLE",
      ... The full list of build IDs has been omitted for brevity ...
      "codebuild-demo-project:c282f198-4582-4b38-bdc0-26f96EXAMPLE"
    ]
  }
  ```

## Ver una lista de build IDs (AWS CLI) por lotes
<a name="view-batch-build-list-cli"></a>

Para obtener más información sobre el uso del AWS CLI with CodeBuild, consulte la[Referencia de la línea de comandos](cmd-ref.md).
+ Ejecute el comando **list-build-batches**:

  ```
  aws codebuild list-build-batches --sort-order sort-order --next-token next-token
  ```

  En el comando anterior, sustituya los siguientes marcadores de posición:
  + *sort-order*: cadena opcional utilizada para indicar cómo enumerar la compilación por lotes IDs. Los valores válidos son `ASCENDING` y `DESCENDING`.
  + *next-token*: cadena opcional. Durante una ejecución anterior, si hubiera más de 100 elementos en la lista, solo se devolverían los 100 primeros, junto con una única cadena denominada *next token*. Para obtener el siguiente lote de elementos de la lista, ejecute de nuevo este comando añadiendo el siguiente token a la llamada. Para obtener todos los elementos de la lista, siga ejecutando el comando con cada uno de los siguientes tokens hasta que no se devuelvan más tokens.

  Por ejemplo, si ejecuta este comando:

  ```
  aws codebuild list-build-batches --sort-order ASCENDING
  ```

  Un resultado similar al siguiente podría aparecer en la salida:

  ```
  {
    "nextToken": "4AEA6u7J...The full token has been omitted for brevity...MzY2OA==",
    "ids": [
      "codebuild-demo-project:815e755f-bade-4a7e-80f0-efe51EXAMPLE"
      "codebuild-demo-project:84a7f3d1-d40e-4956-b4cf-7a9d4EXAMPLE"
      ... The full list of build IDs has been omitted for brevity ...
      "codebuild-demo-project:931d0b72-bf6f-4040-a472-5c707EXAMPLE"
    ]
  }
  ```

  Si ejecuta este comando de nuevo:

  ```
  aws codebuild list-build-batches --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
  ```

  Un resultado similar al siguiente podría aparecer en la salida:

  ```
  {
    "ids": [
      "codebuild-demo-project:49015049-21cf-4b50-9708-df115EXAMPLE",
      "codebuild-demo-project:543e7206-68a3-46d6-a4da-759abEXAMPLE",
      ... The full list of build IDs has been omitted for brevity ...
      "codebuild-demo-project:c282f198-4582-4b38-bdc0-26f96EXAMPLE"
    ]
  }
  ```

## Ver una lista de build IDs (AWS SDKs)
<a name="view-build-list-sdks"></a>

Para obtener más información sobre su uso CodeBuild con AWS SDKs, consulte la[AWS SDKs y referencia de herramientas](sdk-ref.md).

# Ver una lista de compilaciones IDs para un proyecto de construcción en AWS CodeBuild
<a name="view-builds-for-project"></a>

Puede usar la AWS CodeBuild consola o AWS SDKs ver una lista de compilaciones IDs para un proyecto de compilación en el que se encuentra CodeBuild. AWS CLI

**Topics**
+ [Ver una lista de compilaciones IDs para un proyecto de compilación (consola)](#view-builds-for-project-console)
+ [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)](#view-builds-for-project-cli)
+ [Ver una lista de compilaciones por lotes IDs para un proyecto de compilación (AWS CLI)](#view-batch-builds-for-project-cli)
+ [Ver una lista de compilaciones IDs para un proyecto de compilación (AWS SDKs)](#view-builds-for-project-sdks)

## Ver una lista de compilaciones IDs para un proyecto de compilación (consola)
<a name="view-builds-for-project-console"></a>

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

1. En el panel de navegación, elija **Proyectos de compilación**. En la lista de proyectos de compilación, en la columna **Name (Nombre)**, elija el proyecto de compilación. 

**nota**  
De forma predeterminada, solo se muestran las 100 compilaciones o proyectos de compilación más recientes. Para ver más compilaciones o proyectos de compilación, elija el icono de rueda dentada y, a continuación, seleccione un valor diferente para **Builds per page (Compilaciones por página)** o **Projects per page (Proyectos por página)** o seleccione las flechas atrás y adelante.

## Ver una lista de compilaciones IDs para un proyecto de compilación (AWS CLI)
<a name="view-builds-for-project-cli"></a>

Para obtener más información sobre el uso del AWS CLI with AWS CodeBuild, consulte la[Referencia de la línea de comandos](cmd-ref.md).

Ejecute el comando **list-builds-for-project** de la siguiente manera:

```
aws codebuild list-builds-for-project --project-name project-name --sort-order sort-order --next-token next-token
```

En el comando anterior, sustituya los siguientes marcadores de posición:
+ *project-name*: Cadena obligatoria que se utiliza para indicar el nombre del proyecto de compilación IDs para el que se van a enumerar las compilaciones. Para obtener una lista de proyectos de compilación, consulte [Ver una lista de nombres de proyectos de compilación (AWS CLI)](view-project-list.md#view-project-list-cli).
+ *sort-order*: Cadena opcional que se utiliza para indicar cómo enumerar la compilación IDs. Los valores válidos son `ASCENDING` y `DESCENDING`.
+ *next-token*: cadena opcional. Durante una ejecución anterior, si hubiera más de 100 elementos en la lista, solo se devolverían los 100 primeros, junto con una única cadena denominada *next token*. Para obtener el siguiente lote de elementos de la lista, ejecute de nuevo este comando añadiendo el siguiente token a la llamada. Para obtener todos los elementos de la lista, siga ejecutando el comando con cada uno de los siguientes tokens devueltos hasta que no se devuelvan más tokens.

Por ejemplo, si ejecuta un comando similar a este:

```
aws codebuild list-builds-for-project --project-name codebuild-demo-project --sort-order ASCENDING
```

Aparecerá un resultado como el siguiente en la salida:

```
{
  "nextToken": "4AEA6u7J...The full token has been omitted for brevity...MzY2OA==",
  "ids": [
    "codebuild-demo-project:9b175d16-66fd-4e71-93a0-50a08EXAMPLE"
    "codebuild-demo-project:a9d1bd09-18a2-456b-8a36-7d65aEXAMPLE"
    ... The full list of build IDs has been omitted for brevity ...
    "codebuild-demo-project:fe70d102-c04f-421a-9cfa-2dc15EXAMPLE"
  ]
}
```

Si ejecuta este comando de nuevo:

```
aws codebuild list-builds-for-project --project-name codebuild-demo-project --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
```

Podría aparecer un resultado como el siguiente en la salida:

```
{
  "ids": [
    "codebuild-demo-project:98253670-7a8a-4546-b908-dc890EXAMPLE"
    "codebuild-demo-project:ad5405b2-1ab3-44df-ae2d-fba84EXAMPLE"
    ... The full list of build IDs has been omitted for brevity ...
    "codebuild-demo-project:f721a282-380f-4b08-850a-e0ac1EXAMPLE"
  ]
}
```

## Ver una lista de compilaciones por lotes IDs para un proyecto de compilación (AWS CLI)
<a name="view-batch-builds-for-project-cli"></a>

Para obtener más información sobre el uso del AWS CLI with AWS CodeBuild, consulte la[Referencia de la línea de comandos](cmd-ref.md).

Ejecute el comando **list-build-batches-for-project** de la siguiente manera:

```
aws codebuild list-build-batches-for-project --project-name project-name --sort-order sort-order --next-token next-token
```

En el comando anterior, sustituya los siguientes marcadores de posición:
+ *project-name*: Cadena obligatoria que se utiliza para indicar el nombre del proyecto de compilación IDs para el que se van a enumerar las compilaciones. Para obtener una lista de proyectos de compilación, consulte [Ver una lista de nombres de proyectos de compilación (AWS CLI)](view-project-list.md#view-project-list-cli).
+ *sort-order*: Cadena opcional que se utiliza para indicar cómo enumerar la compilación IDs. Los valores válidos son `ASCENDING` y `DESCENDING`.
+ *next-token*: cadena opcional. Durante una ejecución anterior, si hubiera más de 100 elementos en la lista, solo se devolverían los 100 primeros, junto con una única cadena denominada *next token*. Para obtener el siguiente lote de elementos de la lista, ejecute de nuevo este comando añadiendo el siguiente token a la llamada. Para obtener todos los elementos de la lista, siga ejecutando el comando con cada uno de los siguientes tokens devueltos hasta que no se devuelvan más tokens.

Por ejemplo, si ejecuta un comando similar a este:

```
aws codebuild list-build-batches-for-project --project-name codebuild-demo-project --sort-order ASCENDING
```

Aparecerá un resultado como el siguiente en la salida:

```
{
  "nextToken": "4AEA6u7J...The full token has been omitted for brevity...MzY2OA==",
  "ids": [
    "codebuild-demo-project:9b175d16-66fd-4e71-93a0-50a08EXAMPLE"
    "codebuild-demo-project:a9d1bd09-18a2-456b-8a36-7d65aEXAMPLE"
    ... The full list of build IDs has been omitted for brevity ...
    "codebuild-demo-project:fe70d102-c04f-421a-9cfa-2dc15EXAMPLE"
  ]
}
```

Si ejecuta este comando de nuevo:

```
aws codebuild list-build-batches-for-project --project-name codebuild-demo-project --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
```

Podría aparecer un resultado como el siguiente en la salida:

```
{
  "ids": [
    "codebuild-demo-project:98253670-7a8a-4546-b908-dc890EXAMPLE"
    "codebuild-demo-project:ad5405b2-1ab3-44df-ae2d-fba84EXAMPLE"
    ... The full list of build IDs has been omitted for brevity ...
    "codebuild-demo-project:f721a282-380f-4b08-850a-e0ac1EXAMPLE"
  ]
}
```

## Ver una lista de compilaciones IDs para un proyecto de compilación (AWS SDKs)
<a name="view-builds-for-project-sdks"></a>

Para obtener más información sobre su uso AWS CodeBuild con AWS SDKs, consulte la[AWS SDKs y referencia de herramientas](sdk-ref.md).