

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.

# S'intègre AWS CodeBuild
<a name="builds-working"></a>

Une *construction* représente un ensemble d'actions effectuées AWS CodeBuild pour créer des artefacts de sortie (par exemple, un fichier JAR) sur la base d'un ensemble d'artefacts d'entrée (par exemple, une collection de fichiers de classe Java).

Les règles suivantes s'appliquent lorsque vous exécutez plusieurs builds :
+ Les builds s'exécutent simultanément, lorsque possible. Le nombre maximal de versions en cours d'exécution simultanée peut varier. Pour de plus amples informations, veuillez consulter [Quotas pour AWS CodeBuild](limits.md). 
+ Si le projet de génération possède une limite de génération simultanée définie, les versions renvoient une erreur si le nombre de versions en cours atteint la limite de génération simultanée pour le projet. Pour plus d'informations, voir [Activer la limite de génération simultanée](create-project.md#enable-concurrent-build-limit.console).
+ Si aucune limite de génération simultanée n'est définie pour le projet de génération, les versions sont mises en file d'attente si le nombre de versions en cours atteint la limite de génération simultanée pour la plate-forme et le type de calcul. Le nombre maximal de builds dans une file d'attente est à cinq fois la limite des builds simultanés. Pour de plus amples informations, veuillez consulter [Quotas pour AWS CodeBuild](limits.md).

  Un build dans une file d'attente qui ne démarre pas après le nombre de minutes spécifié dans sa valeur d'expiration est supprimé de la file d'attente. La valeur de délai d'expiration par défaut est de huit heures. Vous pouvez remplacer le délai de mise en file d'attente de génération par une valeur comprise entre cinq minutes et huit heures lorsque vous exécutez votre build. Pour de plus amples informations, veuillez consulter [Exécuter AWS CodeBuild les builds manuellement](run-build.md).

  Il n'est pas possible de prédire l'ordre dans lequel les builds mis en attente démarrent. 

**Note**  
Vous pouvez accéder à l'historique d'une génération pour une durée d'un an.

Vous pouvez effectuer ces tâches lorsque vous gérez des générations :

