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.
# Tutorial: Configurar un corredor CodeBuild-hosted GitLab
Este tutorial le muestra cómo configurar sus CodeBuild proyectos para ejecutar trabajos GitLab CI/CD en proceso. Para obtener más información sobre el uso GitLab o la GitLab autogestión con CodeBuild ella, consulte[Self-managed GitLab se ejecuta en AWS CodeBuild](gitlab-runner.md).
Para completar este tutorial, primero debe:
+ Conéctate con una aplicación OAuth mediante. CodeConnections Ten en cuenta que cuando te conectes con una app de OAuth, debes usar la CodeBuild consola para hacerlo. Para obtener instrucciones adicionales, consulte [GitLab accede 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 accede en CodeBuild](access-tokens-gitlab-overview.md).
**nota**
Esto solo debe hacerse 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 aplicación GitLab OAuth. Si existen CodeConnections para una GitLab cuenta en particular, no solicita 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
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**, elija **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 el código YAML de tu GitLab CI/CD canalización. 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
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 GitLab CI/CD canalización (YAML)
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-{{}}-$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 {{}} coincide con el nombre del proyecto en el que creó. CodeBuild Si no coincide, no CodeBuild procesará el webhook y es posible que la GitLab CI/CD canalización se bloquee.
El siguiente es un ejemplo de un GitLab CI/CD proceso YAML:
```
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 CodeBuild-hosted GitLab](sample-gitlab-runners-gitlab-ci.images.md) para ver una lista de imágenes seleccionadas. Para usar imágenes personalizadas, consulte [El corredor admite anulaciones de etiquetas CodeBuild-hosted GitLab](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-{{}}-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
- image:{{}}-{{}}
- instance-size:{{}}
```
El siguiente es un ejemplo de un YAML de GitLab CI/CD canalización:
```
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-{{}}-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
- fleet:{{}}
```
Para anular tanto la flota como la imagen utilizadas para la compilación, utilice la sintaxis siguiente:
```
tags:
- codebuild-{{}}-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
- fleet:{{}}
- image:{{}}-{{}}
```
El siguiente es un ejemplo de un YAML de GitLab CI/CD canalización:
```
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 tus trabajos de GitLab CI/CD canalización en una imagen personalizada, puedes configurar una imagen personalizada en tu 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 reemplazo 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\_BUILD y POST\_BUILD
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-{{}}-$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 la tarea de GitLab CI/CD canalización manualmente.
+ 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
Siempre que se ejecute una GitLab CI/CD canalización, CodeBuild recibirá los eventos de las tareas de CI/CD canalización a través del webhook. Para cada trabajo en CI/CD proceso, CodeBuild inicia una compilación para ejecutar un ejecutor efímero GitLab . El ejecutor es responsable de ejecutar un único trabajo de CI/CD canalización. 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
La siguiente YAML-formatted parte de una CloudFormation plantilla crea un grupo de filtros que activa una compilación cuando se evalúa como verdadera. El siguiente grupo de filtros especifica una solicitud de trabajo de GitLab CI/CD canalización con un nombre de 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\]
```