

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.

# Ejecutores autogestionados GitLab en AWS CodeBuild
<a name="gitlab-runner"></a>

GitLab proporciona dos modos de ejecución para ejecutar las GitLab tareas en CI/CD proceso. Uno de los modos son los ejecutores GitLab hospedados, que son gestionados GitLab y totalmente integrados con GitLab ellos. El otro modo son los ejecutores autogestionados, que le permiten crear su propio entorno personalizado para ejecutar las tareas en proceso de GitLab CI/CD.

Los pasos básicos para configurar un CodeBuild proyecto para ejecutar tareas de canalización de GitLab CI/CD son los siguientes:

1. Si aún no lo ha hecho, conéctese con una OAuth aplicación a la que conectar su proyecto. GitLab

1. Ve a la CodeBuild consola y crea un CodeBuild proyecto con un webhook y configura tus filtros de webhook.

1. Actualiza tu canalización de GitLab CI/CD en YAML GitLab para configurar tu entorno de compilación.

Para obtener un procedimiento más detallado, consulte [Tutorial: Configurar un ejecutor hospedado CodeBuild GitLab](sample-gitlab-runners.md).

Esta función permite que sus trabajos de canalización de GitLab CI/CD se integren de forma nativa AWS, lo que proporciona seguridad y comodidad a través de funciones como IAM AWS CloudTrail y Amazon VPC. Puede acceder a los tipos de instancias más recientes, incluidas las basadas en ARM.

**Topics**
+ [Acerca del ejecutor alojado CodeBuild GitLab](gitlab-runner-questions.md)
+ [Tutorial: Configurar un ejecutor hospedado CodeBuild GitLab](sample-gitlab-runners.md)
+ [El ejecutor hospedado admite anulaciones CodeBuild de GitLab etiquetas](gitlab-runners-update-labels.md)
+ [Calcule las imágenes compatibles con el ejecutor alojado CodeBuild GitLab](sample-gitlab-runners-gitlab-ci.images.md)

# Acerca del ejecutor alojado CodeBuild GitLab
<a name="gitlab-runner-questions"></a>

Las siguientes son algunas preguntas frecuentes sobre el corredor CodeBuild hospedado GitLab.

## ¿Qué tipos de fuentes admiten los CodeBuild ejecutores alojados? GitLab
<a name="gitlab-runner-source"></a>

CodeBuild GitLab Los ejecutores alojados en -hosts son compatibles con el tipo de `GITLAB_SELF_MANAGED` fuente `GITLAB` y.

## ¿Cuándo debo incluir las anulaciones de instancias e imágenes en la etiqueta?
<a name="gitlab-runner-image-label"></a>

Puede incluir las modificaciones de imagen e instancia en la etiqueta para especificar un entorno de compilación diferente para cada uno de sus trabajos de canalización de GitLab CI/CD. Esto se puede hacer sin necesidad de crear varios CodeBuild proyectos o webhooks.

## ¿Puedo utilizarla CloudFormation para esta función?
<a name="gitlab-runner-cfn"></a>

Sí, puedes incluir un grupo de filtros en tu CloudFormation plantilla que especifique un filtro de eventos de trabajo GitLab de flujo de trabajo en el webhook de tu proyecto.

```
Triggers:
  Webhook: true
  FilterGroups:
    - - Type: EVENT
        Pattern: WORKFLOW_JOB_QUEUED
```

Para obtener más información, consulte [Filtrar eventos de GitLab webhook ()CloudFormation](gitlab-webhook-events-cfn.md).

Si necesitas ayuda para configurar las credenciales del proyecto en tu CloudFormation plantilla, consulta [AWS::CodeBuild::SourceCredential](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-sourcecredential.html)la *Guía del AWS CloudFormation usuario* para obtener más información.

## ¿Cómo puedo enmascarar los secretos al usar esta característica?
<a name="gitlab-runner-secrets"></a>