**Topics**
+ [Exécuter AWS CodeBuild les builds manuellement](run-build.md)
+ [Exécuter des builds sur AWS Lambda ordinateur](lambda.md)
+ [Exécutez des builds sur des flottes à capacité réservée](fleets.md)
+ [Exécuter des builds par lots](batch-build.md)
+ [Exécuter des tests parallèles dans des builds par lots](parallel-test.md)
+ [Des mises en cache pour améliorer les performances](build-caching.md)
+ [Debug s'intègre AWS CodeBuild](debug-builds.md)
+ [Supprimer les builds AWS CodeBuild](delete-builds.md)
+ [Réessayer les builds manuellement AWS CodeBuild](retry-build.md)
+ [Retry s'intègre automatiquement AWS CodeBuild](auto-retry-build.md)
+ [Arrêter les intégrations AWS CodeBuild](stop-build.md)
+ [Arrêter les compilations par lots AWS CodeBuild](stop-batch-build.md)
+ [Le déclencheur AWS CodeBuild se construit automatiquement](build-triggers.md)
+ [Afficher les détails du build dans AWS CodeBuild](view-build-details.md)
+ [Afficher la liste des éléments IDs intégrés AWS CodeBuild](view-build-list.md)
+ [Afficher la liste des versions IDs d'un projet de construction dans AWS CodeBuild](view-builds-for-project.md)

# Exécuter AWS CodeBuild les builds manuellement
<a name="run-build"></a>

Vous pouvez utiliser la AWS CodeBuild AWS CLI console ou AWS SDKs exécuter une intégration CodeBuild.

**Topics**
+ [Exécutez les builds localement avec l' AWS CodeBuild agent](use-codebuild-agent.md)
+ [Exécution d'une génération (console)](run-build-console.md)
+ [Exécution d'une génération (AWS CLI)](run-build-cli.md)
+ [Exécuter une compilation par lots (AWS CLI)](run-batch-build-cli.md)
+ [Lancement automatique de l'exécution de générations (AWS CLI)](run-build-cli-auto-start.md)
+ [Arrêt automatique de l'exécution de générations (AWS CLI)](run-build-cli-auto-stop.md)
+ [Exécution d'une génération (AWS SDKs)](run-build-sdks.md)

# Exécutez les builds localement avec l' AWS CodeBuild agent
<a name="use-codebuild-agent"></a>

Vous pouvez utiliser l' AWS CodeBuild agent pour exécuter CodeBuild des builds sur une machine locale. Des agents sont disponibles pour les plateformes x86\$164 et ARM.

Vous pouvez également vous abonner pour recevoir des notifications lorsque de nouvelles versions de l'agent sont publiées. 

## Conditions préalables
<a name="use-codebuild-agent.prerequisites"></a>

Avant de commencer, vous devez effectuer les opérations suivantes :
+ Installez Git sur votre machine locale.
+ Installez et configurez [Docker](https://www.docker.com/) sur votre machine locale.

## Configurer l'image de construction
<a name="use-codebuild-agent.setup-image"></a>

Vous devez uniquement configurer l'image de construction lors de la première exécution de l'agent ou lorsque l'image a changé.

**Pour configurer l'image de construction**

1. [Si vous souhaitez utiliser une image Amazon Linux 2 sélectionnée, vous pouvez l'extraire du référentiel CodeBuild public Amazon ECR à l'adresse https://gallery.ecr. aws/codebuild/amazonlinux-x86\$164-standard](https://gallery.ecr.aws/codebuild/amazonlinux-x86_64-standard) avec la commande suivante :

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

   Sinon, si vous souhaitez utiliser une autre image Linux, effectuez les opérations suivantes :

   1. Clonez le dépôt CodeBuild d'images :

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

   1. Accédez au répertoire des images. Pour cet exemple, utilisez l'`aws/codebuild/standard:5.0`image :

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

   1. Construisez l'image. Cela peut prendre plusieurs minutes. 

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

1. Téléchargez l' CodeBuild agent.

   Pour télécharger la version x86\$164 de l'agent, exécutez la commande suivante :

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

   Pour télécharger la version ARM de l'agent, exécutez la commande suivante :

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

1. <a name="codebuild-agent-sha"></a>L' CodeBuild agent est disponible à l'[adresse https://gallery.ecr. aws/codebuild/local-construit](https://gallery.ecr.aws/codebuild/local-builds). 

   La signature SHA (Secure Hash Algorithm) pour la version x86\$164 de l'agent est la suivante :

   ```
   sha256:ccb19bdd7af94e4dc761e4c58c267e9455c28ec68d938086b4dc1cf8fe6b0940
   ```

   La signature SHA pour la version ARM de l'agent est la suivante :

   ```
   sha256:7d7b5d35d2ac4e062ae7ba8c662ffed15229a52d09bd0d664a7816c439679192
   ```

   Vous pouvez utiliser le SHA pour identifier la version de l'agent. Pour voir la signature SHA de l'agent, exécutez la commande suivante et recherchez le SHA sous `RepoDigests` : 

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

## Exécutez l' CodeBuild agent
<a name="use-codebuild-agent.run-agent"></a>

**Pour exécuter l' CodeBuild agent**

1. Accédez au répertoire qui contient la source de votre projet de compilation.

1. Téléchargez le 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. Exécutez le `codebuild_build.sh` script et spécifiez votre image de conteneur et le répertoire de sortie.

   Pour exécuter une version x86\$164, exécutez la commande suivante :

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

   Pour exécuter une version ARM, exécutez la commande suivante :

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

   Remplacez *<container-image>* par le nom de l'image du conteneur, tel que `aws/codebuild/standard:5.0` ou`public.ecr.aws/codebuild/amazonlinux-x86_64-standard:4.0`.

   Le script lance l'image de construction et exécute la construction sur le projet dans le répertoire en cours. Pour spécifier l'emplacement du projet de génération, ajoutez l'`-s <build project directory>`option à la commande de script.

## Recevez des notifications pour les nouvelles versions de CodeBuild l'agent
<a name="receive-codebuild-agent-notifications"></a>

Vous pouvez vous abonner aux notifications Amazon SNS afin d'être averti lorsque de nouvelles versions de l' AWS CodeBuild agent sont publiées. 

**Pour vous abonner aux notifications des CodeBuild agents**

1. [Ouvrez la console Amazon SNS à l'adresse v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home) 

1. Dans la barre de navigation, si ce n'est pas déjà fait, remplacez la AWS région par **USA Est (Virginie du Nord)**. Vous devez sélectionner cette AWS région car les notifications Amazon SNS auxquelles vous vous abonnez sont créées dans cette région. 

1. Dans le panneau de navigation, sélectionnez **Abonnements**. 

1. Sélectionnez **Créer un abonnement**. 

1. Dans **Créer un abonnement**, procédez comme suit : 

   1. Pour **ARN de la rubrique**, utilisez l’Amazon Resource Name (ARN) suivant : 

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

   1. Pour **Protocol (Protocole)**, choisissez **Email (E-mail)** ou **SMS**. 

   1. Pour **Endpoint (Point de terminaison)**, choisissez où recevoir les notifications (e-mail ou SMS). Saisissez une adresse e-mail, une adresse ou un numéro de téléphone, y compris l'indicatif régional. 

   1. Choisissez **Créer un abonnement**. 

   1. Choisissez **E-mail** pour recevoir un e-mail vous demandant de confirmer votre inscription. Suivez les instructions dans l'e-mail pour finaliser votre abonnement. 

      Si vous ne souhaitez plus recevoir ces notifications, exécutez la procédure suivante pour annuler votre abonnement. 

**Pour vous désabonner des notifications des CodeBuild agents**

1. [Ouvrez la console Amazon SNS à l'adresse v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home) 

1. Dans le panneau de navigation, sélectionnez **Abonnements**. 

1. Sélectionnez l'abonnement, puis sous **Actions**, choisissez **Delete subscriptions (Supprimer des abonnements)**. Lorsque vous êtes invité à confirmer, choisissez **Delete**. 

# Exécution d'une génération (console)
<a name="run-build-console"></a>

À utiliser AWS CodePipeline pour exécuter une compilation avec CodeBuild, ignorez ces étapes et suivez les instructions indiquées dans[À utiliser CodeBuild avec CodePipeline](how-to-create-pipeline.md).

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

1. Dans le volet de navigation, choisissez **Projets de génération**.

1. Dans la liste des projets de construction, choisissez le projet de construction.

1. Vous pouvez exécuter le build avec les paramètres de projet de build par défaut, ou remplacer les paramètres de build pour ce build uniquement.

   1. Si vous souhaitez exécuter le build avec les paramètres de projet de build par défaut, choisissez **Start build**. La construction démarre immédiatement.

   1. Si vous souhaitez remplacer les paramètres par défaut du projet de construction, choisissez **Commencer la construction avec des remplacements**. Sur la page **Démarrer la création**, vous pouvez remplacer les éléments suivants :
      + **Configuration de construction**
      + **Source**
      + **Dérogations de variables d'environnement**

      Si vous devez sélectionner des remplacements plus avancés, choisissez **Advanced build overrides**. Dans cette page, vous pouvez annuler les éléments suivants :
      + **Configuration de construction**
      + **Source**
      + **Environnement**
      + **Spécifications de construction**
      + **Artefacts**
      + **Journaux**

      Lorsque vous avez effectué vos sélections de remplacement, choisissez **Start build**.

Pour de plus amples informations sur cette génération, consultez [Affichage des détails d'une génération (console)](view-build-details.md#view-build-details-console).

# Exécution d'une génération (AWS CLI)
<a name="run-build-cli"></a>

**Note**  
À utiliser CodePipeline pour exécuter une compilation avec AWS CodeBuild, ignorez ces étapes et suivez les instructions indiquées dans[Créez un pipeline qui utilise CodeBuild (AWS CLI)](how-to-create-pipeline-cli.md).  
Pour plus d'informations sur l'utilisation du AWS CLI with CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).

1. Exécutez la commande `start-build` de l'une des manières suivantes :

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

   Utilisez cette commande si vous souhaitez exécuter une génération utilisant la dernière version de l'artefact d'entrée de génération et les paramètres existants du projet de génération.

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

   Utilisez cette commande si vous souhaitez exécuter une génération avec une version précédente de l'artefact d'entrée de génération, ou si vous souhaitez remplacer les paramètres pour les artefacts de sortie, les variables d'environnement, le fichier buildspec ou le délai d'expiration de génération par défaut.

1. Si vous exécutez la **start-build** commande avec l'`--project-name`option, *<project-name>* remplacez-la par le nom du projet de génération, puis passez à l'étape 6 de cette procédure. Pour obtenir une liste de projets de génération, consultez [Afficher les noms des projets de construction](view-project-list.md).

1. Si vous exécutez la **start-build** commande avec l'`--idempotency-token`option, un identifiant ou un jeton unique distinguant majuscules et minuscules est inclus dans la `start-build` demande. Le jeton est valide pendant 5 minutes après la demande . Si vous répétez la `start-build` demande avec le même jeton, mais que vous modifiez un paramètre, CodeBuild renvoie une erreur de non-concordance des paramètres.

1. Si vous exécutez la commande **start-build** avec l'option `--generate-cli-skeleton`, des données au format JSON apparaissent dans la sortie. Copiez les données dans un fichier (par exemple,`start-build.json`) à un emplacement de l'ordinateur local ou de l'instance sur laquelle le AWS CLI est installé. Modifiez les données copiées pour qu'elles correspondent au format suivant, et enregistrez vos résultats :

   ```
   {
     "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"
   }
   ```

   Remplacez les espaces réservés suivants :
   + *projectName*: chaîne obligatoire. Nom du projet de génération à utiliser pour la génération. 
   + *sourceVersion*: chaîne facultative. Une version du code source à générer, comme suit :
     + Pour Amazon S3, l'ID de version qui correspond à la version du fichier ZIP d'entrée que vous souhaitez créer. Si *sourceVersion* ce n'est pas spécifié, c'est la dernière version qui est utilisée.
     + Pour CodeCommit, l'ID de validation qui correspond à la version du code source que vous souhaitez créer. S'il n'*sourceVersion*est pas spécifié, l'ID de validation HEAD de la branche par défaut est utilisé. (Vous ne pouvez pas spécifier de nom de balise pour*sourceVersion*, mais vous pouvez spécifier l'ID de validation de la balise.)
     + Pour GitHub, l'ID de validation, l'ID de pull request, le nom de branche ou le nom de balise correspondant à la version du code source que vous souhaitez créer. Si un ID de demande d'extraction est spécifié, il doit utiliser le format `pr/pull-request-ID` (par exemple, `pr/25`). Si un nom de branche est spécifié, l'ID de validation HEAD de la branche est utilisé. S'il n'*sourceVersion*est pas spécifié, l'ID de validation HEAD de la branche par défaut est utilisé. 
     + Pour Bitbucket, l'ID de validation, le nom de branche ou le nom de balise qui correspond à la version du code source à générer. Si un nom de branche est spécifié, l'ID de validation HEAD de la branche est utilisé. S'il n'*sourceVersion*est pas spécifié, l'ID de validation HEAD de la branche par défaut est utilisé. 
   + Les espaces réservés suivants sont pour `artifactsOverride`.
     + *type* - Facultatif. Type d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
     + *location* - Facultatif. Emplacement d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
     + *path* - Facultatif. Chemin d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
     + *namespaceType* - Facultatif. Type de chemin d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
     + *name* - Facultatif. Nom d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
     + *packaging* - Facultatif. Type de packaging d'artefact de sortie de génération qui remplace pour cette génération celui défini dans le projet de génération.
   + *buildspecOverride* - Facultatif. Déclaration de spécification de génération (buildspec) qui remplace pour cette génération celle définie dans le projet de génération. Si cette valeur est définie, il peut s'agir d'une définition de spécification de génération en ligne, du chemin vers un fichier buildspec alternatif, relatif à la valeur de la variable d'environnement `CODEBUILD_SRC_DIR` intégrée, ou du chemin vers un compartiment S3. Le compartiment S3 doit être dans la même région AWS que le projet de génération. Spécifiez le fichier buildspec à l'aide de son nom ARN (par exemple, `arn:aws:s3:::<my-codebuild-sample2>/buildspec.yml`). Si cette valeur n'est pas fournie ou qu'elle est définie sur une chaîne vide, le code source doit contenir un fichier `buildspec.yml` dans son répertoire racine. Pour de plus amples informations, veuillez consulter [Nom de fichier buildspec et emplacement de stockage](build-spec-ref.md#build-spec-ref-name-storage).
   + Les espaces réservés suivants sont pour `cacheOverride`.
     + *cacheOverride-location* - Facultatif. Emplacement d'un objet `ProjectCache` pour cette génération qui remplace l'objet `ProjectCache` spécifié dans le projet de génération. `cacheOverride` est facultatif et accepte un objet `ProjectCache`. `location` est obligatoire dans un objet `ProjectCache`.
     + *cacheOverride-type* - Facultatif. Type d'un objet `ProjectCache` pour cette génération qui remplace l'objet `ProjectCache` spécifié dans le projet de génération. `cacheOverride` est facultatif et accepte un objet `ProjectCache`. `type` est obligatoire dans un objet `ProjectCache`.
   + *certificateOverride* - Facultatif. Nom d'un certificat pour cette génération qui remplace celui spécifié dans le projet de génération.
   + *environmentTypeOverride* - Facultatif. Type de conteneur pour cette génération qui remplace celui spécifié dans le projet de génération. La chaîne valide actuelle est `LINUX_CONTAINER`.
   + Les espaces réservés suivants sont pour `environmentVariablesOverride`.
     + *environmentVariablesOverride-name* - Facultatif. Nom d'une variable d'environnement dans le projet de génération dont vous voulez substituer la valeur pour cette génération.
     + *environmentVariablesOverride-type* - Facultatif. Type de variable d'environnement dans le projet de génération dont vous voulez substituer la valeur pour cette génération.
     + *environmentVariablesValue* - Facultatif. Valeur de la variable d'environnement définie dans le projet de génération que vous voulez substituer pour cette génération.
   + *gitCloneDepthOverride* - Facultatif. Valeur de **Git clone depth** dans le projet de génération dont vous voulez remplacer la valeur pour cette génération. Si votre type de source est Amazon S3, cette valeur n'est pas prise en charge.
   + *imageOverride* - Facultatif. Nom d'une image pour cette génération qui remplace celle spécifiée dans le projet de génération.
   + *idempotencyToken* - Facultatif. Chaîne qui tient lieu de jeton pour spécifier que la demande de génération est idempotente. Vous pouvez choisir n'importe quelle chaîne de 64 caractères maximum. Le jeton est valide pendant 5 minutes après la demande de démarrage de la construction. Si vous répétez la demande de démarrage de la construction avec le même jeton, mais que vous modifiez un paramètre, cela CodeBuild renvoie une erreur de non-concordance des paramètres. 
   + *insecureSslOverride*: booléen facultatif qui indique s'il faut remplacer le paramètre TLS non sécurisé spécifié dans le projet de génération. Le paramètre TLS non sécurisé détermine s'il convient d'ignorer les avertissements TLS lors de la connexion au code source du projet. Cette dérogation s'applique uniquement si la source du build est GitHub Enterprise Server.
   + *privilegedModeOverride*: booléen facultatif. Si celle-ci est définie sur true, la génération remplace le mode privilégié dans le projet de génération.
   +  *queuedTimeoutInMinutesOverride*: entier facultatif qui indique le nombre de minutes pendant lesquelles une version est autorisée à être mise en file d'attente avant son expiration. Sa valeur minimale est de cinq minutes et sa valeur maximale est 480 minutes (huit heures). 
   + *reportBuildStatusOverride*: booléen facultatif qui indique s'il faut envoyer à votre fournisseur source l'état du début et de la fin d'une compilation. Si vous le définissez avec un fournisseur de source autre qu' GitHub GitHub Enterprise Server ou Bitbucket, un invalidInputException est émis.
   + *sourceAuthOverride*: chaîne facultative. Type d'autorisation pour cette génération qui remplace celle définie dans le projet de génération. Cette dérogation s'applique uniquement si la source du projet de build est Bitbucket ou. GitHub
   + *sourceLocationOverride*: chaîne facultative. Emplacement qui remplace l'emplacement de la source pour cette génération par celui défini dans le projet de génération.
   + *serviceRoleOverride*: chaîne facultative. Nom d'un rôle de service pour cette génération qui remplace celui spécifié dans le projet de génération.
   + *sourceTypeOverride*: chaîne facultative. Type d'entrée source pour cette génération qui remplace l'entrée source définie dans le projet de génération. Les chaînes valides sont `NO_SOURCE`, `CODECOMMIT`, `CODEPIPELINE`, `GITHUB`, `S3`, `BITBUCKET` et `GITHUB_ENTERPRISE`.
   + *timeoutInMinutesOverride*: Numéro optionnel. Nombre de minutes de délai d'expiration de génération qui remplace pour cette de génération celui défini dans le projet de génération. 

   Nous vous recommandons de stocker une variable d'environnement avec une valeur sensible, telle qu'un identifiant de clé d' AWS accès, une clé d'accès AWS secrète ou un mot de passe en tant que paramètre dans Amazon EC2 Systems Manager Parameter Store. CodeBuild peut utiliser un paramètre stocké dans Amazon EC2 Systems Manager Parameter Store uniquement si le nom de ce paramètre commence par `/CodeBuild/` (par exemple,`/CodeBuild/dockerLoginPassword`). Vous pouvez utiliser la CodeBuild console pour créer un paramètre dans Amazon EC2 Systems Manager. Sélectionnez **Créer un paramètre**, puis suivez les instructions. (Dans cette boîte de dialogue, pour la **clé KMS**, vous pouvez éventuellement spécifier l'ARN d'une AWS KMS clé dans votre compte. Amazon EC2 Systems Manager utilise cette clé pour chiffrer la valeur du paramètre pendant le stockage et pour le déchiffrer lors de la récupération.) Si vous utilisez la CodeBuild console pour créer un paramètre, la console commence le paramètre `/CodeBuild/` tel qu'il est stocké. Toutefois, si vous utilisez la console Amazon EC2 Systems Manager Parameter Store pour créer un paramètre, vous devez commencer le nom du paramètre par et définir **Type** sur **Secure String**. `/CodeBuild/` Pour plus d'informations, consultez les [AWS Systems Manager sections Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) et [Walkthrough : Create and test a String parameter (console)](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-console.html) dans le *guide de l'utilisateur d'Amazon EC2 Systems Manager*.

   Si votre projet de génération fait référence à des paramètres stockés dans Amazon EC2 Systems Manager Parameter Store, le rôle de service du projet de génération doit autoriser l'`ssm:GetParameters`action. Si vous avez choisi **Créer un nouveau rôle de service dans votre compte** plus tôt, cette action est automatiquement incluse dans le rôle de service par défaut de votre projet de génération. CodeBuild Toutefois, si vous avez choisi précédemment **Choisir un rôle de service existant dans votre compte**, vous devez inclure séparément cette action dans votre rôle de service.

   Les variables d'environnement que vous définissez remplacent les variables d'environnement existantes. Par exemple, si l'image Docker contient déjà une variable d'environnement nommée `MY_VAR` avec la valeur `my_value` et que vous définissez une variable d'environnement nommée `MY_VAR` avec la valeur `other_value`, la valeur `my_value` est remplacée par `other_value`. De même, si l'image Docker contient déjà une variable d'environnement nommée `PATH` avec la valeur `/usr/local/sbin:/usr/local/bin` et que vous définissez une variable d'environnement nommée `PATH` avec la valeur `$PATH:/usr/share/ant/bin`, la valeur `/usr/local/sbin:/usr/local/bin` est remplacée par la valeur littérale `$PATH:/usr/share/ant/bin`. 

   Ne définissez pas de variables d'environnement avec un nom commençant par `CODEBUILD_`. Ce préfixe est réservé à une utilisation interne .

   Si une variable d'environnement avec le même nom est définie dans plusieurs emplacements, la valeur de la variable d'environnement est déterminée comme suit :
   + La valeur de l'appel d'opération de démarrage de génération a une priorité plus élevée.
   + La valeur de la définition de projet de génération vient ensuite dans l'ordre des priorités.
   + La valeur figurant dans la déclaration du fichier buildspec a la priorité la plus faible.

   Pour de plus amples informations sur les valeurs valides pour ces espaces réservés, consultez [Création d'un projet de génération (AWS CLI)](create-project.md#create-project-cli). Pour obtenir une liste des derniers paramètres pour un projet de génération, consultez [Afficher les détails du projet de construction](view-project-details.md).

1. Placez-vous dans le répertoire contenant le fichier que vous venez d'enregistrer, puis exécutez à nouveau la commande `start-build`.

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

1. En cas de réussite, des données similaires à ce qui est décrit dans la procédure [Pour exécuter la génération](getting-started-overview.md#getting-started-run-build-cli) apparaissent en sortie.

Pour utiliser les informations détaillées sur cette génération, notez la valeur `id` de la sortie, puis consultez [Affichage des détails d'une génération (AWS CLI)](view-build-details.md#view-build-details-cli).

# Exécuter une compilation par lots (AWS CLI)
<a name="run-batch-build-cli"></a>

1. Exécutez la commande `start-build-batch` de l'une des manières suivantes :

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

   Utilisez cette commande si vous souhaitez exécuter une génération utilisant la dernière version de l'artefact d'entrée de génération et les paramètres existants du projet de génération.

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

   Utilisez cette commande si vous souhaitez exécuter une génération avec une version précédente de l'artefact d'entrée de génération, ou si vous souhaitez remplacer les paramètres pour les artefacts de sortie, les variables d'environnement, le fichier buildspec ou le délai d'expiration de génération par défaut.

1. Si vous exécutez la **start-build-batch** commande avec l'`--project-name`option, *<project-name>* remplacez-la par le nom du projet de génération, puis passez à l'étape 6 de cette procédure. Pour obtenir une liste de projets de génération, consultez [Afficher les noms des projets de construction](view-project-list.md).

1. Si vous exécutez la **start-build-batch** commande avec l'`--idempotency-token`option, un identifiant unique distinguant majuscules et minuscules, ou jeton, est inclus dans la `start-build-batch` demande. Le jeton est valide pendant 5 minutes après la demande . Si vous répétez la `start-build-batch` demande avec le même jeton, mais que vous modifiez un paramètre, CodeBuild renvoie une erreur de non-concordance des paramètres.

1. Si vous exécutez la **start-build-batch** commande avec l'`--generate-cli-skeleton`option, les données au format JSON sont sorties dans le fichier. *<json-file>* Ce fichier est similaire au squelette produit par la **start-build** commande, avec l'ajout de l'objet suivant. Pour plus d'informations sur les objets courants, consultez[Exécution d'une génération (AWS CLI)](run-build-cli.md).

   Modifiez ce fichier pour ajouter des remplacements de build et enregistrez vos résultats.

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

   L'`buildBatchConfigOverride`objet est une [ProjectBuildBatchConfig](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectBuildBatchConfig.html)structure qui contient les remplacements de configuration de génération par lots pour cette version.  
*combineArtifacts*  
Un booléen qui indique si les artefacts de construction pour la génération par lots doivent être combinés dans un seul emplacement d'artefact.  
*allowedComputeTypes*  
Tableau de chaînes qui spécifient les types de calcul autorisés pour la construction par lots. Reportez-vous [à la section Types de calcul de l'environnement](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html) de génération pour ces valeurs.   
*maximumBuildsAllowed*  
Spécifie le nombre maximal de builds autorisés.  
*batchServiceRole*  
Spécifie l'ARN du rôle de service pour le projet de génération par lots.  
*batchTimeout*  
Spécifie la durée maximale, en minutes, pendant laquelle la génération du lot doit être terminée.

1. Placez-vous dans le répertoire contenant le fichier que vous venez d'enregistrer, puis exécutez à nouveau la commande `start-build-batch`.

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

1. En cas de succès, la représentation JSON d'un [BuildBatch](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_BuildBatch.html)objet apparaît dans la sortie de la console. Voir la [syntaxe de StartBuildBatch réponse](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_StartBuildBatch.html#API_StartBuildBatch_ResponseSyntax) pour un exemple de ces données.

# Lancement automatique de l'exécution de générations (AWS CLI)
<a name="run-build-cli-auto-start"></a>

Si votre code source est stocké dans un référentiel GitHub ou dans un référentiel GitHub Enterprise Server, vous pouvez utiliser des GitHub webhooks pour AWS CodeBuild reconstruire votre code source chaque fois qu'une modification de code est envoyée au référentiel.

Exécutez la commande **create-webhook** comme suit :

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

*<project-name>*est le nom du projet de construction qui contient le code source à reconstruire.

En GitHub effet, des informations similaires aux suivantes apparaissent dans la sortie :

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

*<url>*est l'URL du GitHub webhook.

Pour GitHub Enterprise Server, des informations similaires aux suivantes apparaissent dans la sortie :

![\[Exemples d'informations de sortie.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/create-webhook-ghe.png)


1. Copiez la clé secrète et l'URL de la charge utile à partir de la sortie. Vous en avez besoin pour ajouter un webhook dans GitHub Enterprise Server. 

1. Dans GitHub Enterprise Server, choisissez le référentiel dans lequel votre CodeBuild projet est stocké. Choisissez **Settings (Paramètres)**, **Hooks & services**, puis **Add webhook (Ajouter un webhook)**. 

1. Entrez l'URL et la clé secrète de la charge utile, acceptez les valeurs par défaut pour les autres champs, puis choisissez **Add webhook**.

# Arrêt automatique de l'exécution de générations (AWS CLI)
<a name="run-build-cli-auto-stop"></a>

Si votre code source est stocké dans un référentiel GitHub ou dans un référentiel GitHub Enterprise Server, vous pouvez configurer des GitHub webhooks pour AWS CodeBuild reconstruire votre code source chaque fois qu'une modification de code est envoyée au référentiel. Pour de plus amples informations, veuillez consulter [Lancement automatique de l'exécution de générations (AWS CLI)](run-build-cli-auto-start.md).

Si vous avez activé ce comportement, vous pouvez le désactiver en exécutant la commande `delete-webhook` comme suit :

```
aws codebuild delete-webhook --project-name <project-name>
```
+ où *<project-name>* est le nom du projet de construction qui contient le code source à reconstruire.

Si cette commande aboutit, aucune information ni aucune erreur n'apparaît dans la sortie.

**Note**  
Cela supprime le webhook de votre CodeBuild projet uniquement. Vous devez également supprimer le webhook de votre référentiel GitHub ou de celui GitHub d'Enterprise Server.

# Exécution d'une génération (AWS SDKs)
<a name="run-build-sdks"></a>

À utiliser CodePipeline pour exécuter une compilation avec AWS CodeBuild, ignorez ces étapes et suivez [Utilisez AWS CodeBuild with AWS CodePipeline pour tester le code et exécuter des builds](how-to-create-pipeline.md) plutôt les instructions indiquées.

Pour plus d'informations sur l'utilisation CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Exécuter des builds sur AWS Lambda ordinateur
<a name="lambda"></a>

AWS Lambda compute offre des vitesses de démarrage optimisées pour vos builds. AWS Lambda prend en charge des builds plus rapides grâce à une latence de démarrage plus faible. AWS Lambda évolue également automatiquement, de sorte que les builds n'attendent pas dans la file d'attente pour s'exécuter. Cependant, certains cas d'utilisation AWS Lambda ne sont pas compatibles, et s'ils vous concernent, utilisez le calcul EC2. Pour de plus amples informations, veuillez consulter [Limites du AWS Lambda calcul](#lambda.limitations).

**Topics**
+ [Quels outils et environnements d'exécution seront inclus dans les images docker de l'environnement d'exécution sélectionnées sur lesquelles s'exécutent ? AWS Lambda](#lambda.tools)
+ [Et si l'image sélectionnée n'inclut pas les outils dont j'ai besoin ?](#lambda.custom)
+ [Dans quelles régions le AWS Lambda calcul CodeBuild est-il possible ?](#lambda.regions)
+ [Limites du AWS Lambda calcul](#lambda.limitations)
+ [Déployer une fonction Lambda à l'aide de AWS SAM CodeBuild Lambda Java](sample-lambda-sam-gradle.md)
+ [Créez une application React d'une seule page avec CodeBuild Lambda Node.js](sample-lambda-react-nodejs.md)
+ [Mettre à jour une configuration de fonction Lambda avec CodeBuild Lambda Python](sample-lambda-boto3-python.md)

## Quels outils et environnements d'exécution seront inclus dans les images docker de l'environnement d'exécution sélectionnées sur lesquelles s'exécutent ? AWS Lambda
<a name="lambda.tools"></a>

AWS Lambda prend en charge les outils suivants : AWS CLI v2, AWS SAM CLI, git, go, Java, Node.js, Python, pip, Ruby et .NET.

## Et si l'image sélectionnée n'inclut pas les outils dont j'ai besoin ?
<a name="lambda.custom"></a>

Si l'image sélectionnée n'inclut pas les outils dont vous avez besoin, vous pouvez fournir une image Docker d'environnement personnalisée qui inclut les outils nécessaires.

**Note**  
Lambda ne prend pas en charge les fonctions qui utilisent les images de conteneur multi-architecture. Pour plus d'informations, voir [Création d'une fonction Lambda à l'aide d'une image de conteneur](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#images-reqs) dans le Guide du *AWS Lambda développeur*.

Notez que vous avez besoin des autorisations Amazon ECR suivantes pour utiliser des images personnalisées pour le calcul 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"
        }
    ]
}
```

------

Notez également que cela `wget` doit être installé `curl` ou doit être installé pour pouvoir utiliser des images personnalisées.

## Dans quelles régions le AWS Lambda calcul CodeBuild est-il possible ?
<a name="lambda.regions"></a>

En CodeBuild, le AWS Lambda calcul est pris en charge dans les pays suivants Régions AWS : USA Est (Virginie du Nord), USA Est (Ohio), USA Ouest (Oregon), Asie-Pacifique (Mumbai), Asie-Pacifique (Singapour), Asie-Pacifique (Sydney), Asie-Pacifique (Tokyo), Europe (Francfort), Europe (Irlande) et Amérique du Sud (São Paulo). Pour plus d'informations sur Régions AWS les CodeBuild zones disponibles, consultez la section [AWS Services par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).

## Limites du AWS Lambda calcul
<a name="lambda.limitations"></a>

Certains cas d'utilisation AWS Lambda ne sont pas compatibles, et s'ils vous concernent, utilisez le calcul EC2 :
+ AWS Lambda ne prend pas en charge les outils qui nécessitent des autorisations root. Pour des outils tels que `yum` ou`rpm`, utilisez le type de calcul EC2 ou d'autres outils ne nécessitant pas d'autorisations root.
+ AWS Lambda ne prend pas en charge les builds ou les exécutions de Docker.
+ AWS Lambda ne prend pas en charge l'écriture dans des fichiers externes`/tmp`. Les gestionnaires de packages inclus sont configurés pour utiliser le `/tmp` répertoire par défaut pour le téléchargement et le référencement des packages.
+ AWS Lambda ne prend pas en charge le type d'environnement `LINUX_GPU_CONTAINER` et n'est pas pris en charge sur Windows Server Core 2019.
+ AWS Lambda ne prend pas en charge la mise en cache, les délais de génération personnalisés, les délais d'attente, les badges de génération, le mode privilégié, les environnements d'exécution personnalisés ou les durées d'exécution supérieures à 15 minutes.
+ AWS Lambda ne prend pas en charge la connectivité VPC, une plage fixe d'adresses IP CodeBuild sources, le système EFS, l'installation de certificats ou l'accès SSH avec le gestionnaire de session.

# Déployer une fonction Lambda à l'aide de AWS SAM CodeBuild Lambda Java
<a name="sample-lambda-sam-gradle"></a>

The AWS Serverless Application Model (AWS SAM) est un framework open source permettant de créer des applications sans serveur. Pour plus d'informations, consultez le [AWS Serverless Application Model référentiel](https://github.com/aws/serverless-application-model) sur GitHub. L'exemple Java suivant utilise Gradle pour créer et tester une AWS Lambda fonction. Ensuite, la AWS SAM CLI est utilisée pour déployer le CloudFormation modèle et le bundle de déploiement. Grâce à CodeBuild Lambda, les étapes de construction, de test et de déploiement sont toutes gérées automatiquement, ce qui permet de mettre à jour rapidement l'infrastructure sans intervention manuelle lors d'une seule génération.

## Configurez votre AWS SAM référentiel
<a name="sample-lambda-sam-gradle.set-up-repo"></a>

Créez un AWS SAM `Hello World` projet à l'aide de la AWS SAM CLI.

**Pour créer votre AWS SAM projet**

1. Suivez les instructions du *guide du AWS Serverless Application Model développeur* pour [installer la AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) sur votre machine locale.

1. Exécutez `sam init` et sélectionnez la configuration de projet suivante.

   ```
   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. Téléchargez le dossier AWS SAM du projet dans un référentiel source compatible. Pour obtenir la liste des types de sources pris en charge, consultez [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Création d'un projet CodeBuild Lambda Java
<a name="sample-lambda-sam-gradle.create-project"></a>

Créez un projet AWS CodeBuild Lambda Java et configurez les autorisations IAM nécessaires pour le build.

**Pour créer votre projet CodeBuild Lambda Java**

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

1.  Si une page CodeBuild d'informations s'affiche, choisissez **Create build project**. Sinon, dans le volet de navigation, développez **Build****, choisissez Build projects**, puis **Create build project**. 

1. Dans **Nom du projet**, saisissez un nom pour ce projet de génération. Les noms des projets de construction doivent être uniques pour chaque AWS compte. Vous pouvez également inclure une description facultative du projet de construction pour aider les autres utilisateurs à comprendre à quoi sert ce projet.

1. Dans **Source**, sélectionnez le référentiel source dans lequel se trouve votre AWS SAM projet.

1. Dans **Environment (Environnement)** :
   + Pour **Compute**, sélectionnez **Lambda**.
   + Pour **Runtime (s)**, sélectionnez **Java**.
   + Pour **Image**, sélectionnez **aws/codebuild/amazonlinux-x86\$164-lambda-standard:corretto21**.
   + Pour **Rôle de service**, laissez l'option **Nouveau rôle de service** sélectionnée. Notez le **nom du rôle**. Cela sera nécessaire lorsque vous mettrez à jour les autorisations IAM du projet ultérieurement dans cet exemple.

1. Choisissez **Créer un projet de génération**.

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 

1. Dans le volet de navigation, choisissez **Rôles** et sélectionnez le rôle de service associé à votre projet. Vous pouvez trouver votre rôle dans le projet en CodeBuild sélectionnant votre projet de construction, en choisissant **Modifier**, **Environnement**, puis **Rôle de service**.

1. Sélectionnez l'onglet **Trust relationships** (Relations d'approbation), puis **Edit trust policy** (Modifier la politique d'approbation).

1. Ajoutez la politique intégrée suivante à votre rôle IAM. Cela sera utilisé pour déployer votre AWS SAM infrastructure ultérieurement. Pour plus d’informations, consultez [Ajout et suppression d’autorisations basées sur l’identité IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le *Guide de l’utilisateur IAM*.

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

****  

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

------

## Configurer le buildspec du projet
<a name="sample-lambda-sam-gradle.set-up-buildspec"></a>

Pour créer, tester et déployer votre fonction Lambda, CodeBuild lit et exécute les commandes de construction à partir d'une spécification de construction.

**Pour configurer le buildspec de votre projet**

1. Dans la CodeBuild console, sélectionnez votre projet de build, puis choisissez **Edit** et **Buildspec**.

1. Dans **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Passer** à l'éditeur.

1. Supprimez les commandes de construction préremplies et collez les spécifications de construction suivantes.

   ```
   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. Choisissez **Update buildspec (Mettre à jour buildspec)**.

## Déployez votre infrastructure AWS SAM Lambda
<a name="sample-lambda-sam-gradle.deploy"></a>

Utilisez CodeBuild Lambda pour déployer automatiquement votre infrastructure Lambda

**Pour déployer votre infrastructure Lambda**

1. Choisissez **Démarrer la génération**. Cela permettra de créer, de tester et de déployer automatiquement votre AWS SAM application pour AWS Lambda l'utiliser CloudFormation.

1. Une fois le build terminé, accédez à la AWS Lambda console et recherchez votre nouvelle fonction Lambda sous le nom du AWS SAM projet.

1. Testez votre fonction Lambda en sélectionnant **API Gateway** dans la vue d'ensemble des **fonctions**, puis en cliquant sur l'URL du point de **terminaison de l'API**. Vous devriez voir une page s'ouvrir avec le message`"message": "hello world"`.

## Nettoyez votre infrastructure
<a name="sample-lambda-sam-gradle.clean-up"></a>

Pour éviter des frais supplémentaires pour les ressources que vous avez utilisées au cours de ce didacticiel, supprimez les ressources créées par votre AWS SAM modèle et CodeBuild.

**Pour nettoyer votre infrastructure**

1. Accédez à la CloudFormation console et sélectionnez le`aws-sam-cli-managed-default`.

1. Dans **Ressources**, videz le compartiment de déploiement`SamCliSourceBucket`.

1. Supprimez la `aws-sam-cli-managed-default` pile.

1. Supprimez la CloudFormation pile associée à votre AWS SAM projet. Cette pile doit porter le même nom que votre AWS SAM projet.

1. Accédez à la CloudWatch console et supprimez les groupes de CloudWatch journaux associés à votre CodeBuild projet.

1. Accédez à la CodeBuild console et supprimez votre CodeBuild projet en choisissant **Supprimer le projet de construction**.

# Créez une application React d'une seule page avec CodeBuild Lambda Node.js
<a name="sample-lambda-react-nodejs"></a>

[Create React App](https://create-react-app.dev/) est un moyen de créer des applications React d'une seule page. L'exemple de fichier Node.js suivant utilise Node.js pour créer les artefacts source à partir de Create React App et renvoie les artefacts de construction.

## Configuration de votre référentiel source et de votre compartiment d'artefacts
<a name="sample-lambda-react-nodejs.set-up-repo"></a>

Créez un référentiel source pour votre projet à l'aide de yarn et de Create React App.

**Pour configurer le référentiel source et le compartiment d'artefacts**

1. Sur votre machine locale, lancez-le `yarn create react-app <app-name>` pour créer une application React simple.

1. Téléchargez le dossier du projet de l'application React dans un référentiel source compatible. Pour obtenir la liste des types de sources pris en charge, consultez [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Création d'un projet CodeBuild Lambda Node.js
<a name="sample-lambda-react-nodejs.create-project"></a>

Créez un projet AWS CodeBuild Lambda Node.js.

**Pour créer votre projet CodeBuild Lambda Node.js**

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

1.  Si une page CodeBuild d'informations s'affiche, choisissez **Créer un projet de construction**. Sinon, dans le volet de navigation, développez **Build****, choisissez Build projects**, puis **Create build project**. 

1. Dans **Nom du projet**, saisissez un nom pour ce projet de génération. Les noms des projets de construction doivent être uniques pour chaque AWS compte. Vous pouvez également inclure une description facultative du projet de construction pour aider les autres utilisateurs à comprendre à quoi sert ce projet.

1. Dans **Source**, sélectionnez le référentiel source dans lequel se trouve votre AWS SAM projet.

1. Dans **Environment (Environnement)** :
   + Pour **Compute**, sélectionnez **Lambda**.
   + Pour **Runtime (s)**, sélectionnez **Node.js**.
   + Pour **Image**, sélectionnez **aws/codebuild/amazonlinux-x86\$164-lambda-standard:nodejs20**.

1. Dans **Artefacts**:
   + Pour **Type**, sélectionnez **Amazon S3**.
   + Dans le **champ Nom du compartiment**, sélectionnez le compartiment d'artefacts du projet que vous avez créé précédemment.
   + Pour l'**emballage des artefacts**, sélectionnez **Zip**.

1. Choisissez **Créer un projet de génération**.

## Configurer le buildspec du projet
<a name="sample-lambda-react-nodejs.set-up-buildspec"></a>

Pour créer votre application React, CodeBuild lit et exécute les commandes de construction à partir d'un fichier buildspec.

**Pour configurer le buildspec de votre projet**

1. Dans la CodeBuild console, sélectionnez votre projet de build, puis choisissez **Edit** et **Buildspec**.

1. Dans **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Basculer vers** l'éditeur.

1. Supprimez les commandes de construction préremplies et collez les spécifications de construction suivantes.

   ```
   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. Choisissez **Update buildspec (Mettre à jour buildspec)**.

## Créez et exécutez votre application React
<a name="sample-lambda-react-nodejs.build"></a>

Créez l'application React sur CodeBuild Lambda, téléchargez les artefacts de construction et exécutez l'application React localement.

**Pour créer et exécuter votre application React**

1. Choisissez **Démarrer la génération**.

1. Une fois le build terminé, accédez au bucket d'artefacts de votre projet Amazon S3 et téléchargez l'artefact de l'application React.

1. Décompressez l'artefact de construction de React et placez-le `run npm install -g serve && serve -s build` dans le dossier du projet.

1. La `serve` commande servira le site statique sur un port local et imprimera le résultat sur votre terminal. Vous pouvez visiter l'URL localhost ci-dessous `Local:` dans la sortie du terminal pour afficher votre application React.

Pour en savoir plus sur la gestion du déploiement d'un serveur basé sur React, voir [Créer un déploiement d'applications React](https://create-react-app.dev/docs/deployment/).

## Nettoyez votre infrastructure
<a name="sample-lambda-react-nodejs.clean-up"></a>

Pour éviter des frais supplémentaires pour les ressources que vous avez utilisées au cours de ce didacticiel, supprimez les ressources créées pour votre CodeBuild projet.

**Pour nettoyer votre infrastructure**

1. Supprimer les artefacts de votre projet (compartiment Amazon S3)

1. Accédez à la CloudWatch console et supprimez les groupes de CloudWatch journaux associés à votre CodeBuild projet.

1. Accédez à la CodeBuild console et supprimez votre CodeBuild projet en choisissant **Supprimer le projet de construction**.

# Mettre à jour une configuration de fonction Lambda avec CodeBuild Lambda Python
<a name="sample-lambda-boto3-python"></a>

L'exemple Python suivant utilise [Boto3](https://aws.amazon.com/sdk-for-python/) et Lambda CodeBuild Python pour mettre à jour la configuration d'une fonction Lambda. Cet exemple peut être étendu pour gérer d'autres AWS ressources par programmation. Pour plus d'informations, consultez la documentation de [Boto3](https://aws.amazon.com/sdk-for-python/).

## Conditions préalables
<a name="sample-lambda-boto3-python.prerequisites"></a>

Créez ou trouvez une fonction Lambda dans votre compte.

Cet exemple suppose que vous avez déjà créé une fonction Lambda dans votre compte et que vous l'utiliserez CodeBuild pour mettre à jour les variables d'environnement de la fonction Lambda. Pour plus d'informations sur la configuration d'une fonction Lambda via CodeBuild, consultez l'[Déployer une fonction Lambda à l'aide de AWS SAM CodeBuild Lambda Java](sample-lambda-sam-gradle.md)exemple ou rendez-vous sur. [AWS Lambda](https://aws.amazon.com/lambda/)

## Configurez votre référentiel de sources
<a name="sample-lambda-boto3-python.set-up-repo"></a>

Créez un dépôt source pour stocker votre script python Boto3.

**Pour configurer le référentiel source**

1. Copiez le script python suivant dans un nouveau fichier appelé`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. Téléchargez le fichier python dans un référentiel source compatible. Pour obtenir la liste des types de sources pris en charge, consultez [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html).

## Création d'un projet CodeBuild Lambda Python
<a name="sample-lambda-boto3-python.create-project"></a>

Créez un projet CodeBuild Lambda Python.

**Pour créer votre projet CodeBuild Lambda Java**

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

1.  Si une page CodeBuild d'informations s'affiche, choisissez **Create build project**. Sinon, dans le volet de navigation, développez **Build****, choisissez Build projects**, puis **Create build project**. 

1. Dans **Nom du projet**, saisissez un nom pour ce projet de génération. Les noms des projets de construction doivent être uniques pour chaque AWS compte. Vous pouvez également inclure une description facultative du projet de construction pour aider les autres utilisateurs à comprendre à quoi sert ce projet.

1. Dans **Source**, sélectionnez le référentiel source dans lequel se trouve votre AWS SAM projet.

1. Dans **Environment (Environnement)** :
   + Pour **Compute**, sélectionnez **Lambda**.
   + Pour **Runtime (s)**, sélectionnez **Python**.
   + Pour **Image**, sélectionnez **aws/codebuild/amazonlinux-x86\$164-lambda-standard:python3.12**.
   + Pour **Rôle de service**, laissez l'option **Nouveau rôle de service** sélectionnée. Notez le **nom du rôle**. Cela sera nécessaire lorsque vous mettrez à jour les autorisations IAM du projet ultérieurement dans cet exemple.

1. Choisissez **Créer un projet de génération**.

1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 

1. Dans le volet de navigation, choisissez **Rôles** et sélectionnez le rôle de service associé à votre projet. Vous pouvez trouver votre rôle dans le projet en CodeBuild sélectionnant votre projet de construction, en choisissant **Modifier**, **Environnement**, puis **Rôle de service**.

1. Sélectionnez l'onglet **Trust relationships** (Relations d'approbation), puis **Edit trust policy** (Modifier la politique d'approbation).

1. Ajoutez la politique intégrée suivante à votre rôle IAM. Cela sera utilisé pour déployer votre AWS SAM infrastructure ultérieurement. Pour plus d’informations, consultez [Ajout et suppression d’autorisations basées sur l’identité IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le *Guide de l’utilisateur IAM*.

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

****  

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

------

## Configurer le buildspec du projet
<a name="sample-lambda-boto3-python.set-up-buildspec"></a>

Afin de mettre à jour la fonction Lambda, le script lit les variables d'environnement depuis le buildspec pour trouver le nom, le nom de la variable d'environnement et la valeur de la variable d'environnement de la fonction Lambda.

**Pour configurer le buildspec de votre projet**

1. Dans la CodeBuild console, sélectionnez votre projet de build, puis choisissez **Edit** et **Buildspec**.

1. Dans **Buildspec**, choisissez **Insérer des commandes de construction**, puis **Passer** à l'éditeur.

1. Supprimez les commandes de construction préremplies et collez les spécifications de construction suivantes.

   ```
   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. Choisissez **Update buildspec (Mettre à jour buildspec)**.

## Mettez à jour votre configuration Lambda
<a name="sample-lambda-boto3-python.update"></a>

Utilisez CodeBuild Lambda Python pour mettre à jour automatiquement la configuration de votre fonction Lambda.

**Pour mettre à jour la configuration de votre fonction Lambda**

1. Choisissez **Démarrer la génération**.

1. Une fois le build terminé, accédez à votre fonction Lambda.

1. Sélectionnez **Configuration**, puis Variables d'**environnement**. Vous devriez voir une nouvelle variable d'environnement contenant une clé `FEATURE_ENABLED` et une valeur`true`.

## Nettoyez votre infrastructure
<a name="sample-lambda-boto3-python.clean-up"></a>

Pour éviter des frais supplémentaires pour les ressources que vous avez utilisées au cours de ce didacticiel, supprimez les ressources créées pour votre CodeBuild projet.

**Pour nettoyer votre infrastructure**

1. Accédez à la CloudWatch console et supprimez les groupes de CloudWatch journaux associés à votre CodeBuild projet.

1. Accédez à la CodeBuild console et supprimez votre CodeBuild projet en choisissant **Supprimer le projet de construction**.

1. Si vous avez créé une fonction Lambda aux fins de cet exemple, choisissez **Actions** et **fonction Supprimer pour nettoyer votre fonction** Lambda.

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

Si vous souhaitez étendre cet exemple pour gérer d'autres AWS ressources à l'aide de AWS CodeBuild Lambda Python :
+ Mettez à jour le script Python pour modifier les nouvelles ressources à l'aide de Boto3.
+ Mettez à jour le rôle IAM associé à votre CodeBuild projet afin d'obtenir des autorisations pour les nouvelles ressources.
+ Ajoutez toutes les nouvelles variables d'environnement associées aux nouvelles ressources à vos spécifications de construction.

# Exécutez des builds sur des flottes à capacité réservée
<a name="fleets"></a>

CodeBuild propose les flottes de calcul suivantes :
+ Flottes à la demande
+ Flottes de capacité réservée

Avec des flottes à la demande, CodeBuild fournit le calcul nécessaire à vos builds. Les machines sont détruites à la fin de la construction. Les flottes à la demande sont entièrement gérées et incluent des fonctionnalités de mise à l'échelle automatique pour faire face aux pics de demande.

**Note**  
Les flottes à la demande ne sont pas compatibles avec macOS.

CodeBuild propose également des flottes de capacités réservées contenant des instances alimentées par Amazon EC2 et gérées par. CodeBuild Avec les flottes de capacité réservée, vous configurez un ensemble d'instances dédiées pour votre environnement de construction. Ces machines restent inactives, prêtes à traiter les builds ou les tests immédiatement et réduisent les durées de construction. Avec des flottes de capacité réservées, vos machines fonctionnent en permanence et continueront d'entraîner des coûts tant qu'elles seront approvisionnées.

**Important**  
Quelle que soit la durée pendant laquelle vous exécutez une instance, les flottes de capacité réservée sont facturées initialement par instance, après quoi des coûts supplémentaires peuvent être associés. Pour de plus amples informations, veuillez consulter [https://aws.amazon.com/codebuild/pricing/](https://aws.amazon.com/codebuild/pricing/).

**Topics**
+ [Création d'un parc de capacités réservées](#fleets.how-to)
+ [Bonnes pratiques](#fleets.best-practices)
+ [Puis-je partager un parc de capacités réservées entre plusieurs CodeBuild projets ?](#fleets.share)
+ [Comment fonctionne le calcul basé sur les attributs ?](#fleets.attribute-compute)
+ [Puis-je spécifier manuellement une instance Amazon EC2 pour mon parc ?](#fleets.manual-input-compute)
+ [Quelles régions prennent en charge les flottes à capacité réservée ?](#fleets.regions)
+ [Comment configurer une flotte de macOS à capacité réservée ?](#fleets.configure-macos)
+ [Comment configurer une Amazon Machine Image (AMI) personnalisée pour un parc de capacités réservées ?](#fleets.custom-ami)
+ [Limitations des flottes à capacité réservée](#fleets.limitations)
+ [Propriétés du parc à capacité réservée](fleets.reserved-capacity-fleets.md)
+ [Échantillons de capacité réservée avec AWS CodeBuild](reserved-capacity-samples.md)

## Création d'un parc de capacités réservées
<a name="fleets.how-to"></a>

Suivez les instructions ci-dessous pour créer un parc de capacités réservées.

**Pour créer un parc de capacités réservées**

1. Connectez-vous à la AWS CodeBuild console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Dans le volet de navigation, choisissez **Compute fleets**, puis **Create Fleet**.

1. Dans le champ de texte **Calculer le nom du parc**, saisissez le nom de votre parc.

1. Dans le menu déroulant **Système d'exploitation**, sélectionnez le système d'exploitation.

1. Dans le menu déroulant **Architecture**, sélectionnez l'architecture.

1. (Facultatif) Sélectionnez **Utiliser le mode d'exécution de l'instance. Facultatif** pour exécuter directement sur une instance Amazon EC2 au lieu d'un conteneur Docker. Choisissez ensuite une **version majeure** et une **version mineure**.

1. (Facultatif) Dans **Configuration supplémentaire**, procédez comme suit :
   + Sélectionnez **Configurer le VPC - facultatif** pour connecter votre flotte à un VPC afin d'accéder à des ressources privées pendant l'utilisation.
     + Dans le menu déroulant **VPC**, sélectionnez un VPC auquel votre CodeBuild flotte aura accès.
     + Dans le menu déroulant **Sous-réseaux**, sélectionnez les sous-réseaux à utiliser CodeBuild pour configurer votre configuration VPC.
     + Dans le menu déroulant **Groupes de sécurité**, sélectionnez les groupes de sécurité CodeBuild à utiliser pour fonctionner avec votre VPC.
     + Dans le champ **Rôle de service de flotte**, choisissez un rôle de service existant.
**Note**  
Assurez-vous que votre rôle dans la flotte dispose des autorisations nécessaires. Pour de plus amples informations, veuillez consulter [Autoriser un utilisateur à ajouter une politique d'autorisation pour un rôle de service de flotte](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).
     + Si vous avez choisi le système d'exploitation Amazon Linux, sélectionnez **Définir les configurations de proxy (facultatif)** pour appliquer le contrôle d'accès réseau à vos instances à capacité réservée.
     + Pour **Comportement par défaut**, choisissez d'autoriser ou de refuser le trafic sortant vers toutes les destinations par défaut.
     + Pour les **règles de proxy**, choisissez **Ajouter une règle de proxy** pour spécifier les domaines de destination ou IPs pour autoriser ou refuser le contrôle d'accès au réseau.
   + Sélectionnez **Configurer une AMI personnalisée. Cette option est facultative** pour utiliser une Amazon Machine Image (AMI) personnalisée.
     + Dans le menu déroulant **AMI**, sélectionnez une Amazon Machine Image (AMI) pour votre flotte.
     + Dans le champ **Rôle de service de flotte**, choisissez un rôle de service existant.
**Note**  
Assurez-vous que votre rôle dans la flotte dispose des autorisations nécessaires. Pour de plus amples informations, veuillez consulter [Autoriser un utilisateur à ajouter une politique d'autorisation pour un rôle de service de flotte](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).

1. Dans **Configuration de la capacité**, dans **Mode de sélection de calcul**, choisissez l'une des options suivantes :
   + Si vous choisissez **Sélection guidée**, procédez comme suit :
     + Pour **Compute**, choisissez le type d'instances inclus dans ce parc.
     + Dans le champ **de texte Capacité**, entrez le nombre minimum d'instances dans le parc.
     + (Facultatif) Dans **Configuration supplémentaire**, procédez comme suit :
       + Sélectionnez **Configurer le dimensionnement : facultatif** pour redimensionner automatiquement votre flotte en fonction de cette configuration. Dans le menu déroulant **optionnel Mode de mise à l'échelle**, choisissez le comportement à adopter lorsque la demande dépasse la capacité de la flotte.
   + Si vous choisissez **Instance personnalisée**, procédez comme suit :
     + Dans le menu déroulant **Calculer le type d'instance**, sélectionnez le type d'instances inclus dans ce parc.
     + Dans le champ de texte **Taille de volume EBS supplémentaire - facultatif**, entrez le volume supplémentaire aux 64 Go d'espace disque fournis.
     + Dans le champ **de texte Capacité**, entrez le nombre minimum d'instances dans le parc.
     + (Facultatif) Dans **Configuration supplémentaire**, procédez comme suit :
       + Sélectionnez **Configurer le dimensionnement : facultatif** pour redimensionner automatiquement votre flotte en fonction de cette configuration. Dans le menu déroulant **optionnel Mode de mise à l'échelle**, choisissez le comportement à adopter lorsque la demande dépasse la capacité de la flotte.

1. Choisissez **Créer un parc informatique**.

1. Une fois le parc informatique créé, créez un nouveau CodeBuild projet ou modifiez un projet existant. Dans **Environnement**, choisissez **Capacité réservée** sous **Modèle de provisionnement**, puis choisissez le parc spécifié sous **Nom du parc**.

## Bonnes pratiques
<a name="fleets.best-practices"></a>

Lorsque vous utilisez des flottes de capacité réservée, nous vous recommandons de suivre ces bonnes pratiques.
+ Nous vous recommandons d'utiliser le mode de cache source pour améliorer les performances de génération en mettant en cache la source.
+ Nous vous recommandons d'utiliser la mise en cache des couches Docker pour améliorer les performances de création en mettant en cache les couches Docker existantes.

## Puis-je partager un parc de capacités réservées entre plusieurs CodeBuild projets ?
<a name="fleets.share"></a>

Oui, vous pouvez optimiser l'utilisation de la capacité d'une flotte en l'utilisant dans le cadre de plusieurs projets.

**Important**  
Lorsque vous utilisez la fonctionnalité de capacité réservée, les données mises en cache sur les instances de flotte, y compris les fichiers source, les couches Docker et les répertoires mis en cache spécifiés dans les spécifications de construction, peuvent être accessibles aux autres projets du même compte. Cela est intentionnel et permet aux projets au sein d'un même compte de partager des instances de flotte.

## Comment fonctionne le calcul basé sur les attributs ?
<a name="fleets.attribute-compute"></a>

Si vous choisissez `ATTRIBUTE_BASED_COMPUTE` celui de votre flotte`computeType`, vous pouvez spécifier les attributs dans un nouveau champ appelé`computeConfiguration`. Ces attributs incluent vCPUs, la mémoire, l'espace disque et le`machineType`. C'`machineType`est l'un `GENERAL` ou l'autre`NVME`. Après avoir spécifié un ou plusieurs des attributs disponibles, il CodeBuild choisira un type de calcul parmi les types d'instances pris en charge disponibles une fois finalisé`computeConfiguration`.

**Note**  
CodeBuild choisira l'instance la moins chère qui répond à toutes les exigences de saisie. La mémoire, le v CPUs et l'espace disque des instances choisies seront tous supérieurs ou égaux aux exigences d'entrée. Vous pouvez vérifier les problèmes résolus `computeConfiguration` dans le parc créé ou mis à jour.

Si vous saisissez un `computeConfiguration` qu'il n'est pas possible de satisfaire CodeBuild, vous recevrez une exception de validation. Notez également que le comportement de dépassement de flotte à la demande sera remplacé par le comportement de file d'attente s'il n'`computeConfiguration`est pas disponible pour la demande.

## Puis-je spécifier manuellement une instance Amazon EC2 pour mon parc ?
<a name="fleets.manual-input-compute"></a>

Oui, vous pouvez saisir directement l'instance Amazon EC2 souhaitée dans la console en sélectionnant **Instance personnalisée** ou en configurant le paramètre API,. `InstanceType` Ce champ est utilisé dans les cas suivants APIs : CreateFleet UpdateFleet, CreateProject, UpdateProject et StartBuild. Pour de plus amples informations, veuillez consulter [Compute instance type](fleets.reserved-capacity-fleets.md#compute).

## Quelles régions prennent en charge les flottes à capacité réservée ?
<a name="fleets.regions"></a>

Capacité réservée Les flottes Amazon Linux et Windows sont prises en charge dans les pays suivants Régions AWS : USA Est (Virginie du Nord), USA Est (Ohio), USA Ouest (Oregon), Asie-Pacifique (Mumbai), Asie-Pacifique (Singapour), Asie-Pacifique (Sydney), Asie-Pacifique (Tokyo), Europe (Francfort), Europe (Irlande) et Amérique du Sud (São Paulo). Pour plus d'informations sur Régions AWS les CodeBuild zones disponibles, consultez la section [AWS Services par région](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).

Capacité réservée Les flottes macOS Medium sont prises en charge dans les pays suivants Régions AWS : USA Est (Virginie du Nord), USA Est (Ohio), USA Ouest (Oregon), Asie-Pacifique (Sydney) et Europe (Francfort). Capacité réservée Les grandes flottes macOS sont prises en charge dans les pays suivants Régions AWS : USA Est (Virginie du Nord), USA Est (Ohio), USA Ouest (Oregon) et Asie-Pacifique (Sydney).

## Comment configurer une flotte de macOS à capacité réservée ?
<a name="fleets.configure-macos"></a>

**Pour configurer un parc macOS à capacité réservée**

1. Connectez-vous à la AWS CodeBuild console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Dans le volet de navigation, choisissez **Compute fleets**, puis **Create Fleet**.

1. Dans le champ de texte **Calculer le nom du parc**, saisissez le nom de votre parc.

1. Dans le menu déroulant **Système d'exploitation**, sélectionnez **macOS**.

1. Dans le champ **Calcul**, sélectionnez l'un des types de machines de calcul suivants : **Apple M2, 24 Go de mémoire, 8 V CPUs** ou **Apple M2, 32 Go de mémoire, 12 CPUs V.**

1. Dans le champ **de texte Capacité**, entrez le nombre minimum d'instances dans le parc.

1. (Facultatif) Pour utiliser une image personnalisée pour votre flotte[Comment configurer une Amazon Machine Image (AMI) personnalisée pour un parc de capacités réservées ?](#fleets.custom-ami), assurez-vous que votre Amazon Machine Image (AMI) répond aux exigences requises.

1. (Facultatif) Pour configurer un VPC avec votre flotte, dans **Configuration supplémentaire**, procédez comme suit :
   + Dans le menu déroulant **VPC - facultatif**, sélectionnez un VPC auquel votre CodeBuild flotte aura accès.
   + Dans le menu déroulant **Sous-réseaux**, sélectionnez les sous-réseaux à utiliser CodeBuild pour configurer votre configuration VPC.
   + Dans le menu déroulant **Groupes de sécurité**, sélectionnez les groupes de sécurité CodeBuild à utiliser pour fonctionner avec votre VPC.
   + Dans le champ **Rôle de service de flotte**, choisissez un rôle de service existant.
**Note**  
Assurez-vous que votre rôle dans la flotte dispose des autorisations nécessaires. Pour de plus amples informations, veuillez consulter [Autoriser un utilisateur à ajouter une politique d'autorisation pour un rôle de service de flotte](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-permission-policy-fleet-service-role).

1. Choisissez **Créer une flotte de calcul** et attendez que l'instance de flotte soit lancée. Une fois lancée, la capacité sera`n/n`, où *n* est la capacité fournie ?

1. Une fois le parc informatique lancé, créez un nouveau CodeBuild projet ou modifiez un projet existant. Dans **Environnement**, choisissez **Capacité réservée** sous **Modèle de provisionnement**, puis choisissez le parc spécifié sous **Nom du parc**.

## Comment configurer une Amazon Machine Image (AMI) personnalisée pour un parc de capacités réservées ?
<a name="fleets.custom-ami"></a>

**Pour configurer une Amazon Machine Image (AMI) personnalisée pour un parc de capacités réservées**

1. Connectez-vous à la AWS CodeBuild console AWS Management Console et ouvrez-la sur [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Dans le volet de navigation, choisissez **Compute fleets**, puis **Create Fleet**.

1. Dans le champ de texte **Calculer le nom du parc**, saisissez le nom de votre parc.

1. Choisissez **une image personnalisée** pour votre flotte et assurez-vous que votre Amazon Machine Image (AMI) répond aux exigences suivantes :
   + Si votre type d'environnement est `MAC_ARM` le cas, assurez-vous que votre **architecture** AMI est 64 bits`Mac-Arm`.
   + Si votre type d'environnement est `LINUX_EC2` le cas, assurez-vous que votre **architecture** AMI est 64 bits`x86`.
   + Si votre type d'environnement est `ARM_EC2` le cas, assurez-vous que votre **architecture** AMI est 64 bits`Arm`.
   + Si votre type d'environnement est `WINDOWS_EC2` le cas, assurez-vous que votre **architecture** AMI est 64 bits`x86`.
   + L'AMI autorise le CodeBuild service **Organization ARN**. Pour une liste des organisations ARNs, voir[Amazon Machine Images (AMI)](fleets.reserved-capacity-fleets.md#ami).
   + Si l'AMI est chiffrée à l'aide d'une AWS KMS clé, AWS KMS celle-ci doit également autoriser l'**ID d'organisation** du CodeBuild service. Pour une liste des organisations IDs, voir[Amazon Machine Images (AMI)](fleets.reserved-capacity-fleets.md#ami). Pour plus d'informations sur AWS KMS les clés, consultez [Autoriser les organisations et OUs utiliser une clé KMS](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/share-amis-with-organizations-and-OUs.html#allow-org-ou-to-use-key) dans le guide de l'*utilisateur Amazon EC2*. Pour autoriser CodeBuild l'organisation à utiliser une clé KMS, ajoutez la déclaration suivante à la politique de clé :

     ```
     {
         "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"
             }
         }
     }
     ```
   + Dans le champ **Rôle du service de flotte**, accordez les autorisations Amazon EC2 suivantes :

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

****  

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

------

## Limitations des flottes à capacité réservée
<a name="fleets.limitations"></a>

Il existe certains cas d'utilisation que les flottes de capacité réservée ne prennent pas en charge, et s'ils vous concernent, utilisez plutôt des flottes à la demande :
+ Les flottes de capacité réservée ne prennent pas en charge les indicateurs d'utilisation des builds.
+ Les flottes de macOS à capacité réservée ne prennent pas en charge les sessions de débogage.

Pour plus d'informations sur les limites et les quotas, consultez[Flottes informatiques](limits.md#fleet-limits).

# Propriétés du parc à capacité réservée
<a name="fleets.reserved-capacity-fleets"></a>

Un parc à capacité réservée contient les propriétés suivantes. Pour plus d'informations sur les flottes de capacité réservée, consultez[Exécutez des builds sur des flottes à capacité réservée](fleets.md). 

**Système d’exploitation**  
Le système d'exploitation. Les systèmes d'exploitation suivants sont disponibles :  
+ Amazon Linux
+ macOS
+ Windows Server 2019
+ Windows Server 2022

**Architecture**  
L'architecture du processeur. Les architectures disponibles sont les suivantes :  
+ x86\$164
+ Bras 64

**Type d'environnement**  
Les types d'environnement disponibles lorsque **Amazon Linux** est sélectionné. Les types d'environnement suivants sont disponibles :  
+ Linux EC2
+ GPU Linux

**Type d'instance de calcul**  
Les configurations de calcul pour les instances de flotte.    
**Sélection guidée**  
Spécifiez différents types de calcul en sélectionnant les paramètres du vCPU, de la mémoire et de l'espace disque. Pour plus d'informations sur la disponibilité des types de calcul par région, consultez[À propos des types d'environnement de capacité réservée](build-env-ref-compute-types.md#environment-reserved-capacity.types).  
**Instance personnalisée**  
Spécifiez manuellement le type d'instance souhaité.

**Capacity**  
Le nombre initial de machines allouées au parc, qui définit le nombre de builds pouvant être exécutés en parallèle.

**Comportement de débordement**  
Définit le comportement lorsque le nombre de builds dépasse la capacité de la flotte.    
**À la demande**  
Les versions Overflow s'exécutent CodeBuild à la demande.  
Si vous choisissez de définir votre comportement de débordement à la demande lors de la création d'une flotte connectée au VPC, assurez-vous d'ajouter les autorisations VPC requises à votre rôle de service de projet. Pour plus d'informations, consultez [Exemple de déclaration de politique autorisant CodeBuild l'accès aux AWS services nécessaires à la création d'une interface réseau VPC](auth-and-access-control-iam-identity-based-access-control.md#customer-managed-policies-example-create-vpc-network-interface).
Si vous choisissez de définir votre comportement de débordement à la demande, notez que les versions de débordement seront facturées séparément, comme pour Amazon EC2 à la demande. Pour de plus amples informations, veuillez consulter [https://aws.amazon.com/codebuild/pricing/](https://aws.amazon.com/codebuild/pricing/).  
**File d'attente**  
Les cycles de build sont placés dans une file d'attente jusqu'à ce qu'une machine soit disponible. Cela limite les coûts supplémentaires car aucune machine supplémentaire n'est allouée.

**Amazon Machine Images (AMI)**  
Les propriétés Amazon Machine Image (AMI) de votre flotte. Les propriétés suivantes sont prises en charge par CodeBuild :      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/fleets.reserved-capacity-fleets.html)

**Configuration supplémentaire**    
**VPC - en option**  
Le VPC auquel votre CodeBuild flotte aura accès. Pour de plus amples informations, veuillez consulter [Utilisation AWS CodeBuild avec Amazon Virtual Private Cloud](vpc-support.md).  
Si une dérogation de flotte est spécifiée lors de l'appel de l' StartBuild API, la configuration VPC du projet CodeBuild sera ignorée.  
**Sous-réseaux**  
Les sous-réseaux VPC CodeBuild utilisés pour configurer votre configuration VPC. Notez que les flottes de capacité réservée ne prennent en charge qu'un seul sous-réseau dans une seule zone de disponibilité. Assurez-vous également que vos sous-réseaux incluent une passerelle NAT.  
**Groupes de sécurité**  
Les groupes de sécurité VPC CodeBuild utilisés avec votre VPC. Assurez-vous que vos groupes de sécurité autorisent les connexions sortantes.  
**Rôle du service de flotte**  
Définit le rôle de service de votre flotte à partir d'un rôle de service existant dans votre compte.  
**Définir les configurations de proxy (facultatif)**  
Configurations de proxy qui appliquent un contrôle d'accès réseau à vos instances de capacité réservée. Pour de plus amples informations, veuillez consulter [Utilisation AWS CodeBuild avec un serveur proxy géré](run-codebuild-in-managed-proxy-server.md).  
Les configurations de proxy ne sont pas compatibles avec VPC, Windows ou macOS.  
**Comportement par défaut**  
Définit le comportement du trafic sortant.    
**Allow**  
Autorise le trafic sortant vers toutes les destinations par défaut.  
**Refuser**  
Refuse le trafic sortant vers toutes les destinations par défaut.  
**Règles relatives au proxy**  
Spécifie les domaines de destination ou IPs pour autoriser ou refuser le contrôle d'accès au réseau.

# Échantillons de capacité réservée avec AWS CodeBuild
<a name="reserved-capacity-samples"></a>

Ces échantillons peuvent être utilisés pour expérimenter avec des flottes de capacité réservée dans CodeBuild.

**Topics**
+ [Exemple de mise en cache avec capacité réservée](#reserved-capacity-samples.caching)

## Exemple de mise en cache avec capacité réservée
<a name="reserved-capacity-samples.caching"></a>

Un cache peut stocker les éléments réutilisables de votre environnement de génération et les utiliser sur plusieurs générations. Cet exemple montre comment activer la mise en cache dans votre projet de construction en utilisant une capacité réservée. Pour de plus amples informations, veuillez consulter [Des mises en cache pour améliorer les performances](build-caching.md).

Vous pouvez commencer par spécifier un ou plusieurs modes de cache dans les paramètres de votre projet :

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

**Note**  
Assurez-vous d'activer le mode privilégié afin d'utiliser le cache de couche Docker.

Les paramètres buildspec de votre projet doivent ressembler à ce qui suit :

```
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'
```

Vous pouvez commencer par exécuter une compilation avec le nouveau projet pour démarrer le cache. Une fois cette opération terminée, vous devez commencer une autre version avec une spécification de construction alternative, similaire à ce qui suit :

```
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'
```

# Exécuter des builds par lots
<a name="batch-build"></a>

Vous pouvez l'utiliser AWS CodeBuild pour exécuter des versions simultanées et coordonnées d'un projet avec des versions par lots. 

**Topics**
+ [Rôle de sécurité](#batch_security_role)
+ [Types de build par lots](#batch_build_types)
+ [Mode de rapport par lots](#batch-report-mode)
+ [En savoir plus](#batch_more_info)

## Rôle de sécurité
<a name="batch_security_role"></a>

Les générations en lot introduisent un nouveau rôle de sécurité dans la configuration par lots. Ce nouveau rôle est obligatoire car CodeBuild il doit être capable d'appeler les `RetryBuild` actions `StartBuild``StopBuild`, et en votre nom pour exécuter des builds dans le cadre d'un lot. Les clients doivent utiliser un nouveau rôle, et non le même rôle qu’ils utilisent dans leur build, pour deux raisons :
+ Donner au rôle de build `StartBuild`, `StopBuild` et `RetryBuild` les autorisations permettrait à une seule build de lancer davantage de builds via le buildspec.
+ CodeBuild les versions par lots fournissent des restrictions qui limitent le nombre de versions et les types de calcul qui peuvent être utilisés pour les versions du lot. Si le rôle de build dispose de ces autorisations, il est possible que les builds elles-mêmes puissent contourner ces restrictions.

## Types de build par lots
<a name="batch_build_types"></a>

CodeBuild prend en charge les types de génération par lots suivants :

**Topics**
+ [Construire un graphe](#batch_build_graph)
+ [Construire une liste](#batch_build_list)
+ [Construire une matrice](#batch_build_matrix)
+ [Construire un ventilateur](#batch_build_fanout)

### Construire un graphe
<a name="batch_build_graph"></a>

Un graphe de génération définit un ensemble de tâches qui dépendent d'autres tâches du lot. 

L'exemple suivant définit un graphe de construction qui crée une chaîne de dépendances. 

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

Dans cet exemple :
+ `build1`s'exécute en premier car il n'a aucune dépendance.
+ `build2`dépend de`build1`, donc `build2` s'exécute une fois `build1` terminé.
+ `build3`dépend de`build2`, donc `build3` s'exécute une fois `build2` terminé.

Pour plus d'informations sur la syntaxe buildspec du graphe de construction, consultez. [`batch/build-graph`](batch-build-buildspec.md#build-spec.batch.build-graph)

### Construire une liste
<a name="batch_build_list"></a>

Une liste de build définit un certain nombre de tâches exécutées en parallèle. 

L'exemple suivant définit une liste de build. Les `build2` builds `build1` et seront exécutés en parallèle.

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

Pour plus d'informations sur la syntaxe buildspec de la liste de compilation, consultez. [`batch/build-list`](batch-build-buildspec.md#build-spec.batch.build-list)

### Construire une matrice
<a name="batch_build_matrix"></a>

Une matrice de génération définit les tâches avec différentes configurations qui s'exécutent en parallèle. CodeBuild crée une version distincte pour chaque combinaison de configuration possible. 

L'exemple suivant montre une matrice de construction avec deux fichiers buildspec et trois valeurs pour une variable d'environnement.

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

Dans cet exemple, CodeBuild crée six versions :
+ `matrix1.yml` avec `$MY_VAR=VALUE1`
+ `matrix1.yml` avec `$MY_VAR=VALUE2`
+ `matrix1.yml` avec `$MY_VAR=VALUE3`
+ `matrix2.yml` avec `$MY_VAR=VALUE1`
+ `matrix2.yml` avec `$MY_VAR=VALUE2`
+ `matrix2.yml` avec `$MY_VAR=VALUE3`

Chaque build comportera les paramètres suivants :
+ `ignore-failure`réglé sur `false`
+ `env/type`réglé sur `LINUX_CONTAINER`
+ `env/image`réglé sur `aws/codebuild/amazonlinux-x86_64-standard:4.0`
+ `env/privileged-mode`réglé sur `true`

Ces builds s'exécutent en parallèle.

Pour plus d'informations sur la syntaxe buildspec de la matrice de construction, consultez. [`batch/build-matrix`](batch-build-buildspec.md#build-spec.batch.build-matrix)

### Construire un ventilateur
<a name="batch_build_fanout"></a>

Un fanout de build définit une tâche qui sera divisée en plusieurs builds dans le lot. Cela peut être utilisé pour exécuter des tests en parallèle. CodeBuild crée une version distincte pour chaque fragment de cas de test en fonction de la valeur définie dans le `parallelism` champ.

L'exemple suivant définit un fanout de build qui crée cinq builds exécutés en parallèle.

```
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'
```

Dans cet exemple, en supposant que 100 tests doivent être exécutés, CodeBuild crée cinq versions qui exécutent chacune 20 tests en parallèle.

Pour plus d'informations sur la syntaxe buildspec du graphe de construction, consultez. [`batch/build-fanout`](batch-build-buildspec.md#build-spec.batch.build-fanout)

## Mode de rapport par lots
<a name="batch-report-mode"></a>

Si le fournisseur source de votre projet est Bitbucket ou GitHub Enterprise GitHub, et que votre projet est configuré pour signaler les statuts de construction au fournisseur source, vous pouvez sélectionner la manière dont vous souhaitez que les statuts de génération par lots soient envoyés au fournisseur source. Vous pouvez choisir d'envoyer les statuts sous forme de rapport d'état agrégé unique pour le lot, ou de faire en sorte que le statut de chaque build du lot soit signalé individuellement.

Pour plus d’informations, consultez les rubriques suivantes :
+ [Configuration par lots (création)](create-project.md#create-project-console-batch-config)
+ [Configuration par lots (mise à jour)](change-project.md#change-project-console-batch-config)

## En savoir plus
<a name="batch_more_info"></a>

Pour plus d’informations, consultez les rubriques suivantes :
+ [Référence Batch Build Buildspec](batch-build-buildspec.md)
+ [Configuration par lots](create-project.md#create-project-console-batch-config)
+ [Exécuter une compilation par lots (AWS CLI)](run-batch-build-cli.md)
+ [Arrêter les compilations par lots AWS CodeBuild](stop-batch-build.md)

# Exécuter des tests parallèles dans des builds par lots
<a name="parallel-test"></a>

Vous pouvez l'utiliser AWS CodeBuild pour exécuter des tests parallèles dans des builds par lots. L'exécution parallèle de tests est une approche de test dans laquelle plusieurs cas de test s'exécutent simultanément sur différents environnements, machines ou navigateurs, plutôt que de s'exécuter de manière séquentielle. Cette approche permet de réduire considérablement le temps global d'exécution des tests et d'améliorer l'efficacité des tests. Dans CodeBuild, vous pouvez répartir vos tests sur plusieurs environnements et les exécuter simultanément.

Les principaux avantages de l'exécution de tests en parallèle sont les suivants :

1. **Temps d'exécution réduit** : les tests qui dureraient plusieurs heures de manière séquentielle peuvent être achevés en quelques minutes.

1. **Meilleure utilisation des ressources** : utilise efficacement les ressources informatiques disponibles.

1. **Feedback anticipé** - L'achèvement plus rapide des tests signifie un retour d'information plus rapide pour les développeurs.

1. **Rentable** : permet d'économiser du temps et des coûts informatiques à long terme.

Lors de la mise en œuvre de l'exécution de tests en parallèle, deux approches principales sont généralement envisagées : les environnements séparés et le multithreading. Bien que les deux méthodes visent à réaliser des tests simultanément, elles diffèrent considérablement en termes de mise en œuvre et d'efficacité. Les environnements distincts créent des instances isolées dans lesquelles chaque suite de tests s'exécute indépendamment, tandis que le multithreading exécute plusieurs tests simultanément dans le même espace de processus en utilisant différents threads.

Les principaux avantages des environnements séparés par rapport au multithreading sont les suivants :

1. **Isolation** - Chaque test s'exécute dans un environnement complètement isolé, évitant ainsi toute interférence entre les tests.

1. **Conflits de ressources** : aucune concurrence pour les ressources partagées, ce qui se produit souvent dans le multithreading.

1. **Stabilité** : moins sujet aux conditions de course et aux problèmes de synchronisation.

1. **Débogage facilité** : lorsque les tests échouent, il est plus simple d'en identifier la cause car chaque environnement est indépendant.

1. **Gestion des états** : gérez facilement les problèmes d'état partagés qui entravent les tests multithread.

1. **Meilleure évolutivité - Possibilité** d'ajouter facilement d'autres environnements sans complexité.

**Topics**
+ [Support dans AWS CodeBuild](#parallel-test-support)
+ [Activer l'exécution de tests en parallèle dans les versions par lots](parallel-test-enable.md)
+ [Utilisez la `codebuild-tests-run` commande CLI](parallel-test-tests-run.md)
+ [Utilisez la `codebuild-glob-search` commande CLI](parallel-test-glob-search.md)
+ [À propos du fractionnement des tests](parallel-test-splitting.md)
+ [Fusionnez automatiquement les rapports de construction individuels](parallel-test-auto-merge.md)
+ [Exemple d'exécution de tests en parallèle pour différents frameworks de test](sample-parallel-test.md)

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

AWS CodeBuild fournit un support robuste pour l'exécution de tests en parallèle grâce à sa fonctionnalité de génération par lots, spécialement conçue pour tirer parti de l'exécution d'environnements séparés. Cette mise en œuvre s'aligne parfaitement sur les avantages des environnements de test isolés.

**Construction par lots avec distribution de tests**  
CodeBuildla fonctionnalité de génération par lots permet de créer plusieurs environnements de génération qui s'exécutent simultanément. Chaque environnement fonctionne comme une unité complètement isolée, avec ses propres ressources informatiques, son propre environnement d'exécution et ses propres dépendances. Grâce à la configuration de génération par lots, vous pouvez spécifier le nombre d'environnements parallèles dont ils ont besoin et la manière dont les tests doivent être répartis entre eux.

**Tester la CLI de partitionnement**  
CodeBuild inclut un mécanisme de distribution de tests intégré via son outil CLI`codebuild-tests-run`, qui divise automatiquement les tests en différents environnements.

**Agrégation de rapports**  
L'un des principaux points forts de la mise en œuvre CodeBuild est sa capacité à gérer l'agrégation des résultats de test de manière fluide. Lorsque les tests s'exécutent dans des environnements distincts, collecte et combine CodeBuild automatiquement les rapports de test de chaque environnement dans un rapport de test unifié au niveau de la génération par lots. Cette consolidation fournit une vue complète des résultats des tests tout en préservant les avantages d'efficacité de l'exécution parallèle.

Le schéma suivant explique le concept complet de l'exécution de tests en parallèle dans AWS CodeBuild.

![\[Schéma conceptuel de l'exécution de tests en parallèle.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/parallel-test.png)


# Activer l'exécution de tests en parallèle dans les versions par lots
<a name="parallel-test-enable"></a>

Pour exécuter des tests en parallèle, mettez à jour le fichier buildspec de compilation par lots pour inclure le champ build-fanout et le nombre de builds parallèles pour diviser la suite de tests dans le champ, comme indiqué ci-dessous. `parallelism` Le `parallelism` champ indique le nombre d'exécuteurs indépendants configurés pour exécuter la suite de tests.

Pour exécuter les tests dans plusieurs environnements d'exécution parallèle, définissez le `parallelism` champ sur une valeur supérieure à zéro. Dans l'exemple ci-dessous, `parallelism` est défini sur cinq, ce qui signifie qu'il CodeBuild démarre cinq versions identiques qui exécutent une partie de la suite de tests en parallèle.

Vous pouvez utiliser la commande [codebuild-tests-run](parallel-test-tests-run.md)CLI pour diviser et exécuter vos tests. Vos fichiers de test seront divisés et une partie de vos tests sera exécutée dans chaque version. Cela réduit le temps total nécessaire à l'exécution de la suite de tests complète. Dans l'exemple suivant, les tests seront divisés en cinq et les points de division seront calculés en fonction du nom des tests.

```
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 les rapports sont configurés pour la version build-fanout, les rapports de test sont générés séparément pour chaque version, qui peuvent être consultés sous l'onglet **Rapports** des versions correspondantes dans la console. AWS CodeBuild 

Pour plus d'informations sur la façon d'exécuter des tests parallèles par lots, consultez[Exemple d'exécution de tests en parallèle pour différents frameworks de test](sample-parallel-test.md).

# Utilisez la `codebuild-tests-run` commande CLI
<a name="parallel-test-tests-run"></a>

AWS CodeBuild fournit une CLI qui prendra la commande de test et l'emplacement du fichier de test en entrée. La CLI avec ces entrées divisera les tests en un nombre de partitions tel que spécifié dans le `parallelism` champ en fonction des noms de fichiers de test. L'attribution des fichiers de test au shard est décidée par la stratégie de sharding.

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

Le tableau suivant décrit les champs de la commande `codebuild-tests-run` CLI.


| Nom de champ | Type | Obligatoire ou facultatif | Définition | 
| --- | --- | --- | --- | 
|  `test-command`  |  String  |  Obligatoire  |  Cette commande est utilisée pour exécuter les tests.  | 
|  `files-search`  |  String  |  Obligatoire  |  Cette commande fournit une liste de fichiers de test. Vous pouvez utiliser la commande [codebuild-glob-search](parallel-test-glob-search.md)CLI AWS CodeBuild fournie ou tout autre outil de recherche de fichiers de votre choix.  Assurez-vous que la `files-search` commande affiche des noms de fichiers, séparés chacun par une nouvelle ligne.   | 
|  `sharding-strategy`  |  Enum  |  Facultatif  |  Valeurs valides : `equal-distribution` (par défaut), `stability` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/parallel-test-tests-run.html) Pour de plus amples informations, veuillez consulter [À propos du fractionnement des tests](parallel-test-splitting.md).  | 

La `codebuild-tests-run` CLI fonctionne d'abord pour identifier la liste des fichiers de test à l'aide de la commande fournie dans le `files-search` paramètre. Il détermine ensuite un sous-ensemble de fichiers de test désignés pour la partition actuelle (environnement) en utilisant la stratégie de partitionnement spécifiée. Enfin, ce sous-ensemble de fichiers de test est formaté sous forme de liste séparée par des espaces et ajouté à la fin de la commande fournie dans le `test-command` paramètre avant d'être exécuté.

Pour les frameworks de test qui n'acceptent pas les listes séparées par des espaces, la `codebuild-tests-run` CLI fournit une alternative flexible via la variable d'`CODEBUILD_CURRENT_SHARD_FILES`environnement. Cette variable contient une liste séparée par de nouvelles lignes de chemins de fichiers de test désignés pour la partition de build actuelle. En tirant parti de cette variable d'environnement, vous pouvez facilement vous adapter aux différentes exigences du framework de test, en prenant en compte ceux qui attendent des formats d'entrée différents de ceux des listes séparées par des espaces. De plus, vous pouvez également formater les noms des fichiers de test selon les besoins du framework de test. Voici un exemple d'`CODEBUILD_CURRENT_SHARD_FILES`utilisation sous Linux avec le framework Django. Voici `CODEBUILD_CURRENT_SHARD_FILES` ce qui est utilisé pour obtenir les chemins de fichiers de *notation par points* supportés par 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'
```

**Note**  
Notez que la variable d'`CODEBUILD_CURRENT_SHARD_FILES`environnement ne peut être utilisée que dans le cadre de la `codebuild-tests-run` CLI.  
De plus, si vous utilisez la commande de test `CODEBUILD_CURRENT_SHARD_FILES` interne, mettez-la entre `CODEBUILD_CURRENT_SHARD_FILES` guillemets, comme indiqué dans l'exemple ci-dessus.

# Utilisez la `codebuild-glob-search` commande CLI
<a name="parallel-test-glob-search"></a>

AWS CodeBuild fournit un outil CLI intégré appelé `codebuild-glob-search` qui vous permet de rechercher des fichiers dans votre répertoire de travail en fonction d'un ou de plusieurs modèles globaux. Cet outil peut être particulièrement utile lorsque vous souhaitez exécuter des tests sur des fichiers ou des répertoires spécifiques au sein de votre projet.

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

La `codebuild-glob-search` CLI utilise la syntaxe d'utilisation suivante :

```
codebuild-glob-search <glob_pattern1> [<glob_pattern2> ...]
```
+ `<glob_pattern1>``<glob_pattern2>`, etc. : un ou plusieurs modèles globaux à comparer aux fichiers de votre répertoire de travail.
+ `*`: Correspond à n'importe quelle séquence de caractères (à l'exception des séparateurs de chemin).
+ `**`: Correspond à n'importe quelle séquence de caractères (y compris les séparateurs de chemin).

**Note**  
Assurez-vous que la chaîne globale contient des guillemets. Pour vérifier les résultats de la correspondance de modèles, utilisez la `echo` commande.  

```
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 produira une liste de chemins de fichiers séparés par de nouvelles lignes qui correspondent aux modèles globaux fournis. Les chemins de fichiers renvoyés seront relatifs au répertoire de travail.

Si aucun fichier correspondant aux modèles fournis n'est trouvé, la CLI affiche un message indiquant qu'aucun fichier n'a été trouvé.

Notez que les répertoires trouvés selon un modèle donné seront exclus des résultats de recherche.

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

Si vous souhaitez rechercher uniquement les fichiers du répertoire tests et de ses sous-répertoires dotés d'une `.js` extension, vous pouvez utiliser la commande suivante avec la `codebuild-glob-search` CLI :

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

Cette commande recherchera tous les fichiers portant une `.js` extension dans le `__tests__` répertoire et ses sous-répertoires, comme indiqué par le modèle.

# À propos du fractionnement des tests
<a name="parallel-test-splitting"></a>

AWS CodeBuild la fonction de division des tests vous permet de paralléliser l'exécution de votre suite de tests sur plusieurs instances de calcul, réduisant ainsi la durée globale d'exécution des tests. Cette fonctionnalité est activée par le biais de la configuration par lots dans les paramètres de votre CodeBuild projet et de l'`codebuild-tests-run`utilitaire dans votre fichier buildspec.

Les tests sont divisés en fonction de la stratégie de partitionnement spécifiée. CodeBuild propose deux stratégies de partitionnement, comme indiqué ci-dessous :

Répartition égale  
La stratégie de `equal-distribution` partitionnement divise les tests entre des versions parallèles en fonction de l'ordre alphabétique des noms de fichiers de test. Cette approche trie d'abord les fichiers de test, puis utilise une méthode basée sur des fragments pour les distribuer, en veillant à ce que les fichiers similaires soient regroupés pour les tests. Il est recommandé de le faire lorsqu'il s'agit d'un ensemble relativement restreint de fichiers de test. Bien que cette méthode vise à allouer un nombre approximativement égal de fichiers à chaque partition, avec une différence maximale d'un, elle ne garantit pas la stabilité. Lorsque des fichiers de test sont ajoutés ou supprimés dans les versions suivantes, la distribution des fichiers existants peut changer, ce qui peut entraîner une réaffectation entre les partitions.

Stabilité  
La stratégie de `stability` partitionnement utilise un algorithme de hachage cohérent pour répartir les tests entre les partitions, garantissant ainsi la stabilité de la distribution des fichiers. Lorsque de nouveaux fichiers sont ajoutés ou supprimés, cette approche garantit que les file-to-shard assignations existantes restent largement inchangées. Pour les suites de tests de grande taille, il est recommandé d'utiliser l'option de stabilité pour répartir uniformément les tests sur les partitions. Ce mécanisme vise à fournir une distribution quasi égale, en veillant à ce que chaque partition reçoive un nombre similaire de fichiers, avec une variance minimale. Bien que la stratégie de stabilité ne garantisse pas une distribution égale idéale, elle propose une distribution quasi égale qui permet de maintenir la cohérence des attributions de fichiers entre les versions, même lorsque des fichiers sont ajoutés ou supprimés.

Pour activer le fractionnement des tests, vous devez configurer la section par lots dans les paramètres de votre CodeBuild projet, en spécifiant le `parallelism` niveau souhaité et les autres paramètres pertinents. En outre, vous devrez inclure l'`codebuild-tests-run`utilitaire dans votre fichier buildspec, ainsi que les commandes de test et la méthode de division appropriées.

# Fusionnez automatiquement les rapports de construction individuels
<a name="parallel-test-auto-merge"></a>

Dans les versions par lots Fanout, AWS CodeBuild prend en charge la fusion automatique des rapports de construction individuels en un rapport consolidé par lots. Cette fonctionnalité fournit une vue complète des résultats des tests et de la couverture du code pour toutes les versions d'un lot.

## Comment ça marche
<a name="parallel-test-auto-merge.how"></a>

Lors de l'exécution de builds `fanout` par lots, chaque build génère [des rapports de test](test-reporting.md). CodeBuild consolide ensuite automatiquement les rapports identiques provenant de différentes versions dans un rapport unifié, qui est joint à la génération par lots. Ces rapports consolidés sont facilement accessibles via le `reportArns` champ de l'[ BatchGetBuildBatches](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_BatchGetBuildBatches.html#CodeBuild-BatchGetBuildBatches-response-buildBatches)API et peuvent également être consultés dans l'onglet **Rapports** de la console. Cette fonctionnalité de fusion s'étend également aux rapports découverts automatiquement.

Les rapports consolidés sont créés sous [des groupes de rapports](test-report-group.md) qui sont soit spécifiés dans le buildspec, soit découverts automatiquement par. CodeBuild Vous pouvez analyser les tendances des rapports fusionnés directement sous ces groupes de rapports, fournissant ainsi des informations précieuses sur les performances globales de construction et les indicateurs de qualité des versions historiques d'un même projet de génération par lots.

Pour chaque build individuel du lot, des groupes de rapports distincts CodeBuild sont automatiquement créés. Ils suivent une convention de dénomination spécifique, combinant le nom du groupe de rapports de génération par lots avec le suffixe`BuildFanoutShard<shard_number>`, où le `shard_number` représente le numéro de la partition dans laquelle le groupe de rapports est créé. Cette organisation vous permet de suivre et d'analyser les tendances au niveau des versions consolidées et individuelles, offrant ainsi une flexibilité dans la manière dont vous surveillez et évaluez leurs processus de création.

Le rapport de construction par lots suit la même structure que les rapports de [génération individuels](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_Report.html). Les champs clés suivants de l'onglet **Rapport** sont spécifiques aux rapports de génération par lots :

**État du rapport de génération par lots**  
L'état des rapports de génération par lots suit des règles spécifiques en fonction du type de rapport :  
+ Rapports d'essais :
  + Réussite : le statut est défini sur Réussite lorsque tous les rapports de construction individuels ont abouti.
  + Échec : le statut est défini sur Échec si un rapport de génération individuel a échoué.
  + Incomplet : le statut est marqué comme incomplet si un rapport de construction individuel est manquant ou a un statut incomplet.
+ Rapports sur la couverture du code :
  + Terminé : le statut est défini comme terminé lorsque tous les rapports de construction individuels sont terminés.
  + Échec : le statut est défini sur Échec si un rapport de génération individuel a échoué.
  + Incomplet : le statut est marqué comme incomplet si un rapport de construction individuel est manquant ou a un statut incomplet.

**Résumé du test**  
Le rapport de test fusionné consolide les champs suivants de tous les rapports de construction individuels :  
+ duration-in-nano-seconds: durée maximale du test en nanosecondes pour tous les rapports de construction individuels.
+ total : le nombre combiné de tous les cas de test, en additionnant le nombre total de tests de chaque version.
+ status-counts : fournit une vue consolidée des statuts de test tels que réussis, échoués ou ignorés, calculée en agrégeant le nombre de chaque type de statut sur toutes les versions individuelles.

**Résumé de la couverture du code**  
Le rapport de couverture du code fusionné combine les champs de toutes les versions individuelles en utilisant les calculs suivants :  
+ branches couvertes : somme de toutes les branches couvertes à partir des rapports individuels.
+ branches-missed : somme de toutes les branches manquantes dans les rapports individuels.
+ branch-coverage-percentage: `(Total covered branches / Total branches) * 100`
+ lignes couvertes : somme de toutes les lignes couvertes dans les rapports individuels.
+ lines-missed : somme de toutes les lignes manquées dans les rapports individuels.
+ lines-coverage-percentage: `(Total covered lines / Total lines) * 100`

**ID d'exécution**  
L'ARN de génération par lots.

**Cas de test**  
Le rapport fusionné contient une liste consolidée de tous les cas de test issus de versions individuelles, accessible via l'[DescribeTestCases](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeTestCases.html)API et le rapport de génération par lots dans la console.

**Couvertures par code**  
Le rapport de couverture du code fusionné fournit des informations consolidées sur la couverture des lignes et des branches pour chaque fichier dans toutes les versions individuelles, accessibles via l'[DescribeCodeCoverages](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_DescribeCodeCoverages.html)API et le rapport de génération par lots dans la console. Remarque : Pour les fichiers couverts par plusieurs fichiers de test répartis sur différentes partitions, le rapport fusionné utilise les critères de sélection suivants :  

1. La sélection principale est basée sur la couverture de lignes la plus élevée parmi les fragments.

1. Si la couverture des lignes est égale sur plusieurs partitions, la partition présentant la couverture de branches la plus élevée est sélectionnée.

# Exemple d'exécution de tests en parallèle pour différents frameworks de test
<a name="sample-parallel-test"></a>

Vous pouvez utiliser la commande `codebuild-tests-run` CLI pour diviser et exécuter vos tests dans des environnements d'exécution parallèles. La section suivante fournit `buildspec.yml` des exemples de différents frameworks, illustrant l'utilisation de la `codebuild-tests-run` commande.
+ Chaque exemple ci-dessous inclut un `parallelism` niveau de cinq, ce qui signifie que cinq environnements d'exécution identiques seront créés pour répartir vos tests. Vous pouvez choisir un `parallelism` niveau adapté à votre projet en modifiant la `parallelism` valeur dans la `build-fanout` section.
+ Chaque exemple ci-dessous montre comment configurer vos tests pour qu'ils soient divisés par le nom du fichier de test, qui est par défaut. Cela répartit les tests de manière uniforme dans les environnements d'exécution parallèle.

Avant de commencer, consultez [Exécuter des tests parallèles dans des builds par lots](parallel-test.md) pour plus d'informations.

Pour obtenir la liste complète des options disponibles lors de l'utilisation de la commande `codebuild-tests-run` CLI, consultez[Utilisez la `codebuild-tests-run` commande CLI](parallel-test-tests-run.md).

**Topics**
+ [Configurer des tests parallèles avec Django](sample-parallel-test-django.md)
+ [Configurer des tests parallèles avec Elixir](sample-parallel-test-elixir.md)
+ [Configurer des tests parallèles avec Go](sample-parallel-test-go.md)
+ [Configuration de tests parallèles avec Java (Maven)](sample-parallel-test-java-maven.md)
+ [Configurer des tests parallèles avec Javascript (Jest)](sample-parallel-test-javascript.md)
+ [Configurer des tests parallèles avec Kotlin](sample-parallel-test-kotlin.md)
+ [Configurez des tests parallèles avec PHPUnit](sample-parallel-test-phpunit.md)
+ [Configurer des tests parallèles avec Pytest](sample-parallel-test-python.md)
+ [Configurer des tests parallèles avec Ruby (Cucumber)](sample-parallel-test-ruby-cucumber.md)
+ [Configurer des tests parallèles avec Ruby (RSpec)](sample-parallel-test-ruby.md)

# Configurer des tests parallèles avec Django
<a name="sample-parallel-test-django"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Django sur une plate-forme 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'
```

L'exemple ci-dessus montre l'utilisation de la variable d'environnement`CODEBUILD_CURRENT_SHARD_FILES`. Ici `CODEBUILD_CURRENT_SHARD_FILES` est utilisé pour récupérer les chemins des fichiers de notation par points supportés par Django. Utilisez des guillemets doubles `CODEBUILD_CURRENT_SHARD_FILES` à l'intérieur, comme indiqué ci-dessus.

# Configurer des tests parallèles avec Elixir
<a name="sample-parallel-test-elixir"></a>

Voici un exemple de test `buildspec.yml` illustrant l'exécution parallèle d'un test avec Elixir sur une plateforme 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"
```

# Configurer des tests parallèles avec Go
<a name="sample-parallel-test-go"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Go sur une plate-forme 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"
```

Dans l'exemple ci-dessus, `calculator.go` la fonction contient des fonctions mathématiques simples à tester et tous les fichiers de test se trouvent `calc` dans un dossier. `calculator.go`

# Configuration de tests parallèles avec Java (Maven)
<a name="sample-parallel-test-java-maven"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Java sur une plate-forme 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"
```

Dans l'exemple donné, la variable d'environnement `CODEBUILD_CURRENT_SHARD_FILES` contient des fichiers de test dans le shard actuel, séparés par des nouvelles lignes. Ces fichiers sont convertis en une liste de noms de classes séparés par des virgules au format accepté par le `-Dtest` paramètre pour Maven.

# Configurer des tests parallèles avec Javascript (Jest)
<a name="sample-parallel-test-javascript"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Javascript sur une plateforme 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'
```

# Configurer des tests parallèles avec Kotlin
<a name="sample-parallel-test-kotlin"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Kotlin sur une plate-forme 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"
```

Dans l'exemple ci-dessus, la `codebuild-tests-run` CLI est utilisée deux fois. Lors de la première exécution, kotlinc compile les fichiers. La `CODEBUILD_CURRENT_SHARD_FILES` variable récupère les fichiers de test affectés à la partition actuelle, qui sont ensuite convertis en une liste séparée par des espaces. Lors de la deuxième exécution, JUnit exécute les tests. Encore une fois, `CODEBUILD_CURRENT_SHARD_FILES` récupère les fichiers de test assignés à la partition actuelle, mais cette fois ils sont convertis en noms de classes.

# Configurez des tests parallèles avec PHPUnit
<a name="sample-parallel-test-phpunit"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle PHPUnit sur une plate-forme 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'
```

# Configurer des tests parallèles avec Pytest
<a name="sample-parallel-test-python"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Pytest sur une plate-forme 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"
```

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle avec Pytest sur une plate-forme 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"
```

Dans l'exemple ci-dessus, la variable d'`CODEBUILD_CURRENT_SHARD_FILES`environnement est utilisée pour récupérer les fichiers de test affectés à la partition actuelle et transmis sous forme de tableau à la commande pytest.

# Configurer des tests parallèles avec Ruby (Cucumber)
<a name="sample-parallel-test-ruby-cucumber"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests parallèles avec Cucumber sur une plate-forme 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"
```

# Configurer des tests parallèles avec Ruby (RSpec)
<a name="sample-parallel-test-ruby"></a>

Voici un `buildspec.yml` exemple illustrant l'exécution de tests en parallèle RSpec sur une plate-forme 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"
```

# Des mises en cache pour améliorer les performances
<a name="build-caching"></a>

Vous pouvez faire des économies lors de vos générations de projet en utilisant un cache. Un cache peut stocker les éléments réutilisables de votre environnement de génération et les utiliser sur plusieurs générations. Votre projet de génération peut utiliser l'un des deux types de mise en cache suivants : Amazon S3 ou local. Si vous utilisez un cache local, vous devez choisir un ou plusieurs des trois modes de cache : le cache source, le cache de couche Docker et le cache personnalisé. 

**Note**  
Le mode de cache de couche Docker est disponible pour l'environnement Linux uniquement. Si vous choisissez ce mode, vous devez exécuter votre build en mode privilégié. CodeBuild le mode privilégié des projets accorde à son conteneur l'accès à tous les appareils. Pour de plus amples informations, veuillez consulter [Privilège d'exécution et fonctionnalités Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) sur le site web Docker Docs.

**Topics**
+ [Mise en cache d'Amazon S3](caching-s3.md)
+ [Mise en cache locale](caching-local.md)
+ [Spécifier un cache local](specify-caching-local.md)

# Mise en cache d'Amazon S3
<a name="caching-s3"></a>

La mise en cache Amazon S3 stocke le cache dans un compartiment Amazon S3 disponible sur plusieurs hôtes de build. C'est une bonne option pour les artefacts de construction de petite ou moyenne taille qui sont plus coûteux à créer qu'à télécharger.

Pour utiliser Amazon S3 dans une version, vous pouvez spécifier les chemins des fichiers que vous souhaitez mettre en cache`buildspec.yml`. CodeBuild stockera et mettra automatiquement à jour le cache à l'emplacement Amazon S3 configuré sur le projet. Si vous ne spécifiez pas les chemins des fichiers, CodeBuild nous ferons de notre mieux pour mettre en cache les dépendances linguistiques courantes afin d'accélérer les compilations. Vous pouvez consulter les détails du cache dans les journaux de compilation.

En outre, si vous souhaitez disposer de plusieurs versions du cache, vous pouvez définir une clé de cache dans le`buildspec.yml`. CodeBuild stocke le cache dans le contexte de cette clé de cache et crée une copie de cache unique qui ne sera pas mise à jour une fois créée. Les clés de cache peuvent également être partagées entre les projets. Les fonctionnalités telles que les clés dynamiques, le versionnement du cache et le partage du cache entre les versions ne sont disponibles que lorsqu'une clé est spécifiée.

Pour en savoir plus sur la syntaxe du cache dans le fichier buildspec, consultez [cache](build-spec-ref.md#build-spec.cache) la référence buildspec.

**Topics**
+ [Génération de clés dynamiques](#caching-s3-dynamic)
+ [codebuild-hash-files](#caching-s3-dynamic.codebuild-hash-files)
+ [Version du cache](#caching-s3-version)
+ [Partage du cache entre projets](#caching-s3-sharing)
+ [Exemples de spécifications de construction](#caching-s3-examples)

## Génération de clés dynamiques
<a name="caching-s3-dynamic"></a>

Une clé de cache peut inclure des commandes shell et des variables d'environnement pour la rendre unique, ce qui permet des mises à jour automatiques du cache en cas de modification de clé. Par exemple, vous pouvez définir une clé en utilisant le hachage du `package-lock.json` fichier. Lorsque les dépendances de ce fichier changent, le hachage, et donc la clé de cache, change, ce qui déclenche la création automatique d'un nouveau cache.

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

CodeBuild évaluera l'expression `$(codebuild-hash-files package-lock.json)` pour obtenir la clé finale :

```
npm-key-abc123
```

Vous pouvez également définir une clé de cache à l'aide de variables d'environnement, telles que`CODEBUILD_RESOLVED_SOURCE_VERSION`. Cela garantit que chaque fois que votre source change, une nouvelle clé est générée, ce qui entraîne l'enregistrement automatique d'un nouveau cache :

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

CodeBuild évaluera l'expression et obtiendra la clé finale :

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

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

`codebuild-hash-files`est un outil CLI qui calcule un hachage SHA-256 pour un ensemble de fichiers du répertoire CodeBuild source à l'aide de modèles globaux :

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

Voici quelques exemples d'utilisation de `codebuild-hash-files` :

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

## Version du cache
<a name="caching-s3-version"></a>

La version du cache est un hachage généré à partir des chemins des répertoires mis en cache. Si deux caches ont des versions différentes, ils sont traités comme des caches distincts pendant le processus de mise en correspondance. Par exemple, les deux caches suivants sont considérés comme différents car ils font référence à des chemins différents :

```
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/**/*"
```

## Partage du cache entre projets
<a name="caching-s3-sharing"></a>

Vous pouvez utiliser le champ `cacheNamespace` API situé sous la `cache` section pour partager un cache entre plusieurs projets. Ce champ définit l'étendue du cache. Pour partager un cache, vous devez effectuer les opérations suivantes :
+ Utilise le même`cacheNamespace`.
+ Spécifiez le même cache`key`.
+ Définissez des chemins de cache identiques.
+ Utilisez les mêmes compartiments Amazon S3 et `pathPrefix` s'ils sont définis.

Cela garantit la cohérence et permet le partage du cache entre les projets.

### Spécifier un espace de noms de cache (console)
<a name="caching-s3-sharing.console"></a>

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

1. Sélectionnez **Create a project (Créer un projet)**. 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).

1. Dans **Artefacts**, sélectionnez **Configuration supplémentaire**.

1. Pour **le type de cache**, choisissez **Amazon S3**.

1. Pour **Espace de noms du cache - facultatif**, entrez une valeur d'espace de noms.  
![\[Paramètre d'espace de noms du cache dans la CodeBuild console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/s3-cache-namespace.png)

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

### Spécifiez un espace de noms de cache ()AWS CLI
<a name="caching-s3-sharing.cli"></a>

Vous pouvez utiliser le `--cache` paramètre dans le AWS CLI pour spécifier un espace de noms de cache.

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

## Exemples de spécifications de construction
<a name="caching-s3-examples"></a>

Voici plusieurs exemples de spécifications de construction pour les langages courants :

**Topics**
+ [Cache les dépendances de Node.js](#caching-s3-examples.nodejs)
+ [Dépendances du cache en Python](#caching-s3-examples.python)
+ [Dépendances du cache Ruby](#caching-s3-examples.ruby)
+ [Dépendances de Cache Go](#caching-s3-examples.go)

### Cache les dépendances de Node.js
<a name="caching-s3-examples.nodejs"></a>

Si votre projet inclut un `package-lock.json` fichier et l'utilise `npm` pour gérer les dépendances de Node.js, l'exemple suivant montre comment configurer la mise en cache. Par défaut, `npm` installe les dépendances dans le `node_modules` répertoire.

```
version: 0.2

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

### Dépendances du cache en Python
<a name="caching-s3-examples.python"></a>

Si votre projet inclut un `requirements.txt` fichier et utilise pip pour gérer les dépendances Python, l'exemple suivant montre comment configurer la mise en cache. Par défaut, pip installe les packages dans le répertoire du `site-packages` système.

```
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/**/*"
```

En outre, vous pouvez installer des dépendances dans un répertoire spécifique et configurer la mise en cache pour ce répertoire.

```
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/**/*"
```

### Dépendances du cache Ruby
<a name="caching-s3-examples.ruby"></a>

Si votre projet inclut un `Gemfile.lock` fichier et l'utilise `Bundler` pour gérer les dépendances des gemmes, l'exemple suivant montre comment configurer efficacement la mise en cache.

```
version: 0.2

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

### Dépendances de Cache Go
<a name="caching-s3-examples.go"></a>

Si votre projet inclut un `go.sum` fichier et utilise des modules Go pour gérer les dépendances, l'exemple suivant montre comment configurer la mise en cache. Par défaut, les modules Go sont téléchargés et stockés dans le `${GOPATH}/pkg/mod` répertoire.

```
version: 0.2

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

# Mise en cache locale
<a name="caching-local"></a>

La mise en cache locale stocke un cache localement sur un hôte de génération. Le cache est disponible uniquement sur cet hôte de génération. C'est une bonne option pour les artefacts de build de taille intermédiaire à grande, car le cache est immédiatement disponible sur l'hôte de build. Ce n'est pas la meilleure option si vos builds sont rares. Cela signifie que les performances de génération ne sont pas affectés par le temps de transfert réseau.

Si vous choisissez la mise en cache locale, vous devez choisir un ou plusieurs des modes de cache suivants : 
+ Le mode de cache source met en cache des métadonnées Git pour des sources principales et secondaires. Lorsque le cache est créé, les générations suivantes extraient uniquement les modifications apportées entre les validations. Ce mode est un bon choix pour les projets avec un répertoire de travail propre et une source correspondant à un référentiel Git de grande taille. Si vous choisissez cette option et que votre projet n'utilise pas de référentiel Git (AWS CodeCommit, GitHub, GitHub Enterprise Server ou Bitbucket), l'option est ignorée. 
+ Le mode de cache de couche Docker met en cache des couches Docker existantes. Ce mode est un bon choix pour les projets qui génèrent ou extraient des images Docker de taille importante. Il permet d'éviter les problèmes de performances causées par l'extraction d'images Docker de grande taille à partir du réseau. 
**Note**  
Vous pouvez utiliser un cache de couche Docker uniquement dans l'environnement Linux. 
L'indicateur `privileged` doit être défini de sorte que votre projet dispose des autorisations Docker requises.   
Par défaut, le démon Docker est activé pour les versions non VPC. Si vous souhaitez utiliser des conteneurs Docker pour les builds VPC, [consultez Runtime Privilege et Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) Capabilities sur le site Web de Docker Docs et activez le mode privilégié. De plus, Windows ne prend pas en charge le mode privilégié.
Vous devez prendre en compte les implications de sécurité avant d'utiliser un cache de couche Docker. 
+ Le mode de cache personnalisé met en cache les répertoires que vous spécifiez dans le fichier buildspec. Ce mode est un bon choix si votre scénario de génération n'est pas adapté à un des deux autres modes de cache local. Si vous utilisez un cache personnalisé : 
  + Seuls les répertoires peuvent être spécifiés pour la mise en cache. Vous ne pouvez pas spécifier de fichiers individuels. 
  + Les liens symboliques sont utilisés pour référencer les répertoires mis en cache. 
  + Les répertoires mis en cache sont liés à votre génération avant que ses sources de projet soient téléchargées. Les éléments mis en cache remplacent les éléments source s'ils portent le même nom. Les répertoires sont spécifiés à l'aide de chemins de cache dans le fichier buildspec. Pour de plus amples informations, veuillez consulter [Syntaxe d'un fichier buildspec](build-spec-ref.md#build-spec-ref-syntax). 
  + Évitez les noms de répertoire identiques dans la source et dans le cache. Les répertoires mis en cache localement peuvent remplacer ou supprimer le contenu des répertoires du référentiel source portant le même nom.

**Note**  
La mise en cache locale n'est pas prise en charge avec le type d'`LINUX_GPU_CONTAINER`environnement et le type de `BUILD_GENERAL1_2XLARGE` calcul. Pour de plus amples informations, veuillez consulter [Modes et types de calcul de l'environnement de création](build-env-ref-compute-types.md).

**Note**  
La mise en cache locale n'est pas prise en charge lorsque vous configurez CodeBuild pour fonctionner avec un VPC. Pour plus d'informations sur l'utilisation VPCs avec CodeBuild, consultez[Utilisation AWS CodeBuild avec Amazon Virtual Private Cloud](vpc-support.md).

# Spécifier un cache local
<a name="specify-caching-local"></a>

Vous pouvez utiliser la console AWS CLI, le SDK ou CloudFormation pour spécifier un cache local. Pour plus d'informations sur la mise en cache locale, consultez[Mise en cache locale](caching-local.md).

**Topics**
+ [Spécification d'une mise en cache locale (CLI)](#caching-local-cli)
+ [Spécification d'une mise en cache locale (console)](#caching-local-console)
+ [Spécification d'une mise en cache locale (CloudFormation)](#caching-local-cfn)

## Spécification d'une mise en cache locale (CLI)
<a name="caching-local-cli"></a>

Vous pouvez utiliser le `--cache` paramètre dans le AWS CLI pour spécifier chacun des trois types de cache locaux. 
+ Pour spécifier un cache source : 

  ```
  --cache type=LOCAL,mode=[LOCAL_SOURCE_CACHE]
  ```
+ Pour spécifier un cache de couche Docker : 

  ```
  --cache type=LOCAL,mode=[LOCAL_DOCKER_LAYER_CACHE]
  ```
+ Pour spécifier un cache personnalisé : 

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

Pour de plus amples informations, veuillez consulter [Création d'un projet de génération (AWS CLI)](create-project.md#create-project-cli).

## Spécification d'une mise en cache locale (console)
<a name="caching-local-console"></a>

Vous spécifiez un cache dans la section **Artifacts (Artefacts)** de la console. Pour **le type de cache**, choisissez **Amazon S3** ou **Local**. Si vous choisissez **Local**, choisissez une ou plusieurs des trois options de cache local.

![\[Spécifiez un cache local en choisissant une ou plusieurs des trois options de cache local.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/local-cache.png)


Pour de plus amples informations, veuillez consulter [Création d'un projet de génération (console)](create-project.md#create-project-console).

## Spécification d'une mise en cache locale (CloudFormation)
<a name="caching-local-cfn"></a>

Si vous avez l' CloudFormation habitude de spécifier un cache local, sur la `Cache` propriété, pour`Type`, spécifiez`LOCAL`. L'exemple de CloudFormation code au format YAML suivant spécifie les trois types de cache locaux. Vous pouvez spécifier n'importe quelle combinaison de types. Si vous utilisez un cache de couche Docker, sous `Environment`, vous devez définir `PrivilegedMode` sur `true` et `Type` sur `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
```

**Note**  
Par défaut, le démon Docker est activé pour les versions non VPC. Si vous souhaitez utiliser des conteneurs Docker pour les builds VPC, [consultez Runtime Privilege et Linux](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) Capabilities sur le site Web de Docker Docs et activez le mode privilégié. De plus, Windows ne prend pas en charge le mode privilégié.

Pour de plus amples informations, veuillez consulter [Création d'un projet de génération (CloudFormation)](create-project.md#create-project-cloud-formation).

# Debug s'intègre AWS CodeBuild
<a name="debug-builds"></a>

AWS CodeBuild fournit deux méthodes pour le débogage des versions pendant le développement et le dépannage. Vous pouvez utiliser l'environnement CodeBuild Sandbox pour étudier les problèmes et valider les correctifs en temps réel, ou vous pouvez utiliser le gestionnaire de session de AWS Systems Manager pour vous connecter au conteneur de construction et consulter l'état du conteneur.

## Déboguer les builds avec Sandbox CodeBuild
<a name="debug-codebuild-sandbox"></a>

L'environnement CodeBuild sandbox fournit une session de débogage interactive dans un environnement sécurisé et isolé. Vous pouvez interagir avec l'environnement directement via le AWS Management Console ou AWS CLI, exécuter des commandes et valider votre processus de création étape par étape. Il utilise un modèle de facturation rentable à la seconde et prend en charge la même intégration native avec les fournisseurs de sources et de AWS services que votre environnement de construction. Vous pouvez également vous connecter à un environnement sandbox à l'aide de clients SSH ou à partir de vos environnements de développement intégrés ()IDEs.

Pour en savoir plus sur la tarification du CodeBuild sandbox, consultez la [documentation CodeBuild tarifaire](https://aws.amazon.com/codebuild/pricing/#Sandbox). Pour obtenir des instructions détaillées, consultez la [Déboguer les builds avec Sandbox CodeBuild](sandbox.md) documentation.

## Déboguer les builds avec le gestionnaire de session
<a name="debug-codebuild-session-manager"></a>

AWS Systems Manager Session Manager permet d'accéder directement aux versions en cours d'exécution dans leur environnement d'exécution réel. Cette approche vous permet de vous connecter à des conteneurs de build actifs et d'inspecter le processus de construction en temps réel. Vous pouvez examiner le système de fichiers, surveiller les processus en cours d'exécution et résoudre les problèmes au fur et à mesure qu'ils surviennent.

Pour obtenir des instructions détaillées, consultez la [Déboguer les builds avec le gestionnaire de session](session-manager.md) documentation.

# Déboguer les builds avec Sandbox CodeBuild
<a name="sandbox"></a>

Dans AWS CodeBuild, vous pouvez déboguer une version en utilisant le CodeBuild sandbox pour exécuter des commandes personnalisées et résoudre les problèmes liés à votre version.

**Topics**
+ [Conditions préalables](#sandbox-prereq)
+ [Déboguer les versions avec CodeBuild sandbox (console)](#sandbox-console)
+ [Déboguer les builds avec CodeBuild sandbox ()AWS CLI](#sandbox-cli)
+ [Tutoriel : Connexion à un sandbox via SSH](sandbox-ssh-tutorial.md)
+ [Résolution des problèmes AWS CodeBuild de connexion SSH au sandbox](sandbox-troubleshooting.md)

## Conditions préalables
<a name="sandbox-prereq"></a>

Avant d'utiliser un CodeBuild sandbox, assurez-vous que votre rôle de CodeBuild service est conforme à la politique SSM suivante :

------
#### [ 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"
            ]
        }
    ]
}
```

------

## Déboguer les versions avec CodeBuild sandbox (console)
<a name="sandbox-console"></a>

Suivez les instructions suivantes pour exécuter des commandes et connecter votre client SSH au CodeBuild sandbox de la console.

### Exécuter des commandes avec le CodeBuild bac à sable (console)
<a name="sandbox-console.commands"></a>

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

1. Dans le volet de navigation, choisissez **Projets de génération**. Choisissez le projet de génération, puis choisissez **Debug build**.  
![\[La page détaillée du projet debug build dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/sandbox-debug-build.png)

1. Dans l'onglet **Exécuter la commande**, entrez vos commandes personnalisées, puis choisissez **Exécuter la commande**.  
![\[La page détaillée de la commande d'exécution dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/debug-build-run.png)

1. Votre CodeBuild sandbox sera ensuite initialisé et commencera à exécuter vos commandes personnalisées. La sortie sera affichée dans l'onglet **Sortie** lorsqu'elle sera terminée.   
![\[La page de sortie de la commande d'exécution dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/debug-build-run-output.png)

1. Lorsque le dépannage est terminé, vous pouvez arrêter le bac à sable en choisissant **Arrêter le bac à sable**. Choisissez ensuite **Stop** pour confirmer que votre sandbox sera arrêté.  
![\[La boîte de dialogue Stop Sandbox.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/stop-sandbox.png)  
![\[La page de sortie de la commande d'exécution avec un sandbox arrêté dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/stopped-sandbox.png)

### Connectez-vous à votre client SSH avec CodeBuild sandbox (console)
<a name="sandbox-console.ssh"></a>

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

1. Dans le volet de navigation, choisissez **Projets de génération**. Choisissez le projet de génération, puis choisissez **Debug build**.  
![\[La page détaillée du projet debug build dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/sandbox-debug-build.png)

1. Dans l'onglet **Client SSH**, choisissez **Start sandbox**.  
![\[La page sandbox du client SSH dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/ssh-client-sandbox.png)

1. Une fois le CodeBuild sandbox lancé, suivez les instructions de la console pour connecter votre client SSH au sandbox.  
![\[La page sandbox du client SSH dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/ssh-client-sandbox-terminal.png)

1. Lorsque le dépannage est terminé, vous pouvez arrêter le bac à sable en choisissant **Arrêter le bac à sable**. Choisissez ensuite **Stop** pour confirmer que votre sandbox sera arrêté.  
![\[La boîte de dialogue Stop Sandbox.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/stop-sandbox-2.png)  
![\[La page de sortie de la commande d'exécution avec un sandbox arrêté dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/stopped-sandbox-2.png)

## Déboguer les builds avec CodeBuild sandbox ()AWS CLI
<a name="sandbox-cli"></a>

Suivez les instructions suivantes pour exécuter des commandes et connecter votre client SSH au CodeBuild sandbox.

### Démarrer un CodeBuild bac à sable ()AWS CLI
<a name="sandbox-cli.start-sandbox"></a>

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

```
aws codebuild start-sandbox --project-name $PROJECT_NAME
```
+ `--project-name`: nom CodeBuild du projet

------
#### [ 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
            }
        }
    }
}
```

------

### Obtenir des informations sur l'état du bac à sable ()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`: liste séparée par des virgules de `sandboxIds` ou`sandboxArns`.

Vous pouvez fournir un identifiant de sandbox ou un ARN de sandbox :
+ Identifiant du bac à sable : `<codebuild-project-name>:<UUID>`

  Par exemple, `project-name:d25be134-05cb-404a-85da-ac5f85d2d72c`.
+ ARN du bac à sable : arn:aws:codebuild : ::sandbox/ : *<region>* *<account-id>* *<codebuild-project-name>* *<UUID>*

  Par exemple, `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": []
}
```

------

### Arrêter un bac à sable ()AWS CLI
<a name="sandbox-cli.stop-sandbox"></a>

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

```
aws codebuild stop-sandbox --id $SANDBOX-ID
```
+ `--id`: A `sandboxId` ou`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
            }
        }
    }
}
```

------

### Lancer l'exécution d'une commande (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`: commande qui doit être exécutée.
+ `--sandbox-id`: A `sandboxId` ou`sandboxArn`.
+ `--type`: le type de commande,`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
        }
    }
}
```

------

### Obtenir des informations sur les exécutions de commandes (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`: liste séparée par des virgules de. `commandExecutionIds`
+ `--sandbox-id`: A `sandboxId` ou`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": []
}
```

------

### Répertorier les exécutions de commandes pour un sandbox ()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`: le jeton suivant, le cas échéant, pour obtenir des résultats paginés. Vous obtiendrez cette valeur lors de l'exécution précédente de listes de sandbox.
+ `--max-results`: (Facultatif) Le nombre maximum d'enregistrements sandbox à récupérer.
+ `--sort-order`: ordre dans lequel les enregistrements sandbox doivent être récupérés.

------
#### [ 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
                }
            }
        }
    ]
}
```

------

### Répertorier les bacs à sable ()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"
    ]
}
```

------

# Tutoriel : Connexion à un sandbox via SSH
<a name="sandbox-ssh-tutorial"></a>

Ce didacticiel explique comment se connecter à un CodeBuild sandbox à l'aide d'un client SSH.

Pour effectuer ce didacticiel, vous devez d'abord :
+ Assurez-vous d'avoir un AWS CodeBuild projet existant.
+ Configurez les autorisations IAM appropriées configurées pour votre rôle dans le CodeBuild projet. 
+ Installez et configurez AWS CLI sur votre machine locale.

## Étape 1 : démarrer un bac à sable
<a name="sandbox-ssh-tutorial.start-sandbox"></a>

**Pour démarrer un CodeBuild bac à sable dans la console**

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

1. Dans le volet de navigation, choisissez **Projets de génération**. Choisissez le projet de génération, puis choisissez **Debug build**.  
![\[La page détaillée du projet de création dans la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/project-debug-build.png)

1. Dans l'onglet **Client SSH**, choisissez **Start sandbox**.  
![\[L'onglet « Client SSH » de la console avec le bouton « Démarrer le bac à sable ».\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/ssh-client-sandbox.png)

1. Le processus d'initialisation du sandbox peut prendre un certain temps. Vous pouvez vous connecter au sandbox lorsque son statut passe à`RUN_SANDDBOX`.  
![\[La connexion au sandbox SSH une fois que le statut passe à « RUN_SANDDBOX ».\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/run-sandbox.png)

## Étape 2 : Modifier la configuration SSH locale
<a name="sandbox-ssh-tutorial.modify-ssh"></a>

Si vous vous connectez au sandbox pour la première fois, vous devez effectuer un processus de configuration unique en suivant les étapes suivantes :

**Pour modifier la configuration SSH locale dans la console**

1. Localisez les commandes de configuration de votre système d'exploitation.

1. Ouvrez votre terminal local, puis copiez et exécutez les commandes fournies pour télécharger et exécuter le script permettant de configurer votre configuration SSH locale. Par exemple, si votre système d'exploitation est macOS, utilisez la commande suivante :  
![\[Les commandes macOS pour la connexion SSH au CodeBuild sandbox de la console.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/modify-ssh-macOS.png)

1. Le script de configuration ajoutera les configurations requises pour la connexion à vos sandbox. Vous serez invité à accepter ces modifications.

1. Une fois la configuration réussie, une nouvelle entrée de configuration SSH pour le CodeBuild sandbox sera créée.  
![\[Connexion sandbox SSH réussie.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/ssh-terminal-success.png)

## Étape 3 : Connectez-vous au bac à sable
<a name="sandbox-ssh-tutorial.connect-sandbox"></a>

**Pour modifier la configuration SSH locale dans la console**

1. Configurez AWS CLI l'authentification et assurez-vous que votre AWS CLI utilisateur dispose de l'`codebuild:StartSandboxConnection`autorisation. Pour plus d'informations, consultez la section [Authentification à l'aide des informations d'identification utilisateur IAM AWS CLI dans le](https://docs.aws.amazon.com/cli/v1/userguide/cli-authentication-user.html) *guide de l'utilisateur de l'interface de ligne de AWS commande pour la version 1*.

1. Connectez-vous à votre sandbox à l'aide de la commande suivante :

   ```
   ssh codebuild-sandbox-ssh=arn:aws:codebuild:us-east-1:<account-id>:sandbox/<sandbox-id>
   ```
**Note**  
Pour résoudre les problèmes de connexion, utilisez l'`-v`indicateur pour activer la sortie détaillée. Par exemple, `ssh -v codebuild-sandbox-ssh=arn:aws:codebuild:us-east-1:<account-id>:sandbox/<sandbox-id>`.  
Pour obtenir des conseils de dépannage supplémentaires, consultez[Résolution des problèmes AWS CodeBuild de connexion SSH au sandbox](sandbox-troubleshooting.md).

## Étape 4 : Passez en revue vos résultats
<a name="sandbox-ssh-tutorial.review-results"></a>

Une fois connecté, vous pouvez corriger les échecs de compilation, tester les commandes de compilation, expérimenter des modifications de configuration et vérifier les variables d'environnement et les dépendances avec votre sandbox.

# Résolution des problèmes AWS CodeBuild de connexion SSH au sandbox
<a name="sandbox-troubleshooting"></a>

Utilisez les informations de cette rubrique pour identifier, diagnostiquer et résoudre les problèmes de connexion SSH dans le CodeBuild sandbox.

**Topics**
+ [`StartSandboxConnection``InvalidInputException`erreur lors du SSH dans un environnement CodeBuild sandbox](#sandbox-troubleshooting.invalid-input)
+ [Erreur : « Impossible de localiser les informations d'identification » lors du SSH dans un environnement CodeBuild sandbox](#sandbox-troubleshooting.credentials)
+ [`StartSandboxConnection``AccessDeniedException`erreur lors du SSH dans un environnement CodeBuild sandbox](#sandbox-troubleshooting.access-denied)
+ [Erreur : « ssh : Impossible de résoudre le nom d'hôte » lors du SSH dans un environnement sandbox CodeBuild](#sandbox-troubleshooting.hostname)

## `StartSandboxConnection``InvalidInputException`erreur lors du SSH dans un environnement CodeBuild sandbox
<a name="sandbox-troubleshooting.invalid-input"></a>

**Problème :** Lorsque vous tentez de vous connecter à un environnement CodeBuild sandbox à l'aide de la commande`ssh codebuild-sandbox-ssh=<sandbox-arn>`, vous pouvez rencontrer une `InvalidInputException` erreur telle que :

```
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.
```

**Cause possible :**
+ Agent Amazon EC2 Systems Manager manquant : l'agent SSM n'est pas correctement installé ou configuré sur l'image de compilation.
+ Autorisations insuffisantes : le rôle de service de CodeBuild projet ne dispose pas des autorisations SSM requises.

**Solution recommandée :** Si vous utilisez une image personnalisée pour votre build, procédez comme suit.

1. Installez SSM Agent. Pour plus d'informations, consultez la section [Installation et désinstallation manuelles de l'agent SSM sur les instances Amazon EC2 pour](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-linux.html) Linux dans le. ** La version de l'agent SSM doit être `3.0.1295.0` ou ultérieure.

1. Copiez le fichier [ 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) dans le `/etc/amazon/ssm/` répertoire de votre image. Cela active **le mode conteneur** dans l'agent SSM.

1. Assurez-vous que le rôle de service de votre CodeBuild projet dispose des autorisations suivantes, puis redémarrez l'environnement 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"
        ]
    }
   ```

## Erreur : « Impossible de localiser les informations d'identification » lors du SSH dans un environnement CodeBuild sandbox
<a name="sandbox-troubleshooting.credentials"></a>

**Problème :** Lorsque vous tentez de vous connecter à un environnement CodeBuild sandbox à l'aide de la commande`ssh codebuild-sandbox-ssh=<sandbox-arn>`, vous pouvez rencontrer l'erreur d'identification suivante :

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

**Cause possible :** les AWS informations d'identification n'ont pas été correctement configurées dans votre environnement local.

**Solution recommandée :** Configurez vos AWS CLI informations d'identification en suivant la documentation officielle : [Configuration des paramètres du Guide de AWS CLI l'](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)*utilisateur de l'interface de ligne de AWS commande pour la version 2*.

## `StartSandboxConnection``AccessDeniedException`erreur lors du SSH dans un environnement CodeBuild sandbox
<a name="sandbox-troubleshooting.access-denied"></a>

**Problème :** Lorsque vous tentez de vous connecter à un environnement CodeBuild sandbox à l'aide de la commande`ssh codebuild-sandbox-ssh=<sandbox-arn>`, vous pouvez rencontrer l'erreur d'autorisation suivante :

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

**Cause possible :** Vos AWS informations d'identification ne disposent pas CodeBuild des autorisations nécessaires pour effectuer cette opération.

**Solution recommandée :** assurez-vous que l'utilisateur ou le rôle IAM associé à vos AWS CLI informations d'identification dispose des autorisations suivantes :

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

## Erreur : « ssh : Impossible de résoudre le nom d'hôte » lors du SSH dans un environnement sandbox CodeBuild
<a name="sandbox-troubleshooting.hostname"></a>

**Problème :** Lorsque vous tentez de vous connecter à un environnement CodeBuild sandbox à l'aide de la commande`ssh codebuild-sandbox-ssh=<sandbox-arn>`, vous rencontrez l'erreur de résolution de nom d'hôte suivante :

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

**Cause possible :** Cette erreur se produit généralement lorsque le script de connexion au CodeBuild sandbox requis n'a pas été correctement exécuté dans votre environnement local.

**Solution recommandée:**

1. Téléchargez le script de connexion au CodeBuild sandbox.

1. Exécutez le script dans votre terminal pour établir la configuration SSH nécessaire.

1. Réessayez de vous connecter SSH à l'environnement sandbox.

# Déboguer les builds avec le gestionnaire de session
<a name="session-manager"></a>

Dans AWS CodeBuild, vous pouvez suspendre une compilation en cours, puis utiliser le gestionnaire de AWS Systems Manager session pour vous connecter au conteneur de génération et afficher l'état du conteneur.

**Note**  
Cette fonctionnalité n'est pas disponible dans les environnements Windows.

**Topics**
+ [Conditions préalables](#ssm.prerequisites)
+ [Suspendre le build](#ssm-pause-build)
+ [Commencez la construction](#ssm-start-build)
+ [Connectez-vous au conteneur de construction](#ssm-connect)
+ [Reprendre le build](#ssm-resume-build)

## Conditions préalables
<a name="ssm.prerequisites"></a>

Pour autoriser l'utilisation du gestionnaire de session avec la session de génération, vous devez activer la connexion à la session pour la génération. Il existe deux prérequis :
+ CodeBuild L'agent SSM est déjà installé et l'agent SSM est activé sur les images sélectionnées standard de Linux. ContainerMode 

  Si vous utilisez une image personnalisée pour votre build, procédez comme suit :

  1. Installez SSM Agent. Pour plus d'informations, consultez la section [Installation manuelle de l'agent SSM sur les instances EC2 pour Linux](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-manual-agent-install.html) dans le guide de l' AWS Systems Manager utilisateur. La version de l'agent SSM doit être 3.0.1295.0 ou ultérieure.

  1. Copiez le fichier [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) dans le `/etc/amazon/ssm/` répertoire de votre image. Cela active le mode conteneur dans l'agent SSM.
**Note**  
Les images personnalisées nécessiteraient la mise à jour de l'agent SSM le plus récent pour que cette fonctionnalité fonctionne comme prévu.
+ Le rôle CodeBuild de service doit respecter la politique SSM suivante :

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

****  

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

------

  Vous pouvez demander à la CodeBuild console d'associer automatiquement cette politique à votre rôle de service lorsque vous démarrez la génération. Vous pouvez également associer cette politique à votre rôle de service manuellement.
+ Si l'**audit et la journalisation de l'activité des sessions** sont activés dans les préférences de Systems Manager, le rôle de CodeBuild service doit également disposer d'autorisations supplémentaires. Les autorisations sont différentes en fonction de l'endroit où les journaux sont stockés.  
CloudWatch Journaux  
Si vous utilisez CloudWatch Logs pour stocker vos journaux, ajoutez l'autorisation suivante au rôle CodeBuild de service :    
****  

  ```
  {
      "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 vous utilisez Amazon S3 pour stocker vos journaux, ajoutez l'autorisation suivante au rôle CodeBuild de service :    
****  

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

  Pour plus d'informations, consultez la section [Audit et journalisation de l'activité des sessions](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-logging-auditing.html) dans le *guide de AWS Systems Manager l'utilisateur*.

## Suspendre le build
<a name="ssm-pause-build"></a>

Pour suspendre la génération, insérez la **codebuild-breakpoint** commande dans l'une des phases de construction de votre fichier buildspec. La construction sera suspendue à ce stade, ce qui vous permettra de vous connecter au conteneur de construction et de visualiser le conteneur dans son état actuel. 

Par exemple, ajoutez ce qui suit aux phases de construction dans votre fichier buildspec.

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

Ce code crée le `/tmp/hello-world` fichier, puis suspend la compilation à ce stade.

## Commencez la construction
<a name="ssm-start-build"></a>

Pour autoriser l'utilisation du gestionnaire de session avec la session de génération, vous devez activer les connexions de session pour la génération. Pour ce faire, lors du démarrage de la compilation, procédez comme suit :

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

1. Dans le volet de navigation, choisissez **Projets de génération**. Choisissez le projet de construction, puis choisissez **Démarrer la construction avec des remplacements**.

1. Choisissez **Advanced build overrides (Remplacements avancés de génération)**.

1. Dans la section **Environnement**, choisissez l'option **Activer la connexion à la session**. Si cette option n'est pas sélectionnée, toutes les **codebuild-resume** commandes **codebuild-breakpoint** et sont ignorées.

1. Apportez les autres modifications souhaitées, puis choisissez **Démarrer la construction**. 

1. Surveillez l'état de construction dans la console. Lorsque la session est disponible, le lien du **gestionnaire de AWS session** apparaît dans la section **État de la création**.

## Connectez-vous au conteneur de construction
<a name="ssm-connect"></a>

Vous pouvez vous connecter au conteneur de construction de deux manières :

CodeBuild console  
Dans un navigateur Web, ouvrez le lien du **gestionnaire de AWS session** pour vous connecter au conteneur de construction. Une session de terminal s'ouvre pour vous permettre de parcourir et de contrôler le conteneur de construction. 

AWS CLI  
Le plug-in Session Manager doit être installé sur votre machine locale pour cette procédure. Pour plus d'informations, voir [Installer le plug-in du gestionnaire de session pour la AWS CLI](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html) dans le guide de AWS Systems Manager l'utilisateur. 

1. Appelez l'**batch-get-builds**API avec l'ID de build pour obtenir des informations sur le build, y compris l'identifiant cible de session. Le nom de propriété de l'identifiant cible de session varie en fonction du type de sortie de la `aws` commande. C'est pourquoi `--output json` il est ajouté à la commande.

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

1. Copiez la valeur `sessionTarget` de la propriété. Le nom de la `sessionTarget` propriété peut varier en fonction du type de sortie de la `aws` commande. C'est pourquoi `--output json` il est ajouté à la commande à l'étape précédente.

1. Utilisez la commande suivante pour vous connecter au conteneur de construction.

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

Pour cet exemple, vérifiez que le `/tmp/hello-world` fichier existe et contient le texte`Hello World`.

## Reprendre le build
<a name="ssm-resume-build"></a>

Une fois que vous avez terminé d'examiner le conteneur de construction, émettez la **codebuild-resume** commande depuis le shell du conteneur.

```
$ codebuild-resume
```

# Supprimer les builds AWS CodeBuild
<a name="delete-builds"></a>

Vous pouvez utiliser le AWS CLI ou le AWS SDKs pour supprimer des versions intégrales AWS CodeBuild.

**Topics**
+ [Suppression de générations (AWS CLI)](#delete-builds-cli)
+ [Suppression de générations (AWS SDKs)](#delete-builds-sdks)

## Suppression de générations (AWS CLI)
<a name="delete-builds-cli"></a>

Exécutez la commande `batch-delete-builds` :

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

Dans la commande précédente, remplacez l'espace réservé suivant :
+ *ids*: chaîne obligatoire. Les IDs versions à supprimer. Pour spécifier plusieurs générations, séparez les ID par un espace. Pour obtenir la liste des versions IDs, consultez les rubriques suivantes :
  + [Afficher la liste des build IDs (AWS CLI)](view-build-list.md#view-build-list-cli)
  + [Afficher la liste des versions IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

En cas de réussite, un tableau `buildsDeleted` s'affiche dans la sortie avec l'Amazon Resource Name (ARN) de chaque génération supprimée. Des informations sur les générations qui n'ont pas pu être supprimées apparaissent dans la sortie dans un tableau `buildsNotDeleted`.

Par exemple, si vous exécutez la commande suivante :

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

Des informations similaires à ce qui suit s'affichent dans la sortie :

```
{
  "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"
  ]
}
```

## Suppression de générations (AWS SDKs)
<a name="delete-builds-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Réessayer les builds manuellement AWS CodeBuild
<a name="retry-build"></a>

Vous pouvez utiliser la AWS CodeBuild console ou AWS SDKs réessayer manuellement une génération unique ou une intégration par lots. AWS CLI AWS CodeBuild

**Topics**
+ [Réessayer une compilation manuellement (console)](#retry-build-console)
+ [Réessayer une compilation manuellement ()AWS CLI](#retry-build-cli)
+ [Réessayer une compilation manuellement ()AWS SDKs](#retry-build-sdks)

## Réessayer une compilation manuellement (console)
<a name="retry-build-console"></a>

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

1. Effectuez l’une des actions suivantes :
   + Si la *build-ID* page ***build-project-name*:** s'affiche, choisissez **Réessayer de construire**.
   + Dans le volet de navigation, choisissez **Historique de génération**. Dans la liste des versions, cochez la case correspondant à la génération, puis choisissez **Réessayer de construire**.
   + Dans le volet de navigation, choisissez **Projets de génération**. Dans la liste des projets de génération, dans la colonne **Nom**, choisissez le lien correspondant au nom du projet de génération. Dans la liste des versions, cochez la case correspondant à la génération, puis choisissez **Réessayer de construire**.

**Note**  
Par défaut, seuls les 100 derniers projets de génération ou générations sont affichés. Pour afficher plus de générations ou de projets de génération, sélectionnez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Générations par page** ou **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

## Réessayer une compilation manuellement ()AWS CLI
<a name="retry-build-cli"></a>
+ Exécutez la commande **retry-build** :

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

  Dans la commande précédente, remplacez l'espace réservé suivant :
  + *<build-id>*: chaîne obligatoire. L'ID de la version ou de la génération par lots à réessayer. Pour obtenir la liste des versions IDs, consultez les rubriques suivantes :
    + [Afficher la liste des build IDs (AWS CLI)](view-build-list.md#view-build-list-cli)
    + [Afficher la liste des build IDs (AWS CLI) par lots](view-build-list.md#view-batch-build-list-cli)
    + [Afficher la liste des versions IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)
    + [Afficher la liste des compilations par lots IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-batch-builds-for-project-cli)
  + `--idempotency-token`: Facultatif. Si vous exécutez la **retry-build** commande avec l'option, un identifiant unique distinguant majuscules et minuscules, ou jeton, est inclus dans la `retry-build` demande. Le jeton est valide pendant 5 minutes après la demande . Si vous répétez la `retry-build` demande avec le même jeton, mais que vous modifiez un paramètre, CodeBuild renvoie une erreur de non-concordance des paramètres.

## Réessayer une compilation manuellement ()AWS SDKs
<a name="retry-build-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Retry s'intègre automatiquement AWS CodeBuild
<a name="auto-retry-build"></a>

Vous pouvez utiliser la AWS CodeBuild console ou AWS SDKs réessayer automatiquement vos builds. AWS CLI AWS CodeBuild Lorsque le réessai automatique est activé, CodeBuild il appellera automatiquement `RetryBuild` en utilisant le rôle de service du projet après un échec de construction jusqu'à une limite spécifiée. Par exemple, si la limite de tentatives automatiques est définie sur deux, l'API CodeBuild appellera l'`RetryBuild`API pour réessayer automatiquement votre build jusqu'à deux fois supplémentaires.

**Note**  
CodeBuild ne prend pas en charge la nouvelle tentative automatique pour. CodePipeline

**Topics**
+ [Réessayer une compilation automatiquement (console)](#auto-retry-build-console)
+ [Réessayer une compilation automatiquement ()AWS CLI](#auto-retry-build-cli)
+ [Réessayer automatiquement un build ()AWS SDKs](#auto-retry-build-sdks)

## Réessayer une compilation automatiquement (console)
<a name="auto-retry-build-console"></a>

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

1. Sélectionnez **Create a project (Créer un projet)**. 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 **Environment (Environnement)** : 
     +  Pour **Limite de tentatives automatiques**, entrez le nombre maximum de tentatives automatiques souhaitées après un échec de compilation.

1. Dans **Environnement**, sélectionnez **Configuration supplémentaire**.

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

## Réessayer une compilation automatiquement ()AWS CLI
<a name="auto-retry-build-cli"></a>
+ Exécutez la commande **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>"
  ```

  Dans la commande précédente, remplacez les espaces réservés suivants :
  + *<auto-retry-limit>*: Définissez la limite de tentatives automatiques au nombre maximum de tentatives automatiques souhaité après l'échec d'une compilation.
  + *<project-name>*,*<source>*,*<artifacts>*,*environment-type>*, *image-type>**compute-type>*, et *service-role>* : définissez les paramètres de configuration de projet souhaités.

## Réessayer automatiquement un build ()AWS SDKs
<a name="auto-retry-build-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Arrêter les intégrations AWS CodeBuild
<a name="stop-build"></a>

Vous pouvez utiliser la AWS CodeBuild console AWS CLI, ou AWS SDKs pour arrêter une intégration AWS CodeBuild.

**Topics**
+ [Arrêt d'une génération (console)](#stop-build-console)
+ [Arrêt d'une génération (AWS CLI)](#stop-build-cli)
+ [Arrêt d'une génération (AWS SDKs)](#stop-build-sdks)

## Arrêt d'une génération (console)
<a name="stop-build-console"></a>

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

1. Effectuez l’une des actions suivantes :
   + Si la *build-ID* page ***build-project-name*:** s'affiche, choisissez **Arrêter la construction**.
   + Dans le volet de navigation, choisissez **Historique de génération**. Dans la liste des générations, cochez la case correspondant à la génération, puis choisissez **Stop build (Arrêter la génération)**.
   + Dans le volet de navigation, choisissez **Projets de génération**. Dans la liste des projets de génération, dans la colonne **Nom**, choisissez le lien correspondant au nom du projet de génération. Dans la liste des générations, cochez la case correspondant à la génération, puis choisissez **Stop build (Arrêter la génération)**.

**Note**  
Par défaut, seuls les 100 derniers projets de génération ou générations sont affichés. Pour afficher plus de générations ou de projets de génération, sélectionnez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Générations par page** ou **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.  
Si vous AWS CodeBuild ne parvenez pas à arrêter une génération (par exemple, si le processus de génération est déjà terminé), le bouton **Arrêter** est désactivé ou risque de ne pas apparaître.

## Arrêt d'une génération (AWS CLI)
<a name="stop-build-cli"></a>
+ Exécutez la commande **stop-build** :

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

  Dans la commande précédente, remplacez l'espace réservé suivant :
  + *id*: chaîne obligatoire. ID de la génération à arrêter. Pour obtenir la liste des versions IDs, consultez les rubriques suivantes :
    + [Afficher la liste des build IDs (AWS CLI)](view-build-list.md#view-build-list-cli)
    + [Afficher la liste des versions IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

  En cas d'arrêt AWS CodeBuild réussi de la construction, la `buildStatus` valeur de l'`build`objet dans la sortie est`STOPPED`.

  Si vous CodeBuild ne parvenez pas à arrêter la construction (par exemple, si la génération est déjà terminée), la `buildStatus` valeur de l'`build`objet dans la sortie est le statut final de la construction (par exemple,`SUCCEEDED`).

## Arrêt d'une génération (AWS SDKs)
<a name="stop-build-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Arrêter les compilations par lots AWS CodeBuild
<a name="stop-batch-build"></a>

Vous pouvez utiliser la AWS CodeBuild console ou AWS SDKs arrêter l'intégration d'un lot AWS CodeBuild. AWS CLI

**Note**  
Si vous utilisez le calcul Lambda dans votre génération par lots, la génération Lambda en cours ne peut pas être arrêtée.

**Topics**
+ [Arrêter une génération par lots (console)](#stop-batch-build-console)
+ [Arrêter une construction par lots (AWS CLI)](#stop-batch-build-cli)
+ [Arrêter une construction par lots (AWS SDKs)](#stop-batch-build-sdks)

## Arrêter une génération par lots (console)
<a name="stop-batch-build-console"></a>

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

1. Effectuez l’une des actions suivantes :
   + Si la *build-ID* page ***build-project-name*:** s'affiche, choisissez **Arrêter la construction**.
   + Dans le volet de navigation, choisissez **Historique de génération**. Dans la liste des générations, cochez la case correspondant à la génération, puis choisissez **Stop build (Arrêter la génération)**.
   + Dans le volet de navigation, choisissez **Projets de génération**. Dans la liste des projets de génération, dans la colonne **Nom**, choisissez le lien correspondant au nom du projet de génération. Dans la liste des générations, cochez la case correspondant à la génération, puis choisissez **Stop build (Arrêter la génération)**.

**Note**  
Par défaut, seuls les 100 derniers projets de génération ou générations sont affichés. Pour afficher plus de générations ou de projets de génération, sélectionnez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Générations par page** ou **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

## Arrêter une construction par lots (AWS CLI)
<a name="stop-batch-build-cli"></a>
+ Exécutez la commande [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>
  ```

  Dans la commande précédente, remplacez l'espace réservé suivant :
  + *<batch-build-id>*: chaîne obligatoire. Identifiant du lot à arrêter. Pour obtenir la liste des identifiants de génération par lots, consultez les rubriques suivantes :
    + [Afficher la liste des build IDs (AWS CLI) par lots](view-build-list.md#view-batch-build-list-cli)
    + [Afficher la liste des compilations par lots IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-batch-builds-for-project-cli)

## Arrêter une construction par lots (AWS SDKs)
<a name="stop-batch-build-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Le déclencheur AWS CodeBuild se construit automatiquement
<a name="build-triggers"></a>

Vous pouvez créer un déclencheur sur un projet pour planifier une génération une fois toutes les heures, tous les jours ou toutes les semaines. Vous pouvez également modifier un déclencheur pour utiliser une règle personnalisée avec une expression Amazon CloudWatch Cron. Par exemple, à l'aide d'une expression cron, vous pouvez planifier une génération à une heure précise chaque jour de la semaine. Pour plus d'informations sur la création et la modification de déclencheurs, reportez-vous [Création de AWS CodeBuild déclencheurs](#trigger-create) aux sections et[Modifier les AWS CodeBuild déclencheurs](triggers-edit.md).

**Topics**
+ [Création de AWS CodeBuild déclencheurs](#trigger-create)
+ [Modifier les AWS CodeBuild déclencheurs](triggers-edit.md)

## Création de AWS CodeBuild déclencheurs
<a name="trigger-create"></a>

Vous pouvez créer un déclencheur sur un projet pour planifier une génération une fois toutes les heures, tous les jours ou toutes les semaines. Vous pouvez également créer un déclencheur à l'aide d'une règle personnalisée avec une expression Amazon CloudWatch cron. Par exemple, à l'aide d'une expression cron, vous pouvez planifier une génération à une heure précise chaque jour de la semaine. 

**Note**  
Il n'est pas possible de démarrer une génération par lots à partir d'un déclencheur de génération, d'un EventBridge événement Amazon ou d'une AWS Step Functions tâche.

**Topics**
+ [Création de AWS CodeBuild déclencheurs (console)](#trigger-create-console)
+ [Création de AWS CodeBuild déclencheurs par programmation](#trigger-create-code)

### Création de AWS CodeBuild déclencheurs (console)
<a name="trigger-create-console"></a>

Utilisez la procédure suivante pour créer des déclencheurs à l'aide du AWS Management Console.

**Pour créer un déclencheur** 

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

1. Dans le volet de navigation, choisissez **Projets de génération**.

1. Sélectionnez le lien pour le projet de génération pour lequel vous voulez ajouter un déclencheur, puis choisissez l'onglet **Build triggers (Déclencheurs de génération)**.
**Note**  
Par défaut, les 100 projets de construction les plus récents sont affichés. Pour afficher plus de projets de génération, choisissez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

1. Choisissez **Create trigger**.

1. Saisissez un nom dans **Trigger name (Nom du déclencheur)**.

1. Dans la liste déroulante **Fréquence**, choisissez la fréquence de votre déclencheur. Si vous voulez créer une fréquence à l'aide d'une expression cron, choisissez **Custom (Personnalisé)**.

1. Spécifiez les paramètres de la fréquence de votre déclencheur. Vous pouvez saisir les tout premiers caractères de vos sélections dans la zone de texte pour filtrer les éléments du menu déroulant.
**Note**  
 Les heures et minutes de début sont basées sur zéro. La minute de début est un nombre compris entre zéro et 59. L'heure de début est un nombre compris entre zéro et 23. Par exemple, un déclencheur quotidien qui commence tous les jours à 12 h 15 a une heure de début de 12 heures et une minute de début de 15. Un déclencheur quotidien qui commence tous les jours à minuit a une heure de début de zéro et une minute de début de zéro. Un déclencheur quotidien qui commence tous les jours à 23 h 59 a une heure de début de 23 et une minute de départ de 59.   
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/build-triggers.html)

1.  Sélectionnez ** Enable this trigger (Activer ce déclencheur)**. 

1.  (Facultatif) Développez **Advanced section (Section avancée)**. Dans **Source version (Version de la source)**, saisissez une version de votre code source. 
   +  Pour Amazon S3, entrez l'ID de version qui correspond à la version de l'artefact d'entrée que vous souhaitez créer. Si le champ **Version de la source** reste vide, la dernière version est utilisée. 
   +  Pour AWS CodeCommit, saisissez un ID de validation. Si **Version de la source** est vide, l'ID de validation HEAD de la branche par défaut est utilisé. 
   + Pour GitHub ou GitHub Enterprise, saisissez un identifiant de validation, un identifiant de pull request, un nom de branche ou un nom de balise correspondant à la version du code source que vous souhaitez créer. Si vous spécifiez un ID de demande d'extraction, il doit utiliser le format `pr/pull-request-ID` (par exemple, `pr/25`). Si vous spécifiez un nom de branche, l'ID de validation HEAD de la branche est utilisé. Si **Version source** est vide, l'ID de validation HEAD de la branche par défaut est utilisé.
   + Pour Bitbucket, entrez un ID de validation, un nom de branche ou un nom de balise qui correspond à la version du code source à générer. Si vous spécifiez un nom de branche, l'ID de validation HEAD de la branche est utilisé. Si **Version source** est vide, l'ID de validation HEAD de la branche par défaut est utilisé.

1. (Facultatif) Spécifiez un délai compris entre 5 minutes et 2 160 minutes (36 heures). Cette valeur indique la durée des AWS CodeBuild tentatives de compilation avant qu'elle ne s'arrête. Si les **Hours (heures)** et **Minutes** sont laissées vides, la valeur de délai d'expiration par défaut spécifiée dans le projet est utilisée. 

1. Choisissez **Create trigger**.

### Création de AWS CodeBuild déclencheurs par programmation
<a name="trigger-create-code"></a>

CodeBuild utilise les EventBridge règles Amazon pour créer des déclencheurs. Vous pouvez utiliser l' EventBridge API pour créer par programmation des déclencheurs de build pour vos CodeBuild projets. Consultez le [manuel Amazon EventBridge API Reference](https://docs.aws.amazon.com/eventbridge/latest/APIReference/) pour plus d'informations.

# Modifier les AWS CodeBuild déclencheurs
<a name="triggers-edit"></a>

Vous pouvez modifier un déclencheur sur un projet pour planifier une génération une fois toutes les heures, tous les jours ou toutes les semaines. Vous pouvez également modifier un déclencheur pour utiliser une règle personnalisée avec une expression Amazon CloudWatch Cron. Par exemple, à l'aide d'une expression cron, vous pouvez planifier une génération à une heure précise chaque jour de la semaine. Pour plus d'informations sur la création d'un déclencheur, consultez [Création de AWS CodeBuild déclencheurs](build-triggers.md#trigger-create).

**Topics**
+ [Modifier les AWS CodeBuild déclencheurs (console)](#triggers-edit-console)
+ [Modifier les AWS CodeBuild déclencheurs par programmation](#trigger-edit-code)

## Modifier les AWS CodeBuild déclencheurs (console)
<a name="triggers-edit-console"></a>

Utilisez la procédure suivante pour modifier les déclencheurs à l'aide du AWS Management Console.

**Pour modifier un déclencheur**

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

1. Dans le volet de navigation, choisissez **Projets de génération**.

1. Sélectionnez le lien du projet de génération à modifier, puis choisissez l'onglet **Build triggers (Déclencheurs de génération)**.
**Note**  
Par défaut, les 100 projets de construction les plus récents sont affichés. Pour afficher plus de projets de génération, choisissez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

1. Sélectionnez la case d'option en regard du déclencheur à modifier, puis choisissez **Edit (Modifier)**.

1. Dans la liste déroulante **Fréquence**, choisissez la fréquence de votre déclencheur. Si vous voulez créer une fréquence à l'aide d'une expression cron, choisissez **Custom (Personnalisé)**.

1. Spécifiez les paramètres de la fréquence de votre déclencheur. Vous pouvez saisir les tout premiers caractères de vos sélections dans la zone de texte pour filtrer les éléments du menu déroulant.
**Note**  
 Les heures et minutes de début sont basées sur zéro. La minute de début est un nombre compris entre zéro et 59. L'heure de début est un nombre compris entre zéro et 23. Par exemple, un déclencheur quotidien qui commence tous les jours à 12 h 15 a une heure de début de 12 heures et une minute de début de 15. Un déclencheur quotidien qui commence tous les jours à minuit a une heure de début de zéro et une minute de début de zéro. Un déclencheur quotidien qui commence tous les jours à 23 h 59 a une heure de début de 23 heures et une minute de départ de 59.   
****    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/triggers-edit.html)

1.  Sélectionnez ** Enable this trigger (Activer ce déclencheur)**. 

**Note**  
Vous pouvez utiliser la CloudWatch console Amazon [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)pour modifier la version de la source, le délai d'expiration et d'autres options qui ne sont pas disponibles dans AWS CodeBuild.

## Modifier les AWS CodeBuild déclencheurs par programmation
<a name="trigger-edit-code"></a>

CodeBuild utilise les EventBridge règles d'Amazon pour créer des déclencheurs. Vous pouvez utiliser l' EventBridge API pour modifier par programmation les déclencheurs de génération de vos CodeBuild projets. Consultez le [manuel Amazon EventBridge API Reference](https://docs.aws.amazon.com/eventbridge/latest/APIReference/) pour plus d'informations.

# Afficher les détails du build dans AWS CodeBuild
<a name="view-build-details"></a>

Vous pouvez utiliser la AWS CodeBuild console ou AWS SDKs pour afficher les détails des builds gérés par CodeBuild. AWS CLI

**Topics**
+ [Affichage des détails d'une génération (console)](#view-build-details-console)
+ [Affichage des détails d'une génération (AWS CLI)](#view-build-details-cli)
+ [Affichage des détails d'une génération (AWS SDKs)](#view-build-details-sdks)
+ [Transitions des phases de génération](view-build-details-phases.md)

## Affichage des détails d'une génération (console)
<a name="view-build-details-console"></a>

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

1. Effectuez l’une des actions suivantes :
   + Dans le volet de navigation, choisissez **Historique de génération**. Dans la liste des générations, dans la colonne **Exécution de génération**, choisissez le lien de la génération. 
   + Dans le volet de navigation, choisissez **Projets de génération**. Dans la liste des projets de génération, dans la colonne **Nom**, choisissez le lien du nom du projet de génération. Puis, dans la liste des générations, dans la colonne **Exécution de génération**, choisissez le lien de la génération.
**Note**  
Par défaut, seuls les 10 derniers projets de génération ou générations s'affichent. Pour afficher plus de générations ou de projets de génération, sélectionnez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Générations par page** ou **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

## Affichage des détails d'une génération (AWS CLI)
<a name="view-build-details-cli"></a>

Pour plus d'informations sur l'utilisation du AWS CLI with AWS CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).

Exécutez la commande **batch-get-builds** :

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

Remplacez l'espace réservé suivant :
+ *ids*: chaîne obligatoire. Une ou plusieurs versions sur IDs lesquelles afficher les détails. Pour spécifier plusieurs ID de génération, séparez-les par un espace. Vous pouvez spécifier jusqu'à 100 versions IDs. Pour obtenir la liste des versions IDs, consultez les rubriques suivantes :
  + [Afficher la liste des build IDs (AWS CLI)](view-build-list.md#view-build-list-cli)
  + [Afficher la liste des versions IDs pour un projet de construction (AWS CLI)](view-builds-for-project.md#view-builds-for-project-cli)

Par exemple, si vous exécutez la commande suivante :

```
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 la commande aboutit, des données similaires à celles décrites dans [Pour afficher les informations de génération résumées](getting-started-overview.md#getting-started-cli-monitor-build-cli) apparaissent dans la sortie.

## Affichage des détails d'une génération (AWS SDKs)
<a name="view-build-details-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Transitions des phases de génération
<a name="view-build-details-phases"></a>

Les constructions se AWS CodeBuild déroulent par étapes :



![\[Les CodeBuild phases.\]](http://docs.aws.amazon.com/fr_fr/codebuild/latest/userguide/images/build-phases.png)




**Important**  
La phase `UPLOAD_ARTIFACTS` est toujours tentée, même si la phase `BUILD` échoue.

# Afficher la liste des éléments IDs intégrés AWS CodeBuild
<a name="view-build-list"></a>

Vous pouvez utiliser la AWS CodeBuild console ou AWS SDKs afficher la liste des versions IDs pour les versions gérées par CodeBuild. AWS CLI

**Topics**
+ [Afficher la liste des versions IDs (console)](#view-build-list-console)
+ [Afficher la liste des build IDs (AWS CLI)](#view-build-list-cli)
+ [Afficher la liste des build IDs (AWS CLI) par lots](#view-batch-build-list-cli)
+ [Afficher la liste des build IDs (AWS SDKs)](#view-build-list-sdks)

## Afficher la liste des versions IDs (console)
<a name="view-build-list-console"></a>

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

1. Dans le volet de navigation, choisissez **Historique de génération**. 
**Note**  
Par défaut, seules les 10 dernières générations s'affichent. Pour afficher plus de générations, sélectionnez l'icône en forme d'engrenage, puis sélectionnez une autre valeur pour **Générations par page** ou utilisez les flèches avant et arrière.

## Afficher la liste des build IDs (AWS CLI)
<a name="view-build-list-cli"></a>

Pour plus d'informations sur l'utilisation du AWS CLI with CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).
+ Exécutez la commande **list-builds** :

  ```
  aws codebuild list-builds --sort-order sort-order --next-token next-token
  ```

  Dans la commande précédente, remplacez les espaces réservés suivants :
  + *sort-order*: chaîne facultative utilisée pour indiquer comment répertorier le build IDs. Les valeurs valides sont `ASCENDING` et `DESCENDING`.
  + *next-token*: chaîne facultative. Lors d'une exécution précédente, si la liste contenait plus de 100 éléments, seuls les 100 premiers éléments étaient renvoyés, ainsi qu'une chaîne unique appelée *jeton suivant*. Pour obtenir l'ensemble d'éléments suivant dans la liste, exécutez à nouveau cette commande, en ajoutant le jeton suivant à l'appel. Pour obtenir tous les éléments de la liste, continuez d'exécuter cette commande avec chaque jeton suivant ultérieur, jusqu'à ce qu'aucun jeton suivant ne soit renvoyé.

  Par exemple, si vous exécutez la commande suivante :

  ```
  aws codebuild list-builds --sort-order ASCENDING
  ```

  Un résultat similaire à ce qui suit peut s'afficher dans la sortie :

  ```
  {
    "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 vous exécutez à nouveau cette commande :

  ```
  aws codebuild list-builds --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
  ```

  Un résultat similaire à ce qui suit peut s'afficher dans la sortie :

  ```
  {
    "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"
    ]
  }
  ```

## Afficher la liste des build IDs (AWS CLI) par lots
<a name="view-batch-build-list-cli"></a>

Pour plus d'informations sur l'utilisation du AWS CLI with CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).
+ Exécutez la commande **list-build-batches** :

  ```
  aws codebuild list-build-batches --sort-order sort-order --next-token next-token
  ```

  Dans la commande précédente, remplacez les espaces réservés suivants :
  + *sort-order*: chaîne facultative utilisée pour indiquer comment répertorier la compilation par lots IDs. Les valeurs valides sont `ASCENDING` et `DESCENDING`.
  + *next-token*: chaîne facultative. Lors d'une exécution précédente, si la liste contenait plus de 100 éléments, seuls les 100 premiers éléments étaient renvoyés, ainsi qu'une chaîne unique appelée *jeton suivant*. Pour obtenir l'ensemble d'éléments suivant dans la liste, exécutez à nouveau cette commande, en ajoutant le jeton suivant à l'appel. Pour obtenir tous les éléments de la liste, continuez d'exécuter cette commande avec chaque jeton suivant ultérieur, jusqu'à ce qu'aucun jeton suivant ne soit renvoyé.

  Par exemple, si vous exécutez la commande suivante :

  ```
  aws codebuild list-build-batches --sort-order ASCENDING
  ```

  Un résultat similaire à ce qui suit peut s'afficher dans la sortie :

  ```
  {
    "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 vous exécutez à nouveau cette commande :

  ```
  aws codebuild list-build-batches --sort-order ASCENDING --next-token 4AEA6u7J...The full token has been omitted for brevity...MzY2OA==
  ```

  Un résultat similaire à ce qui suit peut s'afficher dans la sortie :

  ```
  {
    "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"
    ]
  }
  ```

## Afficher la liste des build IDs (AWS SDKs)
<a name="view-build-list-sdks"></a>

Pour plus d'informations sur l'utilisation CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).

# Afficher la liste des versions IDs d'un projet de construction dans AWS CodeBuild
<a name="view-builds-for-project"></a>

Vous pouvez utiliser la AWS CodeBuild console AWS CLI, ou AWS SDKs pour afficher la liste des versions IDs d'un projet de génération dans CodeBuild.

**Topics**
+ [Afficher la liste des builds IDs pour un projet de build (console)](#view-builds-for-project-console)
+ [Afficher la liste des versions IDs pour un projet de construction (AWS CLI)](#view-builds-for-project-cli)
+ [Afficher la liste des compilations par lots IDs pour un projet de construction (AWS CLI)](#view-batch-builds-for-project-cli)
+ [Afficher la liste des versions IDs pour un projet de construction (AWS SDKs)](#view-builds-for-project-sdks)

## Afficher la liste des builds IDs pour un projet de build (console)
<a name="view-builds-for-project-console"></a>

1. Ouvrez la CodeBuild console à l'adresse [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

1. Dans le volet de navigation, choisissez **Projets de génération**. Dans la liste des projets de génération, dans la colonne **Nom**, choisissez le projet de génération. 

**Note**  
Par défaut, seuls les 100 derniers projets de génération ou générations sont affichés. Pour afficher plus de générations ou de projets de génération, sélectionnez l'icône en forme d'engrenage, puis choisissez une autre valeur pour **Générations par page** ou **Projects per page (Projets par page)** ou utilisez les flèches avant et arrière.

## Afficher la liste des versions IDs pour un projet de construction (AWS CLI)
<a name="view-builds-for-project-cli"></a>

Pour plus d'informations sur l'utilisation du AWS CLI with AWS CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).

Exécutez la commande **list-builds-for-project**, comme suit :

```
aws codebuild list-builds-for-project --project-name project-name --sort-order sort-order --next-token next-token
```

Dans la commande précédente, remplacez les espaces réservés suivants :
+ *project-name*: chaîne obligatoire utilisée pour indiquer le nom du projet de construction IDs pour lequel répertorier les versions. Pour obtenir une liste de projets de génération, consultez [Affichage d'une liste de noms de projet de génération (AWS CLI)](view-project-list.md#view-project-list-cli).
+ *sort-order*: chaîne facultative utilisée pour indiquer comment répertorier le build IDs. Les valeurs valides sont `ASCENDING` et `DESCENDING`.
+ *next-token*: chaîne facultative. Lors d'une exécution précédente, si la liste contenait plus de 100 éléments, seuls les 100 premiers éléments étaient renvoyés, ainsi qu'une chaîne unique appelée *jeton suivant*. Pour obtenir l'ensemble d'éléments suivant dans la liste, exécutez à nouveau cette commande, en ajoutant le jeton suivant à l'appel. Pour obtenir tous les éléments de la liste, continuez d'exécuter cette commande avec chaque jeton suivant ultérieur renvoyé, jusqu'à ce qu'aucun jeton suivant ne soit renvoyé.

Par exemple, si vous exécutez cette commande comme suit :

```
aws codebuild list-builds-for-project --project-name codebuild-demo-project --sort-order ASCENDING
```

Un résultat similaire à ce qui suit peut apparaître dans la sortie :

```
{
  "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 vous exécutez à nouveau cette commande :

```
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==
```

Un résultat similaire à ce qui suit peut apparaître dans la sortie :

```
{
  "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"
  ]
}
```

## Afficher la liste des compilations par lots IDs pour un projet de construction (AWS CLI)
<a name="view-batch-builds-for-project-cli"></a>

Pour plus d'informations sur l'utilisation du AWS CLI with AWS CodeBuild, consultez le[Référence des commandes en ligne](cmd-ref.md).

Exécutez la commande **list-build-batches-for-project**, comme suit :

```
aws codebuild list-build-batches-for-project --project-name project-name --sort-order sort-order --next-token next-token
```

Dans la commande précédente, remplacez les espaces réservés suivants :
+ *project-name*: chaîne obligatoire utilisée pour indiquer le nom du projet de construction IDs pour lequel répertorier les versions. Pour obtenir une liste de projets de génération, consultez [Affichage d'une liste de noms de projet de génération (AWS CLI)](view-project-list.md#view-project-list-cli).
+ *sort-order*: chaîne facultative utilisée pour indiquer comment répertorier le build IDs. Les valeurs valides sont `ASCENDING` et `DESCENDING`.
+ *next-token*: chaîne facultative. Lors d'une exécution précédente, si la liste contenait plus de 100 éléments, seuls les 100 premiers éléments étaient renvoyés, ainsi qu'une chaîne unique appelée *jeton suivant*. Pour obtenir l'ensemble d'éléments suivant dans la liste, exécutez à nouveau cette commande, en ajoutant le jeton suivant à l'appel. Pour obtenir tous les éléments de la liste, continuez d'exécuter cette commande avec chaque jeton suivant ultérieur renvoyé, jusqu'à ce qu'aucun jeton suivant ne soit renvoyé.

Par exemple, si vous exécutez cette commande comme suit :

```
aws codebuild list-build-batches-for-project --project-name codebuild-demo-project --sort-order ASCENDING
```

Un résultat similaire à ce qui suit peut apparaître dans la sortie :

```
{
  "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 vous exécutez à nouveau cette commande :

```
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==
```

Un résultat similaire à ce qui suit peut apparaître dans la sortie :

```
{
  "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"
  ]
}
```

## Afficher la liste des versions IDs pour un projet de construction (AWS SDKs)
<a name="view-builds-for-project-sdks"></a>

Pour plus d'informations sur l'utilisation AWS CodeBuild avec le AWS SDKs, consultez le[AWS SDKs et référence des outils](sdk-ref.md).