

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Tutoriel : Configuration d'un CodeBuild coureur hébergé GitLab
<a name="sample-gitlab-runners"></a>

Ce didacticiel explique comment configurer vos CodeBuild projets pour exécuter des tâches de pipeline GitLab CI/CD. Pour plus d'informations sur l'utilisation GitLab ou l' GitLab autogestion avec CodeBuild, consultez[GitLab Coureurs autogérés en AWS CodeBuild](gitlab-runner.md).<a name="sample-gitlab-runners-prerequisites"></a>

Pour effectuer ce didacticiel, vous devez d'abord :
+ Connectez-vous à une OAuth application en utilisant CodeConnections. Notez que lorsque vous vous connectez à une OAuth application, vous devez utiliser la CodeBuild console pour ce faire. Pour plus d’informations, consultez [GitLab accéder à CodeBuild](access-tokens-gitlab-overview.md).
+ Connectez-vous CodeBuild à votre GitLab compte. Pour ce faire, vous pouvez l'ajouter GitLab en tant que fournisseur de source dans la console. Pour obtenir des instructions, veuillez consulter [GitLab accéder à CodeBuild](access-tokens-gitlab-overview.md).
**Note**  
Cela ne doit être fait que si vous n'êtes pas connecté GitLab à votre compte.  
Cette fonctionnalité CodeBuild nécessite des autorisations supplémentaires, telles que `create_runner` et `manage_runner` depuis l' GitLab OAuth application. S'il en existe CodeConnections pour un GitLab compte en particulier, celui-ci ne demande pas automatiquement de mises à jour des autorisations. Pour ce faire, vous pouvez accéder à la CodeConnections console et créer une connexion fictive avec le même GitLab compte pour déclencher la réautorisation afin d'obtenir les autorisations supplémentaires. Ainsi, toutes les connexions existantes peuvent utiliser la fonction Runner. Une fois l'opération terminée, vous pouvez supprimer la connexion fictive.

## Étape 1 : Création d'un CodeBuild projet avec un webhook
<a name="sample-gitlab-runners-create-project"></a>

Au cours de cette étape, vous allez créer un CodeBuild projet avec un webhook et le passer en revue dans la GitLab console.

**Pour créer un CodeBuild projet avec un webhook**