De forma predeterminada, los secretos que se imprimen en el registro no están enmascarados. Si desea ocultar sus secretos, puede hacerlo actualizando la configuración de las variables de CI/CD entorno:

**Para enmascarar secretos en GitLab**

1. En tu **GitLab configuración**, selecciona **CI/CD**.

1. En **Variables**, elija **Edit** para el secreto que quiere enmascarar.

1. En **Visibility**, seleccione **Mask variable** y, a continuación, elija **Update variable** para guardar los cambios.

## ¿Puedo recibir eventos de GitLab webhook de varios proyectos de un mismo grupo?
<a name="gitlab-runner-webhooks"></a>

CodeBuild admite webhooks grupales, que reciben eventos de un grupo específico GitLab . Para obtener más información, consulte [GitLab webhooks grupales](gitlab-group-webhook.md).

## ¿Puedo realizar un trabajo en el ejecutor de docker para el ejecutor autoadministrado? Por ejemplo, quiero ejecutar un trabajo de canalización en una imagen específica para mantener el mismo entorno de compilación en un contenedor separado y aislado.
<a name="gitlab-runner-custom-image"></a>

Puedes ejecutar el ejecutor GitLab autogestionado CodeBuild con una imagen específica [creando el proyecto con una imagen personalizada o [anulando la imagen](sample-gitlab-runners.md#sample-gitlab-runners-gitlab-ci)](create-project.md#environment-image.console) en tu archivo. `.gitlab-ci.yml`

## ¿Con qué ejecutor se ejecuta el ejecutor autogestionado? CodeBuild
<a name="gitlab-runner-shell-executor"></a>

El ejecutor autogestionado CodeBuild se ejecuta con el ejecutor del shell, donde la compilación se ejecuta localmente junto con el ejecutor GitLab que se ejecuta dentro del contenedor docker.

## ¿Puedo proporcionar comandos buildspec junto con el ejecutor autoadministrado?
<a name="gitlab-runner-buildspec-commands"></a>

Sí, se pueden agregar comandos buildspec junto con el ejecutor autoadministrado. **Puedes incluir el archivo buildspec.yml en tu GitLab repositorio y usar la `buildspec-override:true` etiqueta de la sección Etiquetas del trabajo.** 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).

## ¿Qué regiones admiten el uso de un ejecutor alojado? CodeBuild GitLab
<a name="gitlab-runner-hosted-regions"></a>

CodeBuild GitLab Los corredores alojados son compatibles en todas las CodeBuild regiones. 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/)

## ¿Qué plataformas admiten el uso de un CodeBuild ejecutor alojado GitLab ?
<a name="gitlab-runner-platform"></a>

CodeBuild GitLab -los ejecutores alojados son compatibles tanto con Amazon EC2 [AWS Lambda](lambda.md)como con Compute. Puede utilizar las siguientes plataformas: Amazon Linux 2, Amazon Linux 2023, Ubuntu y Windows Server Core 2019. Para obtener más información, consulte [Imágenes de computación de EC2](ec2-compute-images.md) y [Imágenes de computación de Lambda](lambda-compute-images.md).

# Tutorial: Configurar un ejecutor hospedado CodeBuild GitLab
<a name="sample-gitlab-runners"></a>

Este tutorial le muestra cómo configurar sus CodeBuild proyectos para ejecutar tareas de canalización de GitLab CI/CD. Para obtener más información sobre el uso GitLab o la GitLab autogestión con ella CodeBuild, consulte. [Ejecutores autogestionados GitLab en AWS CodeBuild](gitlab-runner.md)<a name="sample-gitlab-runners-prerequisites"></a>

