Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriel : Déploiement standard d'Amazon ECS avec CodePipeline
Ce didacticiel vous aide à créer un pipeline de déploiement end-to-end continu (CD) complet avec Amazon ECS with CodePipeline.
**Important**
Dans le cadre de la création d'un pipeline dans la console, un compartiment d'artefacts S3 sera utilisé par CodePipeline pour les artefacts. (Ceci est différent du compartiment utilisé pour une action source S3.) Si le compartiment d'artefacts S3 se trouve dans un compte différent de celui de votre pipeline, assurez-vous que le compartiment d'artefacts S3 appartient à cette personne sûre et Comptes AWS qu'elle sera fiable.
**Note**
Ce didacticiel concerne l'action de déploiement standard d'Amazon ECS pour CodePipeline. Pour un didacticiel qui utilise l'action de déploiement d'Amazon ECS pour CodeDeploy bleu/vert dans CodePipeline, consultez. [Tutoriel : Création d'un pipeline avec une source Amazon ECR et déploiement ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)
**Note**
Ce didacticiel concerne l'action de déploiement standard d'Amazon ECS CodePipeline avec une action source. Pour un didacticiel qui utilise l'action de ECSstandard déploiement Amazon en même temps que l'action de ECRBuild AndPublish création CodePipeline pour transférer votre image, consultez[Tutoriel : créer et envoyer une image Docker vers Amazon ECR avec CodePipeline (type V2)](tutorials-ecr-build-publish.md).
## Conditions préalables
Avant de pouvoir créer votre pipeline de déploiement continu à l'aide de ce didacticiel, vous devez avoir mis en place certaines ressources. Voici ce dont vous avez besoin pour commencer :
**Note**
Toutes ces ressources devraient être créées au sein de la même AWS région.
+ Un référentiel de contrôle de source (utilisé dans ce didacticiel CodeCommit) avec votre Dockerfile et la source de votre application. Pour plus d'informations, voir [Création d'un CodeCommit référentiel](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-create-repository.html) dans le *guide de AWS CodeCommit l'utilisateur*.
+ Un référentiel d'images Docker (ce didacticiel utilise Amazon ECR) contenant une image que vous avez créée à partir de votre Dockerfile et de la source de l'application. Pour plus d'informations, consultez les sections [Création d'un référentiel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) et diffusion [d'une image](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) dans le *guide de l'utilisateur d'Amazon Elastic Container Registry*.
+ Une définition de tâche Amazon ECS qui fait référence à l'image Docker hébergée dans votre référentiel d'images. Pour plus d'informations, consultez la section [Création d'une définition de tâche](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-task-definition.html) dans le manuel *Amazon Elastic Container Service Developer Guide*.
**Important**
L'action de déploiement standard d'Amazon ECS pour CodePipeline crée sa propre révision de la définition de tâche en fonction de la révision utilisée par le service Amazon ECS. Si vous créez de nouvelles révisions pour la définition de tâche sans mettre à jour le service Amazon ECS, l'action de déploiement ignorera ces révisions.
Vous trouverez ci-dessous un exemple de définition de tâche utilisé pour ce didacticiel. La valeur que vous utilisez pour `name` et `family` qui sera utilisée à l'étape suivante pour votre fichier de spécifications de construction.
```
{
"ipcMode": null,
"executionRoleArn": "role_ARN",
"containerDefinitions": [
{
"dnsSearchDomains": null,
"environmentFiles": null,
"logConfiguration": {
"logDriver": "awslogs",
"secretOptions": null,
"options": {
"awslogs-group": "/ecs/hello-world",
"awslogs-region": "us-west-2",
"awslogs-stream-prefix": "ecs"
}
},
"entryPoint": null,
"portMappings": [
{
"hostPort": 80,
"protocol": "tcp",
"containerPort": 80
}
],
"command": null,
"linuxParameters": null,
"cpu": 0,
"environment": [],
"resourceRequirements": null,
"ulimits": null,
"dnsServers": null,
"mountPoints": [],
"workingDirectory": null,
"secrets": null,
"dockerSecurityOptions": null,
"memory": null,
"memoryReservation": 128,
"volumesFrom": [],
"stopTimeout": null,
"image": "image_name",
"startTimeout": null,
"firelensConfiguration": null,
"dependsOn": null,
"disableNetworking": null,
"interactive": null,
"healthCheck": null,
"essential": true,
"links": null,
"hostname": null,
"extraHosts": null,
"pseudoTerminal": null,
"user": null,
"readonlyRootFilesystem": null,
"dockerLabels": null,
"systemControls": null,
"privileged": null,
"name": "hello-world"
}
],
"placementConstraints": [],
"memory": "2048",
"taskRoleArn": null,
"compatibilities": [
"EC2",
"FARGATE"
],
"taskDefinitionArn": "ARN",
"family": "hello-world",
"requiresAttributes": [],
"pidMode": null,
"requiresCompatibilities": [
"FARGATE"
],
"networkMode": "awsvpc",
"cpu": "1024",
"revision": 1,
"status": "ACTIVE",
"inferenceAccelerators": null,
"proxyConfiguration": null,
"volumes": []
}
```
+ Un cluster Amazon ECS qui exécute un service utilisant la définition de tâche que vous avez mentionnée précédemment. Pour plus d'informations, consultez les sections [Création d'un cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html) et [Création d'un service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html) dans le manuel *Amazon Elastic Container Service Developer Guide*.
Dès lors que ces prérequis sont respectés, vous pouvez commencer à créer votre pipeline de déploiement continu à l'aide du didacticiel.
## Étape 1 : Ajout d'un fichier de spécification de génération dans votre référentiel source
Ce didacticiel permet CodeBuild de créer votre image Docker et de l'envoyer vers Amazon ECR. Ajoutez un fichier `buildspec.yml` à votre référentiel de code source pour indiquer à CodeBuild comment effectuer cette opération. L'exemple de spécification de génération ci-dessous prévoit les opérations suivantes :
+ Phase antérieure à la génération :
+ Connectez-vous à Amazon ECR.
+ Définition de l'URI du référentiel en fonction de votre image ECR et ajout d'une balise d'image avec les sept premiers caractères de l'ID de validation Git de la source.
+ Phase de génération :
+ Création de l'image Docker et balisage de l'image avec `latest` et l'ID de validation Git.
+ Phase postérieure à la génération :
+ Transmission de l'image à votre référentiel ECR avec les deux balises.
+ Écrivez un fichier appelé `imagedefinitions.json` dans la racine de compilation contenant le nom du conteneur de votre service Amazon ECS, ainsi que l'image et le tag. La phase de déploiement de votre pipeline de déploiement continu s'appuie sur ces informations pour créer une révision de la définition de tâche de votre service avant de mettre à jour ce dernier afin qu'il utilise la nouvelle définition de tâche. Le fichier `imagedefinitions.json` est obligatoire pour l'exécutant de tâches ECS.
Collez cet exemple de texte pour créer votre `buildspec.yml` fichier et remplacez les valeurs de votre image et de la définition de la tâche. Ce texte utilise l'exemple d'ID de compte 111122223333.
```
version: 0.2
phases:
pre_build:
commands:
- echo Logging in to Amazon ECR...
- aws --version
- aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
- REPOSITORY_URI=012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world
- COMMIT_HASH=$(echo $CODEBUILD_RESOLVED_SOURCE_VERSION | cut -c 1-7)
- IMAGE_TAG=${COMMIT_HASH:=latest}
build:
commands:
- echo Build started on `date`
- echo Building the Docker image...
- docker build -t $REPOSITORY_URI:latest .
- docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
post_build:
commands:
- echo Build completed on `date`
- echo Pushing the Docker images...
- docker push $REPOSITORY_URI:latest
- docker push $REPOSITORY_URI:$IMAGE_TAG
- echo Writing image definitions file...
- printf '[{"name":"hello-world","imageUri":"%s"}]' $REPOSITORY_URI:$IMAGE_TAG > imagedefinitions.json
artifacts:
files: imagedefinitions.json
```
La spécification de construction a été écrite pour l'exemple de définition de tâche fourni dans[Conditions préalables](#ecs-cd-prereqs), utilisé par le service Amazon ECS pour ce didacticiel. La valeur `REPOSITORY_URI` correspond au référentiel `image` (sans aucune balise d'image), tandis que la valeur `hello-world` située vers la fin du fichier correspond au nom de conteneur dans la définition de tâche du service.
**Pour ajouter un fichier `buildspec.yml` à votre référentiel source**
1. Ouvrez un éditeur de texte, puis copiez et collez la spécification de génération précédente dans un nouveau fichier.
1. Remplacez la `REPOSITORY_URI` valeur (`012345678910.dkr.ecr.us-west-2.amazonaws.com/hello-world`) par l'URI de votre référentiel Amazon ECR (sans aucune balise d'image) pour votre image Docker. Remplacez `hello-world` par le nom de conteneur figurant dans la définition de tâche de votre service qui fait référence à votre image Docker.
1. Validez votre fichier `buildspec.yml` et transmettez-le à votre référentiel source.
1. Ajoutez le fichier.
```
git add .
```
1. Validez la modification.
```
git commit -m "Adding build specification."
```
1. Transmettez la validation.
```
git push
```
## Étape 2 : Création de votre pipeline de déploiement continu
Utilisez l' CodePipeline assistant pour créer les étapes de votre pipeline et connecter votre référentiel source à votre service ECS.
**Pour créer le pipeline**
1. Ouvrez la CodePipeline console à l'adresse [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).
1. Sur la page **Welcome (Bienvenue)**, choisissez **Créer un pipeline**.
Si c'est la première fois que vous l'utilisez CodePipeline, une page d'introduction apparaît à la place du message de **bienvenue**. Choisir **Get Started Now** (Démarrer maintenant).
1. Sur la page **Étape 1 : Choisir une option de création**, sous **Options de création**, choisissez l'option **Créer un pipeline personnalisé**. Choisissez **Suivant**.
1. À **l'étape 2 : Choisissez les paramètres** **du pipeline, dans Nom du pipeline**, tapez le nom de votre pipeline. Pour ce didacticiel, le nom du pipeline est **hello-world**.
1. Dans **Type de pipeline**, conservez la sélection par défaut à **V2**. Les types de pipelines diffèrent en termes de caractéristiques et de prix. Pour de plus amples informations, veuillez consulter [Types de pipelines](pipeline-types.md). Choisissez **Suivant**.
1. Sur la page **Étape 3 : Ajouter une étape source**, pour **Source provider**, sélectionnez ** AWS CodeCommit**.
1. Pour **Nom du référentiel**, choisissez le nom du référentiel CodeCommit à utiliser comme emplacement source pour votre pipeline.
1. Pour **Nom de branche**, choisissez la branche à utiliser, puis **Étape suivante**.
1. Sur la page **Étape 4 : Ajouter une étape de construction**, pour le **fournisseur de construction **AWS CodeBuild****, sélectionnez, puis sélectionnez **Créer un projet**.
1. Dans **Nom du projet**, attribuez un nom unique à votre projet de génération. Pour ce didacticiel, le nom de projet est **hello-world**.
1. Pour **Image d'environnement**, choisissez **Managed image (Image gérée)**.
1. Pour **Operating system (Système d'exploitation)**, choisissez **Amazon Linux 2**.
1. Pour **Runtime(s) (Exécution(s))**, sélectionnez **Standard**.
1. Pour **Image**, choisissez **`aws/codebuild/amazonlinux2-x86_64-standard:3.0`**.
1. Pour la **Image version (Version d'image)** et le **Environment type (Type d'environnement)**, utilisez les valeurs par défaut.
1. Sélectionnez **Enable this flag if you want to build Docker images or want your builds to get elevated privileges (Activer cet indicateur si vous souhaitez créer des images Docker ou que vos builds reçoivent des privilèges élevés)**.
1. Désélectionnez les **CloudWatch journaux**. Il se peut que vous deviez développer le **mode Avancé**.
1. Choisissez **Continuer vers CodePipeline**.
1. Choisissez **Suivant**.
**Note**
L'assistant crée un rôle CodeBuild de service pour votre projet de build, appelé **codebuild- *build-project-name* -service-role**. Notez ce nom de rôle lorsque vous y ajouterez des autorisations Amazon ECR ultérieurement.
1. Sur la page **Étape 5 : Ajouter une étape de déploiement**, dans le **champ Fournisseur de déploiement**, sélectionnez **Amazon ECS**.
1. Dans le **champ Nom du cluster**, choisissez le cluster Amazon ECS dans lequel votre service est exécuté. Pour ce didacticiel, le cluster est **default**.
1. Pour **Nom du service**, choisissez le service à mettre à jour, puis **Étape suivante**. Pour ce didacticiel, le nom de service est **hello-world**.
1. Sur la page **Étape 6 : Vérification**, vérifiez la configuration de votre pipeline, puis choisissez **Créer un pipeline** pour créer le pipeline.
**Note**
Maintenant que le pipeline est créé, il essaie d'exécuter les différentes phases. Cependant, le CodeBuild rôle par défaut créé par l'assistant n'est pas autorisé à exécuter toutes les commandes contenues dans le `buildspec.yml` fichier, de sorte que la phase de génération échoue. Les autorisations nécessaires à la phase de génération sont ajoutées dans la section suivante.
## Étape 3 : ajouter des autorisations Amazon ECR au rôle CodeBuild
L' CodePipeline assistant a créé un rôle IAM pour le projet de construction, appelé CodeBuild **codebuild- *build-project-name* -service-role**. Pour ce didacticiel, le nom est **codebuild-hello-world-service-role**. Étant donné que le `buildspec.yml` fichier appelle les opérations de l'API Amazon ECR, le rôle doit disposer d'une politique autorisant les autorisations nécessaires pour effectuer ces appels Amazon ECR. La procédure suivante vous aide à attacher les autorisations adéquates au rôle.
**Pour ajouter des autorisations Amazon ECR au rôle CodeBuild**
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 de gauche, choisissez **Rôles**.
1. Dans le champ de recherche, tapez **codebuild-** et choisissez le rôle créé par l' CodePipeline assistant. Pour ce didacticiel, le nom du rôle est **codebuild-hello-world-service-role**.
1. Sur la page **Summary (Récapitulatif)**, choisissez **Attach policies (Attacher les stratégies)**.
1. Cochez la case située à gauche de la EC2 ContainerRegistryPowerUser politique **Amazon**, puis choisissez **Joindre la politique**.
## Étape 4 : Test de votre pipeline
Votre pipeline doit disposer de tous les éléments nécessaires pour exécuter un déploiement AWS continu end-to-end natif. À présent, testez sa fonctionnalité en transmettant une modification de code à votre référentiel source.
**Pour tester votre pipeline**
1. Apportez une modification de code au référentiel source que vous avez configuré, validez-la, puis transmettez-la.
1. Ouvrez la CodePipeline console à l'adresse [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).
1. Choisissez votre pipeline dans la liste.
1. Observez la progression du pipeline dans ses différentes phases. Votre pipeline doit être terminé et votre service Amazon ECS exécute l'image Docker créée à partir de votre modification de code.