1. Ouvrez la AWS CodeBuild console sur [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Créez un projet de génération. Pour plus d’informations, consultez [Création d'un projet de génération (console)](create-project.md#create-project-console) et [Exécution d'une génération (console)](run-build-console.md).

   Dans **Type de projet**, choisissez le **projet Runner**.
   +  Dans **Runner** : 
     + Pour le **fournisseur Runner**, choisissez **GitLab**.
     +  Pour **Credential**, sélectionnez l'une des options suivantes :
       + Choisissez les informations d'**identification de source par défaut**. La connexion par défaut applique une GitLab connexion par défaut à tous les projets.
       + Choisissez Informations d'**identification source personnalisées**. La connexion personnalisée applique une GitLab connexion personnalisée qui remplace les paramètres par défaut de votre compte.
**Note**  
Si vous n'avez pas encore créé de connexion avec votre fournisseur, vous devrez créer une nouvelle GitLab connexion. Pour obtenir des instructions, veuillez consulter [Connect CodeBuild à GitLab](access-tokens-gitlab-overview.md#connections-gitlab).
     + Pour l'**emplacement de Runner**, choisissez **Repository**.
     +  Pour **Repository**, choisissez le nom de votre projet en GitLab spécifiant le chemin du projet avec l'espace de noms.
   +  Dans **Environment (Environnement)** : 
     + Choisissez une **image d'environnement** compatible et **calculez**. Notez que vous avez la possibilité de remplacer les paramètres d'image et d'instance en utilisant une étiquette dans le YAML de votre pipeline GitLab CI/CD. Pour de plus amples informations, veuillez consulter [Étape 2 : Créez un fichier .gitlab-ci.yml dans votre dépôt](#sample-gitlab-runners-gitlab-ci).
   +  Dans **Buildspec**: 
     + Notez que votre spécification de construction sera ignorée à moins qu'elle ne `buildspec-override:true` soit ajoutée sous forme d'étiquette. Au lieu de cela, il le CodeBuild remplacera pour utiliser des commandes qui configureront le coureur autogéré.

1. Continuez avec les valeurs par défaut, puis choisissez **Create build project**.

1. Ouvrez la GitLab console sur `https://gitlab.com/user-name/repository-name/-/hooks` pour vérifier qu'un webhook a été créé et qu'il est activé pour diffuser des événements de **tâches Workflow**.

## Étape 2 : Créez un fichier .gitlab-ci.yml dans votre dépôt
<a name="sample-gitlab-runners-gitlab-ci"></a>

Au cours de cette étape, vous allez créer un `.gitlab-ci.yml` fichier dans lequel vous [https://gitlab.com/](https://gitlab.com/)allez configurer votre environnement de construction et utiliser des runners GitLab autogérés. CodeBuild Pour plus d'informations, consultez la section [Utiliser des coureurs autogérés](https://docs.gitlab.com/runner/#use-self-managed-runners).

### Mettez à jour votre pipeline GitLab CI/CD YAML
<a name="sample-gitlab-runners-update-yaml.setup"></a>

Accédez à votre référentiel `https://gitlab.com/user-name/project-name/-/tree/branch-name` et créez-en un`.gitlab-ci.yml`. Vous pouvez configurer votre environnement de génération en effectuant l'une des opérations suivantes :
+ Vous pouvez spécifier le nom du CodeBuild projet, auquel cas le build utilisera votre configuration de projet existante pour le calcul, l'image, la version de l'image et la taille de l'instance. Le nom du projet est nécessaire pour lier les AWS paramètres associés à votre GitLab tâche à un CodeBuild projet spécifique. En incluant le nom du projet dans le YAML, CodeBuild il est autorisé à invoquer des tâches avec les paramètres de projet corrects.

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

  `$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME`est nécessaire pour mapper la construction à des exécutions de tâches de pipeline spécifiques et arrêter la génération lorsque l'exécution du pipeline est annulée.
**Note**  
Assurez-vous que le nom du projet que vous avez créé *<project-name>* correspond à celui dans lequel vous l'avez créé CodeBuild. S'il ne correspond pas, le webhook ne CodeBuild sera pas traité et le pipeline GitLab CI/CD risque de se bloquer.

  Voici un exemple de pipeline GitLab CI/CD 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
  ```
+ Vous pouvez également remplacer votre image et le type de calcul dans la balise. Consultez [Calculer les images prises en charge par le logiciel CodeBuild -hosted runner GitLab](sample-gitlab-runners-gitlab-ci.images.md) la liste des images sélectionnées. Pour utiliser des images personnalisées, voir[Les remplacements d'étiquettes sont pris en charge par le CodeBuild coureur hébergé GitLab](gitlab-runners-update-labels.md). Le type de calcul et l'image contenus dans la balise remplaceront les paramètres d'environnement de votre projet. Pour remplacer les paramètres de votre environnement pour une version de calcul Amazon EC2, utilisez la syntaxe suivante :

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

  Voici un exemple de pipeline GitLab CI/CD YAML :

  ```
  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
  ```
+ Vous pouvez remplacer la flotte utilisée pour votre build dans le tag. Cela remplacera les paramètres de flotte configurés dans votre projet pour utiliser le parc spécifié. Pour de plus amples informations, veuillez consulter [Exécutez des builds sur des flottes à capacité réservée](fleets.md). Pour remplacer les paramètres de votre flotte pour une version de calcul Amazon EC2, utilisez la syntaxe suivante :

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

  Pour remplacer à la fois la flotte et l'image utilisées pour la génération, utilisez la syntaxe suivante :

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

  Voici un exemple de pipeline GitLab CI/CD YAML :

  ```
  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
  ```
+ Pour exécuter vos tâches de pipeline GitLab CI/CD sur une image personnalisée, vous pouvez configurer une image personnalisée dans votre CodeBuild projet et éviter de fournir une étiquette de remplacement d'image. CodeBuild utilisera l'image configurée dans le projet si aucune étiquette de remplacement d'image n'est fournie.

Une fois que vous aurez validé vos modifications`.gitlab-ci.yml`, un GitLab pipeline sera déclenché et une notification Webhook sera envoyée pour démarrer votre build in CodeBuild. `build-job`

### Exécutez les commandes buildspec pendant les phases INSTALL, PRE\$1BUILD et POST\$1BUILD
<a name="sample-gitlab-runners-update-yaml.buildspec"></a>

Par défaut, CodeBuild ignore les commandes buildspec lors de l'exécution d'une version autogérée. GitLab Pour exécuter les commandes buildspec pendant la construction, `buildspec-override:true` vous pouvez les ajouter en tant que suffixe à : `tags`

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

En utilisant cette commande, CodeBuild vous créerez un dossier appelé `gitlab-runner` dans le dossier source principal du conteneur. Lorsque le GitLab coureur démarre pendant la `BUILD` phase, il court dans le `gitlab-runner` répertoire.

L'utilisation d'une dérogation buildspec dans une version autogérée présente plusieurs limites : GitLab 
+ CodeBuild n'exécutera pas de commandes buildspec pendant la `BUILD` phase, car le lanceur autogéré s'exécute pendant la phase. `BUILD`
+ CodeBuild ne téléchargera aucune source principale ou secondaire pendant la `DOWNLOAD_SOURCE` phase. Si vous avez configuré un fichier buildspec, seul ce fichier sera téléchargé depuis la source principale du projet.
+ Si une commande de construction échoue pendant la `INSTALL` phase `PRE_BUILD` ou, elle ne CodeBuild démarrera pas le lanceur autogéré et la tâche du pipeline GitLab CI/CD devra être annulée manuellement.
+ CodeBuild récupère le jeton du coureur pendant la `DOWNLOAD_SOURCE` phase, dont le délai d'expiration est d'une heure. Si votre `PRE_BUILD` ou vos `INSTALL` phases dépassent une heure, le jeton de course peut expirer avant le départ du coureur GitLab autogéré.

## Étape 3 : Passez en revue vos résultats
<a name="sample-gitlab-runners-verify"></a>

Chaque fois qu'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 projet de pipeline est effectué. Une fois le travail terminé, le lanceur et le processus de construction associé seront immédiatement interrompus.

Pour consulter les journaux des tâches de votre CI/CD pipeline, accédez à votre référentiel GitLab, choisissez **Build**, **Jobs**, puis choisissez le **Job** spécifique dont vous souhaitez consulter les journaux.

Vous pouvez consulter les étiquettes demandées dans le journal pendant que le travail attend d'être récupéré par un coureur autogéré. CodeBuild

## Filtrer les événements du GitLab webhook ()CloudFormation
<a name="sample-gitlab-runners-webhooks-cfn"></a>

La partie suivante d'un CloudFormation modèle au format YAML crée un groupe de filtres qui déclenche une génération lorsqu'elle est évaluée à true. Le groupe de filtres suivant spécifie un nom de GitLab CI/CD pipeline job request with a CI/CD pipeline correspondant à l'expression régulière`\[CI-CodeBuild\]`.

```
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\]
```