Para completar este tutorial, primero debe:
+ Conéctese con una OAuth aplicación mediante CodeConnections. Ten en cuenta que cuando te conectes con una OAuth aplicación, debes usar la CodeBuild consola para hacerlo. Para obtener instrucciones adicionales, consulte [GitLab acceder en CodeBuild](access-tokens-gitlab-overview.md).
+ Conéctate CodeBuild a tu GitLab cuenta. Para ello, puedes añadirlo GitLab como proveedor de fuentes en la consola. Para obtener instrucciones, consulte [GitLab acceder en CodeBuild](access-tokens-gitlab-overview.md).
**nota**  
Esto solo es necesario si no te has conectado GitLab a tu cuenta.  
Con esta función, CodeBuild necesita permisos adicionales, como `create_runner` y `manage_runner` desde la GitLab OAuth aplicación. Si existen CodeConnections para una GitLab cuenta en particular, no solicitará automáticamente las actualizaciones de permisos. Para ello, puedes ir a la CodeConnections consola y crear una conexión ficticia con la misma GitLab cuenta para activar la reautorización y obtener los permisos adicionales. De esta forma, todas las conexiones existentes pueden utilizar la característica del ejecutor. Una vez que se finalice, puede eliminar la conexión ficticia.

## Paso 1: Crea un CodeBuild proyecto con un webhook
<a name="sample-gitlab-runners-create-project"></a>

En este paso, crearás un CodeBuild proyecto con un webhook y lo revisarás en la GitLab consola.

**Para crear un CodeBuild proyecto con un webhook**

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

1. Cree un proyecto de compilación. 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 **Tipo de proyecto**, seleccione **Proyecto de ejecutor**.
   +  En **Ejecutor**: 
     + Para el **proveedor Runner**, selecciona. **GitLab**
     +  En **Credencial**, elija una de las opciones siguientes:
       + Elija **Credencial de origen predeterminada**. La conexión predeterminada aplica una GitLab conexión predeterminada en todos los proyectos.
       + Elija **Credencial de origen personalizada**. La conexión personalizada aplica una GitLab conexión personalizada que anula la configuración predeterminada de tu cuenta.
**nota**  
Si aún no has creado una conexión con tu proveedor, tendrás que crear una nueva GitLab . Para obtener instrucciones, consulte [Conectarse CodeBuild a GitLab](access-tokens-gitlab-overview.md#connections-gitlab).
     + En **Ubicación del ejecutor**, seleccione **Repositorio**.
     +  En **Repositorio**, elija el nombre de su proyecto GitLab especificando la ruta del proyecto con el espacio de nombres.
   +  En **Environment (Entorno)**: 
     + Elija una **Imagen del entorno** y una **Computación** compatibles. Ten en cuenta que tienes la opción de anular la configuración de la imagen y la instancia mediante una etiqueta en tu canalización de GitLab CI/CD (YAML). Para obtener más información, consulte [Paso 2: creación de un archivo .gitlab-ci.yml en el repositorio](#sample-gitlab-runners-gitlab-ci).
   +  En **Buildspec**: 
     + Tenga en cuenta que su especificación de compilación se ignorará a menos que se agregue `buildspec-override:true` como etiqueta. En su lugar, la CodeBuild anulará para usar comandos que configurarán el ejecutor autogestionado.

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

1. Abre la GitLab consola en `https://gitlab.com/user-name/repository-name/-/hooks` para comprobar que se ha creado un webhook y que está habilitado para entregar eventos de **Workflow** Jobs.

## Paso 2: creación de un archivo .gitlab-ci.yml en el repositorio
<a name="sample-gitlab-runners-gitlab-ci"></a>

En este paso, crearás un `.gitlab-ci.yml` archivo [https://gitlab.com/](https://gitlab.com/)para configurar tu entorno de compilación y utilizar ejecutores GitLab autogestionados en él. CodeBuild Para obtener más información, consulte [Use self-managed runners](https://docs.gitlab.com/runner/#use-self-managed-runners).

### Actualiza tu canalización de GitLab CI/CD (YAML)
<a name="sample-gitlab-runners-update-yaml.setup"></a>

Desplácese a `https://gitlab.com/user-name/project-name/-/tree/branch-name` y cree un archivo `.gitlab-ci.yml` en su repositorio. Para configurar el entorno de compilación, realice una de las siguientes acciones:
+ Puedes especificar el nombre del CodeBuild proyecto, en cuyo caso la compilación utilizará la configuración de proyecto existente para el cálculo, la imagen, la versión de la imagen y el tamaño de la instancia. El nombre del proyecto es necesario para vincular la configuración AWS relacionada de tu GitLab trabajo a un CodeBuild proyecto específico. Al incluir el nombre del proyecto en el YAML, CodeBuild se pueden invocar trabajos con la configuración de proyecto correcta.

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
  ```

  `$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME` es necesario para asignar la compilación a ejecuciones específicas de trabajos de canalización y detener la compilación cuando se cancele la ejecución de la canalización.
**nota**  
Asegúrese de que *<project-name>* coincide con el nombre del proyecto en el que creó. CodeBuild Si no coincide, no CodeBuild procesará el webhook y la canalización de GitLab CI/CD podría bloquearse.

  El siguiente es un ejemplo de una canalización YAML de GitLab CI/CD:

  ```
  workflow:
    name: HelloWorld
  stages:          # List of stages for jobs, and their order of execution
    - build
  
  build-job:       # This job runs in the build stage, which runs first.
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
  ```
+ También puede anular el tipo de computación e imagen en la etiqueta. Consulte [Calcule las imágenes compatibles con el ejecutor alojado CodeBuild GitLab](sample-gitlab-runners-gitlab-ci.images.md) para ver una lista de imágenes seleccionadas. Para usar imágenes personalizadas, consulte [El ejecutor hospedado admite anulaciones CodeBuild de GitLab etiquetas](gitlab-runners-update-labels.md). El tipo de computación y la imagen de la etiqueta anularán la configuración del entorno en el proyecto. Si quiere anular la configuración del entorno para una compilación de computación de Amazon EC2, utilice la sintaxis siguiente:

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - image:<environment-type>-<image-identifier>
      - instance-size:<instance-size>
  ```

  El siguiente es un ejemplo de una canalización YAML de GitLab CI/CD:

  ```
  stages:
    - build
  
  build-job:
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - image:arm-3.0
      - instance-size:small
  ```
+ Puede anular la flota utilizada para su compilación en la etiqueta. Al hacerlo, se anularán los valores de flota configurados en el proyecto para usar la flota especificada. Para obtener más información, consulte [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md). Si quiere anular la configuración de la flota para una compilación de computación de Amazon EC2, utilice la siguiente sintaxis:

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:<fleet-name>
  ```

  Para anular tanto la flota como la imagen utilizadas para la compilación, utilice la sintaxis siguiente:

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:<fleet-name>                    
      - image:<environment-type>-<image-identifier>
  ```

  El siguiente es un ejemplo de una canalización YAML de GitLab CI/CD:

  ```
  stages:
    - build
  
  build-job:
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:myFleet
      - image:arm-3.0
  ```
+ Para ejecutar sus trabajos de canalización de GitLab CI/CD en una imagen personalizada, puede configurar una imagen personalizada en su CodeBuild proyecto y evitar tener que incluir una etiqueta de anulación de imagen. CodeBuild utilizará la imagen configurada en el proyecto si no se proporciona una etiqueta de anulación de imagen.

Cuando confirmes los cambios`.gitlab-ci.yml`, se activará una GitLab canalización y se `build-job` enviará una notificación de webhook para iniciar la compilación. CodeBuild

### Ejecución de comandos buildspec durante las fases INSTALL, PRE\$1BUILD y POST\$1BUILD
<a name="sample-gitlab-runners-update-yaml.buildspec"></a>

De forma predeterminada, CodeBuild ignora cualquier comando de buildspec al ejecutar una compilación autogestionada. GitLab Para ejecutar comandos buildspec durante la compilación, se puede agregar `buildspec-override:true` como sufijo a `tags`:

```
tags:
    - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
    - buildspec-override:true
```

Al usar este comando, CodeBuild se creará una carpeta llamada carpeta de origen `gitlab-runner` principal del contenedor. Cuando el GitLab ejecutor se inicie durante la `BUILD` fase, se ejecutará en el `gitlab-runner` directorio.

Existen varias limitaciones a la hora de utilizar una modificación de las especificaciones de compilación en una compilación autogestionada: GitLab 
+ CodeBuild no ejecutará los comandos buildspec durante la fase, ya que el ejecutor autogestionado se ejecuta en la `BUILD` fase. `BUILD`
+ CodeBuild no descargará ninguna fuente primaria o secundaria durante la fase. `DOWNLOAD_SOURCE` Si ha configurado un archivo buildspec, solo se descargará ese archivo del origen principal del proyecto.
+ Si un comando de compilación falla en la `INSTALL` fase `PRE_BUILD` o, no CodeBuild se iniciará el ejecutor autogestionado y será necesario cancelar GitLab manualmente la tarea de canalización de CI/CD.
+ CodeBuild obtiene el token del corredor durante la `DOWNLOAD_SOURCE` fase, que tiene un tiempo de caducidad de una hora. Si tus `PRE_BUILD` `INSTALL` fases superan una hora, el token de corredor puede caducar antes de que comience el corredor GitLab autogestionado.

## Paso 3: revisión de los resultados
<a name="sample-gitlab-runners-verify"></a>

Siempre que se trate de un GitLab CI/CD pipeline run occurs, CodeBuild would receive the CI/CD pipeline job events through the webhook. For each job in the CI/CD pipeline, CodeBuild starts a build to run an ephemeral GitLab runner. The runner is responsible for executing a single CI/CD trabajo en proceso. Una vez que se complete el trabajo, el ejecutor y el proceso de compilación asociado finalizarán de forma inmediata.

Para ver los registros CI/CD de tus trabajos en proceso, navega hasta tu repositorio GitLab, selecciona **Build**, **Jobs** y, a continuación, elige el **trabajo** específico para el que quieres revisar los registros.

Puedes revisar las etiquetas solicitadas en el registro mientras el trabajo está esperando a que lo recoja una persona autogestionada CodeBuild.

## Filtra los eventos de los GitLab webhooks ()CloudFormation
<a name="sample-gitlab-runners-webhooks-cfn"></a>

La siguiente parte de una plantilla de CloudFormation con formato YAML crea un grupo de filtros que desencadena una compilación cuando se evalúa como true. El siguiente grupo de filtros especifica un nombre de GitLab CI/CD pipeline job request with a CI/CD canalización que coincide con la expresión `\[CI-CodeBuild\]` regular.

```
CodeBuildProject:
  Type: AWS::CodeBuild::Project
  Properties:
    Name: MyProject
    ServiceRole: service-role
    Artifacts:
      Type: NO_ARTIFACTS
    Environment:
      Type: LINUX_CONTAINER
      ComputeType: BUILD_GENERAL1_SMALL
      Image: aws/codebuild/standard:5.0
    Source:
      Type: GITLAB
      Location: CODEBUILD_DEFAULT_WEBHOOK_SOURCE_LOCATION
    Triggers:
      Webhook: true
      ScopeConfiguration:
        Name: group-name
        Scope: GITLAB_GROUP
      FilterGroups:
        - - Type: EVENT
            Pattern: WORKFLOW_JOB_QUEUED
          - Type: WORKFLOW_NAME
            Pattern: \[CI-CodeBuild\]
```

# El ejecutor hospedado admite anulaciones CodeBuild de GitLab etiquetas
<a name="gitlab-runners-update-labels"></a>

En el YAML de tu canalización de GitLab CI/CD, puedes incluir una variedad de sustituciones de etiquetas que modifiquen la versión autogestionada de los ejecutores. Se ignorarán todas las compilaciones no reconocidas por CodeBuild , pero no rechazarán tu solicitud de webhook. Por ejemplo, el siguiente YAML incluye anulaciones para la imagen, el tamaño de la instancia, la flota y la especificación de compilación:

```
workflow:
  name: HelloWorld
stages:
  - build

build-job:
  stage: build
  script:
    - echo "Hello World!"
  tags:
    - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
    - image:arm-3.0
    - instance-size:small
    - fleet:myFleet
    - buildspec-override:true
```

`codebuild-<project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME` (obligatorio)
+ Ejemplo: `codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME`
+ Necesario para todas las canalizaciones de GitLab CI/CD. YAMLs *<project name>*debe ser igual al nombre del proyecto para el que está configurado el webhook del ejecutor autogestionado.

`image:<environment-type>-<image-identifier>`
+ Ejemplo: `image:arm-3.0`
+ Anula la imagen y el tipo de entorno utilizados al iniciar la compilación del ejecutor autoadministrado. Para obtener más información sobre los valores admitidos, consulte [Calcule las imágenes compatibles con el ejecutor alojado CodeBuild GitLab](sample-gitlab-runners-gitlab-ci.images.md).
  + Para anular la imagen y el tipo de entorno utilizados con una imagen personalizada, utilice `image:custom-<environment-type>-<custom-image-identifier>`
  + Ejemplo: `image:custom-arm-public.ecr.aws/codebuild/amazonlinux-aarch64-standard:3.0`
**nota**  
Si la imagen personalizada se encuentra en un registro privado, consulte [Configuración de una credencial de registro privada para ejecutores autoalojados](private-registry-sample-configure-runners.md).

`instance-size:<instance-size>`
+ Ejemplo: `instance-size:small`
+ Anula el tipo de instancia utilizado al iniciar la compilación del ejecutor autoadministrado. Para obtener más información sobre los valores admitidos, consulte [Calcule las imágenes compatibles con el ejecutor alojado CodeBuild GitLab](sample-gitlab-runners-gitlab-ci.images.md).

`fleet:<fleet-name>`
+ Ejemplo: `fleet:myFleet`
+ Anula la configuración de flota establecida en el proyecto para usar la flota especificada. Para obtener más información, consulte [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md).

`buildspec-override:<boolean>`
+ Ejemplo: `buildspec-override:true`
+ Permite que la compilación ejecute comandos buildspec en las fases `INSTALL`, `PRE_BUILD` y `POST_BUILD` si está establecido en `true`.

# Calcule las imágenes compatibles con el ejecutor alojado CodeBuild GitLab
<a name="sample-gitlab-runners-gitlab-ci.images"></a>

En la etiqueta que configuró[Tutorial: Configurar un ejecutor hospedado CodeBuild GitLab](sample-gitlab-runners.md), puede anular la configuración del entorno de Amazon EC2 utilizando los valores de las tres primeras columnas. CodeBuild proporciona las siguientes imágenes informáticas de Amazon EC2. Para obtener más información acerca de 

<a name="build-env-ref.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/sample-gitlab-runners-gitlab-ci.images.html)

Además, puede anular la configuración del entorno de Lambda mediante los siguientes valores. Para obtener más información sobre la computación CodeBuild Lambda, consulte. [Ejecute compilaciones en el AWS Lambda cómputo](lambda.md) CodeBuild admite las siguientes imágenes de procesamiento Lambda:

<a name="lambda.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/sample-gitlab-runners-gitlab-ci.images.html)

Para obtener más información, consulte [Modos y tipos de computación del entorno de compilación](build-env-ref-compute-types.md) y [Imágenes de Docker proporcionadas por CodeBuild](build-env-ref-available.md).