Amazon n' CodeCatalyst est plus ouvert aux nouveaux clients. Les clients existants peuvent continuer à utiliser le service normalement. Pour de plus amples informations, veuillez consulter [Comment effectuer une migration depuis CodeCatalyst](migration.md).

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éployer une application sur Amazon ECS
<a name="deploy-tut-ecs"></a>

Dans ce didacticiel, vous apprendrez à déployer une application sans serveur dans Amazon Elastic Container Service (Amazon ECS) à l'aide d'un flux de travail, Amazon ECS, et de quelques autres services. AWS L'application déployée est un simple site Web Hello World construit sur une image Docker du serveur Web Apache. Le didacticiel explique les tâches de préparation requises, telles que la configuration d'un cluster, puis décrit comment créer un flux de travail pour créer et déployer l'application.

**Astuce**  
Au lieu de suivre ce didacticiel, vous pouvez utiliser un plan qui effectue une configuration complète d'Amazon ECS pour vous. Vous devrez utiliser l'**API Node.js avec AWS Fargate ou l'API** **Java avec AWS Fargate** Blueprint. Pour de plus amples informations, veuillez consulter [Création d'un projet à l'aide d'un plan](projects-create.md#projects-create-console-template).

**Topics**
+ [Conditions préalables](#deploy-tut-ecs-prereqs)
+ [Étape 1 : configurer un AWS utilisateur et AWS CloudShell](#deploy-tut-ecs-user-cloudshell)
+ [Étape 2 : Déployer une application fictive dans Amazon ECS](#deploy-tut-ecs-placeholder)
+ [Étape 3 : créer un référentiel d'images Amazon ECR](#deploy-tut-ecs-ecr)
+ [Étape 4 : Création de AWS rôles](#deploy-tut-ecs-build-deploy-roles)
+ [Étape 5 : Ajouter AWS des rôles à CodeCatalyst](#deploy-tut-ecs-import-roles)
+ [Étape 6 : Création d'un référentiel source](#deploy-tut-ecs-source-repo)
+ [Étape 7 : Ajouter des fichiers source](#deploy-tut-ecs-source-files)
+ [Étape 8 : créer et exécuter un flux de travail](#deploy-tut-ecs-workflow)
+ [Étape 9 : Apportez une modification à vos fichiers source](#deploy-tut-ecs-change)
+ [Nettoyage](#deploy-tut-ecs-cleanup)

## Conditions préalables
<a name="deploy-tut-ecs-prereqs"></a>

Avant de commencer :
+ Vous avez besoin d'un CodeCatalyst **espace** avec un AWS compte connecté. Pour de plus amples informations, veuillez consulter [Création d’un espace](spaces-create.md).
+ Dans votre espace, vous avez besoin d'un projet vide appelé :

  ```
  codecatalyst-ecs-project
  ```

  Utilisez l'option **Partir de zéro** pour créer ce projet.

  Pour de plus amples informations, veuillez consulter [Création d'un projet vide dans Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Dans votre projet, vous avez besoin d'un CodeCatalyst **environnement** appelé :

  ```
  codecatalyst-ecs-environment
  ```

  Configurez cet environnement comme suit :
  + Choisissez n'importe quel type, tel que **Non-production**.
  +  AWS Connectez-y votre compte.
  + Pour le **rôle IAM par défaut**, choisissez n'importe quel rôle. Vous spécifierez un autre rôle ultérieurement.

  Pour de plus amples informations, veuillez consulter [Déploiement dans Comptes AWS et VPCs](deploy-environments.md).

## Étape 1 : configurer un AWS utilisateur et AWS CloudShell
<a name="deploy-tut-ecs-user-cloudshell"></a>

La première étape de ce didacticiel consiste à créer un utilisateur dans AWS IAM Identity Center et à lancer une AWS CloudShell instance sous le nom de cet utilisateur. Pendant la durée de ce didacticiel, CloudShell c'est votre ordinateur de développement et c'est là que vous configurez les AWS ressources et les services. Supprimez cet utilisateur après avoir terminé le didacticiel.

**Note**  
N'utilisez pas votre utilisateur root pour ce didacticiel. Vous devez créer un utilisateur distinct, sinon vous risquez de rencontrer des problèmes lors de l'exécution d'actions dans la AWS Command Line Interface (CLI) ultérieurement.

Pour plus d'informations sur les utilisateurs d'IAM Identity Center CloudShell, consultez le guide de l'*AWS IAM Identity Center utilisateur et le guide* de *AWS CloudShell l'utilisateur*. 

**Pour créer un utilisateur IAM Identity Center**

1. Connectez-vous à la AWS IAM Identity Center console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/singlesignon/](https://console.aws.amazon.com/singlesignon/).
**Note**  
Assurez-vous de vous connecter à l'aide de Compte AWS celui qui est connecté à votre CodeCatalyst espace. Vous pouvez vérifier quel compte est connecté en accédant à votre espace et en choisissant l'onglet **Comptes AWS**. Pour de plus amples informations, veuillez consulter [Création d’un espace](spaces-create.md).

1. Dans le panneau de navigation, choisissez **Users (Utilisateurs)**, puis **Add user (Ajouter un utilisateur)**.

1. Dans **Nom d'utilisateur**, entrez :

   ```
   CodeCatalystECSUser
   ```

1. Sous **Mot de passe**, choisissez **Générer un mot de passe à usage unique que vous pouvez partager avec cet utilisateur**.

1. Dans **Adresse e-mail** et **Confirmer l'adresse e-mail**, entrez une adresse e-mail qui n'existe pas encore dans IAM Identity Center.

1. Dans **Prénom et nom** **de famille**, entrez :

   ```
   CodeCatalystECSUser
   ```

1. Dans **Nom d'affichage**, conservez le nom généré automatiquement :

   ```
   CodeCatalystECSUser CodeCatalystECSUser
   ```

1. Choisissez **Suivant**.

1. Sur la page **Ajouter un utilisateur aux groupes**, choisissez **Next**.

1. Sur la page **Vérifier et ajouter un utilisateur**, passez en revue les informations et choisissez **Ajouter un utilisateur**.

   Une boîte **de dialogue de mot de passe à usage unique** s'affiche.

1. Choisissez **Copier**, puis collez les informations de connexion, y compris l'URL du portail AWS d'accès et le mot de passe à usage unique.

1. Choisissez **Fermer**.

**Pour créer un jeu d'autorisations**

Vous attribuerez cet ensemble d'autorisations à une `CodeCatalystECSUser` date ultérieure.

1. Dans le volet de navigation, choisissez **Ensembles d'autorisations**, puis choisissez **Créer un ensemble d'autorisations**.

1. Choisissez **Ensemble d'autorisations prédéfini**, puis sélectionnez **AdministratorAccess**. Cette politique fournit des autorisations complètes à tous Services AWS. 

1. Choisissez **Suivant**.

1. Dans **Nom du jeu d'autorisations**, entrez :

   ```
   CodeCatalystECSPermissionSet
   ```

1. Choisissez **Suivant**.

1. Sur la page **Réviser et créer**, passez en revue les informations et choisissez **Créer**.

**Pour attribuer l'ensemble d'autorisations à CodeCatalyst ECSUser**

1. Dans le volet de navigation, choisissez **Comptes AWS**, puis cochez la case à côté de Compte AWS celle à laquelle vous êtes actuellement connecté.

1. Choisissez **Attribuer des utilisateurs ou des groupes**.

1. Sélectionnez l’onglet **Utilisateurs**.

1. Cochez la case située à côté de`CodeCatalystECSUser`.

1. Choisissez **Suivant**.

1. Cochez la case située à côté de`CodeCatalystECSPermissionSet`.

1. Choisissez **Suivant**.

1. Vérifiez les informations et choisissez **Soumettre**.

   Vous les avez maintenant assignés `CodeCatalystECSUser` et `CodeCatalystECSPermissionSet` à votre Compte AWS, en les liant ensemble.

**Pour vous déconnecter et vous reconnecter en tant que CodeCatalyst ECSUser**

1. Avant de vous déconnecter, assurez-vous d'avoir l'URL du portail AWS d'accès ainsi que le nom d'utilisateur et le mot de passe à usage unique pour`CodeCatalystECSUser`. Vous devriez avoir copié ces informations dans un éditeur de texte plus tôt.
**Note**  
Si vous ne disposez pas de ces informations, rendez-vous sur la page de `CodeCatalystECSUser` détails dans IAM Identity Center, choisissez **Réinitialiser le mot de passe**, **Générer un mot de passe à usage unique [...]** , et **Réinitialisez à nouveau le mot** de passe pour afficher les informations à l'écran.

1. Déconnectez-vous de AWS.

1. Collez l'URL du portail d' AWS accès dans la barre d'adresse de votre navigateur.

1. Connectez-vous avec le nom d'utilisateur et le mot de passe à usage unique pour`CodeCatalystECSUser`.

1. Dans **Nouveau mot de passe**, entrez un mot de passe, puis choisissez **Définir un nouveau mot de passe**.

   Une **Compte AWS**boîte apparaît à l'écran.

1. Choisissez **Compte AWS**, puis choisissez le nom de l'utilisateur Compte AWS auquel vous avez attribué l'`CodeCatalystECSUser`utilisateur et le jeu d'autorisations.

1. À côté de`CodeCatalystECSPermissionSet`, choisissez **Console de gestion**.

   Le AWS Management Console apparaît. Vous êtes maintenant connecté `CodeCatalystECSUser` avec les autorisations appropriées.

**Pour lancer une AWS CloudShell instance**

1. Par `CodeCatalystECSUser` exemple, dans la barre de navigation supérieure, choisissez l' AWS icône (![\[AWS icon\]](http://docs.aws.amazon.com/fr_fr/codecatalyst/latest/userguide/images/deploy/aws-logo.png)).

   La page principale du AWS Management Console apparaît.

1. Dans la barre de navigation supérieure, choisissez l' AWS CloudShell icône (![\[CloudShell icon\]](http://docs.aws.amazon.com/fr_fr/codecatalyst/latest/userguide/images/deploy/CloudShell.png)).

   CloudShell ouvre. Patientez pendant la création de CloudShell l'environnement.
**Note**  
Si l' CloudShell icône ne s'affiche pas, assurez-vous que vous vous trouvez dans une [région prise en charge par CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/faq-list.html#regions-available). Ce didacticiel part du principe que vous vous trouvez dans la région de l'ouest des États-Unis (Oregon).

**Pour vérifier AWS CLI que le**

1. Dans le CloudShell terminal, saisissez :

   ```
   aws --version
   ```

1. Vérifiez qu'une version apparaît.

   Il AWS CLI est déjà configuré pour l'utilisateur actuel`CodeCatalystECSUser`, il n'est donc pas nécessaire de configurer AWS CLI les clés et les informations d'identification, comme c'est normalement le cas.

## Étape 2 : Déployer une application fictive dans Amazon ECS
<a name="deploy-tut-ecs-placeholder"></a>

Dans cette section, vous déployez manuellement une application fictive dans Amazon ECS. Cette application fictive sera remplacée par l'application Hello World déployée par votre flux de travail. L'application fictive est le serveur Web Apache.

Pour plus d'informations sur Amazon ECS, consultez le *guide du développeur Amazon Elastic Container Service*.

Suivez la série de procédures ci-dessous pour déployer l'application fictive.<a name="deploy-tut-ecs-create-task-execution-role"></a>

**Pour créer le rôle d'exécution des tâches**

Ce rôle accorde à Amazon ECS l' AWS Fargate autorisation d'effectuer des appels d'API en votre nom. 

1. Créez une politique de confiance :

   1. Dans AWS CloudShell, entrez la commande suivante :

      ```
      cat > codecatalyst-ecs-trust-policy.json
      ```

      Un message clignotant apparaît dans le CloudShell terminal.

   1. Entrez le code suivant à l'invite :

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

****  

      ```
      {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
          {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
              "Service": "ecs-tasks.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
          }
        ]
      }
      ```

------

   1. Placez votre curseur après le dernier crochet (`}`).

   1. Appuyez sur **Enter** puis **Ctrl\$1d** pour enregistrer le fichier et quitter cat.

1. Créez un rôle d'exécution de tâches :

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-task-execution-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Associez la `AmazonECSTaskExecutionRolePolicy` politique AWS gérée au rôle :

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-task-execution-role \
         --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
   ```

1. Afficher les détails du rôle :

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-task-execution-role
   ```

1. Notez la `"Arn":` valeur du rôle, par exemple`arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role`. Vous aurez besoin de cet Amazon Resource Name (ARN) ultérieurement.

**Pour créer un nouveau cluster Amazon ECS**

Ce cluster contiendra l'application d'espace réservé Apache, puis l'application Hello World. 

1. Comme dans `CodeCatalystECSUser` AWS CloudShell, créez un cluster vide :

   ```
   aws ecs create-cluster --cluster-name codecatalyst-ecs-cluster
   ```

1. (Facultatif) Vérifiez que le cluster a été créé avec succès :

   ```
   aws ecs list-clusters
   ```

   L'ARN du `codecatalyst-ecs-cluster` cluster doit apparaître dans la liste, indiquant une création réussie.

**Pour créer un fichier de définition de tâche**

Le fichier de définition de tâche indique d'exécuter l'image Docker (`httpd:2.4`) [du serveur Web Apache 2.4](https://hub.docker.com/_/httpd) dont elle est DockerHub extraite.

1. Comme dans `CodeCatalystECSUser` AWS CloudShell, créez un fichier de définition de tâche :

   ```
   cat > taskdef.json
   ```

1. Collez le code suivant à l'invite :

   ```
   {
       "executionRoleArn": "arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               "image": "httpd:2.4",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "cpu": "256",
       "family": "codecatalyst-ecs-task-def",
       "memory": "512",
       "networkMode": "awsvpc"
   }
   ```

   Dans le code précédent, remplacez *arn:aws:iam::111122223333:role/codecatalyst-ecs-task-execution-role*

   avec l'ARN du rôle d'exécution de tâche que vous avez noté dans[Pour créer le rôle d'exécution des tâches](#deploy-tut-ecs-create-task-execution-role).

1. Placez votre curseur après le dernier crochet (`}`).

1. Appuyez sur **Enter** puis **Ctrl\$1d** pour enregistrer le fichier et quitter cat.

**Pour enregistrer le fichier de définition de tâche auprès d'Amazon ECS**

1. Comme dans `CodeCatalystECSUser` AWS CloudShell, enregistrez la définition de tâche :

   ```
   aws ecs register-task-definition \
       --cli-input-json file://taskdef.json
   ```

1. (Facultatif) Vérifiez que la définition de tâche a été enregistrée :

   ```
   aws ecs list-task-definitions
   ```

   La définition de la `codecatalyst-ecs-task-def` tâche doit apparaître dans la liste.

**Pour créer le service Amazon ECS**

Le service Amazon ECS exécute les tâches (et les conteneurs Docker associés) de l'application fictive Apache, puis de l'application Hello World.

1. Par `CodeCatalystECSUser` exemple, passez à la console Amazon Elastic Container Service si ce n'est pas déjà fait.

1. Choisissez le cluster que vous avez créé précédemment,`codecatalyst-ecs-cluster`.

1. Dans l'onglet **Services**, choisissez **Create**.

1. Dans la page **Créer**, procédez comme suit :

   1. Conservez tous les paramètres par défaut, à l'exception de ceux listés ci-dessous.

   1. Pour **Launch type (Type de lancement)**, choisissez **FARGATE**.

   1. Sous **Définition de la tâche**, dans la liste déroulante **Famille**, sélectionnez :

      `codecatalyst-ecs-task-def`

   1. Dans le **champ Nom du service**, entrez :

      ```
      codecatalyst-ecs-service
      ```

   1. Dans la **zone Tâches souhaitées**, entrez :

      ```
      3
      ```

      Dans ce didacticiel, chaque tâche lance un conteneur Docker unique.

   1. Développez la section **Mise en réseau**.

   1. Pour **VPC**, choisissez n'importe quel VPC.

   1. Pour les **sous-réseaux**, choisissez n'importe quel sous-réseau.
**Note**  
Spécifiez un seul sous-réseau. C'est tout ce dont vous avez besoin pour ce tutoriel.
**Note**  
Si vous n'avez pas de VPC ni de sous-réseau, créez-les. Consultez les [sections Créer un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) et [Créer un sous-réseau dans votre VPC dans le guide de l'utilisateur *Amazon* VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#AddaSubnet).

   1. Pour **Groupe de sécurité**, choisissez **Créer un nouveau groupe de sécurité**, puis procédez comme suit :

      1. Pour le **nom du groupe de sécurité**, entrez :

         ```
         codecatalyst-ecs-security-group
         ```

      1. Pour **la description du groupe de sécurité**, entrez :

         ```
         CodeCatalyst ECS security group
         ```

      1. Choisissez **Ajouter une règle**. Pour **Type**, choisissez **HTTP**, et pour **Source**, choisissez **Anywhere**.

   1. En bas, choisissez **Create**.

   1. Patientez pendant la création du service. Cette opération peut prendre quelques minutes.

1. Cliquez sur l'onglet **Tâches**, puis sur le bouton d'actualisation. Vérifiez que la colonne **Dernier état** des trois tâches est définie sur En **cours d'exécution**.

**(Facultatif) Pour vérifier que votre application d'espace réservé Apache est en cours d'exécution**

1. Dans l'onglet **Tâches**, choisissez l'une des trois tâches.

1. Dans le champ **IP publique**, choisissez une **adresse ouverte**.

   Une `It Works!` page apparaît. Cela indique que le service Amazon ECS a démarré avec succès une tâche qui a lancé un conteneur Docker avec l'image Apache.

   À ce stade du didacticiel, vous avez déployé manuellement une définition de cluster, de service et de tâche Amazon ECS, ainsi qu'une application d'espace réservé Apache. Tous ces éléments étant en place, vous êtes maintenant prêt à créer un flux de travail qui remplacera l'application fictive Apache par l'application Hello World du didacticiel.

## Étape 3 : créer un référentiel d'images Amazon ECR
<a name="deploy-tut-ecs-ecr"></a>

Dans cette section, vous allez créer un référentiel d'images privé dans Amazon Elastic Container Registry (Amazon ECR). Ce dépôt stocke l'image Docker du didacticiel qui remplacera l'image fictive d'Apache que vous avez déployée précédemment. 

Pour plus d'informations sur Amazon ECR, consultez le *guide de l'utilisateur d'Amazon Elastic Container Registry*.

**Pour créer un référentiel d'images dans Amazon ECR**

1. Par `CodeCatalystECSUser` exemple, dans AWS CloudShell, créez un référentiel vide dans Amazon ECR :

   ```
   aws ecr create-repository --repository-name codecatalyst-ecs-image-repo
   ```

1. Affichez les détails du référentiel Amazon ECR :

   ```
   aws ecr describe-repositories \
         --repository-names codecatalyst-ecs-image-repo
   ```

1. Notez la `“repositoryUri”:` valeur, par exemple,`111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo`.

   Vous en aurez besoin ultérieurement lors de l'ajout du référentiel à votre flux de travail. 

## Étape 4 : Création de AWS rôles
<a name="deploy-tut-ecs-build-deploy-roles"></a>

Dans cette section, vous allez créer les rôles AWS IAM dont votre CodeCatalyst flux de travail aura besoin pour fonctionner. Ces rôles sont les suivants :
+ **Rôle de création** : accorde à l'action de CodeCatalyst création (dans le flux de travail) l'autorisation d'accéder à votre AWS compte et d'écrire sur Amazon ECR et Amazon EC2.
+ **Rôle de déploiement** : accorde à l'action CodeCatalyst **Deploy to ECS** (dans le flux de travail) l'autorisation d'accéder à votre AWS compte, à Amazon ECS et à quelques autres AWS services.

Pour plus d'informations sur les rôles IAM, consultez la section Rôles [IAM dans le Guide](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) de l'*Gestion des identités et des accès AWS utilisateur*.

**Note**  
Pour gagner du temps, vous pouvez créer un seul rôle, appelé `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle, au lieu des deux rôles répertoriés précédemment. Pour de plus amples informations, veuillez consulter [Création du **CodeCatalystWorkflowDevelopmentRole-*spaceName***rôle pour votre compte et votre espace](ipa-iam-roles.md#ipa-iam-roles-service-create). Sachez que le `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle dispose d'autorisations très étendues, ce qui peut présenter un risque de sécurité. Nous vous recommandons de n'utiliser ce rôle que dans les didacticiels et les scénarios où la sécurité est moins préoccupante. Ce didacticiel part du principe que vous créez les deux rôles répertoriés précédemment.

Pour créer les rôles de génération et de déploiement, vous pouvez utiliser le AWS Management Console ou le AWS CLI.

------
#### [ AWS Management Console ]

Pour créer les rôles de génération et de déploiement, suivez la série de procédures suivante.

**Pour créer un rôle de build**

1. Créez une politique pour le rôle, comme suit :

   1. Connectez-vous à AWS.

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

   1. Dans le panneau de navigation, choisissez **Politiques**.

   1. Choisissez **Create Policy** (Créer une politique).

   1. Choisissez l'onglet **JSON**.

   1. Supprimez le code existant.

   1. Collez le code suivant :

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

****  

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

------
**Note**  
La première fois que le rôle est utilisé pour exécuter des actions de flux de travail, utilisez le caractère générique dans la déclaration de politique de ressources, puis définissez la stratégie avec le nom de la ressource une fois celle-ci disponible.  

      ```
      "Resource": "*"
      ```

   1. Choisissez **Suivant : Balises**.

   1. Choisissez **Suivant : Vérification**.

   1. Dans **Nom**, entrez :

      ```
      codecatalyst-ecs-build-policy
      ```

   1. Choisissez **Create Policy** (Créer une politique).

      Vous venez de créer une politique d'autorisation.

1. Créez le rôle de build, comme suit :

   1. Dans le volet de navigation, sélectionnez **Rôles**, puis **Créer un rôle**.

   1. Choisissez **Politique de confiance personnalisée**.

   1. Supprimez la politique de confiance personnalisée existante.

   1. Ajoutez la politique de confiance personnalisée suivante :

   1. Choisissez **Suivant**.

   1. Dans **Politiques d'autorisations**`codecatalyst-ecs-build-policy`, recherchez et cochez la case correspondante.

   1. Choisissez **Suivant**.

   1. Dans **Nom du rôle**, entrez :

      ```
      codecatalyst-ecs-build-role
      ```

   1. Pour la **description du rôle**, entrez :

      ```
      CodeCatalyst ECS build role
      ```

   1. Choisissez **Créer un rôle**.

   Vous avez maintenant créé un rôle de build avec une politique d'autorisation et une politique de confiance.

1. Obtenez l'ARN du rôle de build, comme suit :

   1. Dans le panneau de navigation, choisissez **Rôles**.

   1. Dans le champ de recherche, entrez le nom du rôle que vous venez de créer (`codecatalyst-ecs-build-role`).

   1. Choisissez le rôle dans la liste.

      La page **Résumé** du rôle apparaît.

   1. En haut, copiez la valeur **ARN**. Vous en aurez besoin ultérieurement.

**Pour créer un rôle de déploiement**

1. Créez une politique pour le rôle, comme suit :

   1. Connectez-vous à AWS.

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

   1. Dans le panneau de navigation, choisissez **Politiques**.

   1. Choisissez **Create Policy** (Créer une politique).

   1. Choisissez l'onglet **JSON**.

   1. Supprimez le code existant.

   1. Collez le code suivant :

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Note**  
La première fois que le rôle est utilisé pour exécuter des actions de flux de travail, utilisez le caractère générique dans la déclaration de politique de ressources. Vous pouvez ensuite définir la politique avec le nom de la ressource une fois celle-ci disponible.  

      ```
      "Resource": "*"
      ```

   1. Choisissez **Suivant : Balises**.

   1. Choisissez **Suivant : Vérification**.

   1. Dans **Nom**, entrez :

      ```
      codecatalyst-ecs-deploy-policy
      ```

   1. Choisissez **Create Policy** (Créer une politique).

      Vous venez de créer une politique d'autorisation.

1. Créez le rôle de déploiement comme suit :

   1. Dans le volet de navigation, sélectionnez **Rôles**, puis **Créer un rôle**.

   1. Choisissez **Politique de confiance personnalisée**.

   1. Supprimez la politique de confiance personnalisée existante.

   1. Ajoutez la politique de confiance personnalisée suivante :

   1. Choisissez **Suivant**.

   1. Dans **Politiques d'autorisations**`codecatalyst-ecs-deploy-policy`, recherchez et cochez la case correspondante.

   1. Choisissez **Suivant**.

   1. Dans **Nom du rôle**, entrez :

      ```
      codecatalyst-ecs-deploy-role
      ```

   1. Pour la **description du rôle**, entrez :

      ```
      CodeCatalyst ECS deploy role
      ```

   1. Choisissez **Créer un rôle**.

   Vous venez de créer un rôle de déploiement avec une politique de confiance.

1. Obtenez l'ARN du rôle de déploiement, comme suit :

   1. Dans le panneau de navigation, choisissez **Rôles**.

   1. Dans le champ de recherche, entrez le nom du rôle que vous venez de créer (`codecatalyst-ecs-deploy-role`).

   1. Choisissez le rôle dans la liste.

      La page **Résumé** du rôle apparaît.

   1. En haut, copiez la valeur **ARN**. Vous en aurez besoin ultérieurement.

------
#### [ AWS CLI ]

Pour créer les rôles de génération et de déploiement, suivez la série de procédures suivante.

**Pour créer une politique de confiance pour les deux rôles**

Comme dans `CodeCatalystECSUser` AWS CloudShell, créez un fichier de politique de confiance :

1. Créez le fichier :

   ```
   cat > codecatalyst-ecs-trust-policy.json
   ```

1. À l'invite du terminal, collez le code suivant :

1. Placez votre curseur après le dernier crochet (`}`).

1. Appuyez sur **Enter** puis **Ctrl\$1d** pour enregistrer le fichier et quitter cat.

**Pour créer la politique de construction et le rôle de construction**

1. Créez la politique de construction :

   1. Comme dans `CodeCatalystECSUser` AWS CloudShell, créez un fichier de politique de construction :

      ```
      cat > codecatalyst-ecs-build-policy.json
      ```

   1. À l'invite, entrez le code suivant :

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

****  

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

------

   1. Placez votre curseur après le dernier crochet (`}`).

   1. Appuyez sur **Enter** puis **Ctrl\$1d** pour enregistrer le fichier et quitter cat.

1. Ajoutez la politique de construction à AWS :

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-build-policy \
       --policy-document file://codecatalyst-ecs-build-policy.json
   ```

1. Dans la sortie de commande, notez la `"arn":` valeur, par exemple,`arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy`. Vous aurez besoin de cet ARN ultérieurement.

1. Créez le rôle de build et associez-y la politique de confiance :

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-build-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Associez la politique de build au rôle de build :

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-build-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy
   ```

   Where *arn:aws:iam::111122223333:policy/codecatalyst-ecs-build-policy* est remplacé par l'ARN de la politique de construction que vous avez mentionnée précédemment.

1. Affichez les détails du rôle de build :

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-build-role
   ```

1. Notez la `"Arn":` valeur du rôle, par exemple`arn:aws:iam::111122223333:role/codecatalyst-ecs-build-role`. Vous aurez besoin de cet ARN ultérieurement.

**Pour créer la politique de déploiement et le rôle de déploiement**

1. Créez une politique de déploiement :

   1. Dans AWS CloudShell, créez un fichier de politique de déploiement :

      ```
      cat > codecatalyst-ecs-deploy-policy.json
      ```

   1. À l'invite, entrez le code suivant :

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [{
          "Action":[
            "ecs:DescribeServices",
            "ecs:CreateTaskSet",
            "ecs:DeleteTaskSet",
            "ecs:ListClusters",
            "ecs:RegisterTaskDefinition",
            "ecs:UpdateServicePrimaryTaskSet",
            "ecs:UpdateService",
            "elasticloadbalancing:DescribeTargetGroups",
            "elasticloadbalancing:DescribeListeners",
            "elasticloadbalancing:ModifyListener",
            "elasticloadbalancing:DescribeRules",
            "elasticloadbalancing:ModifyRule",
            "lambda:InvokeFunction",
            "lambda:ListFunctions",
            "cloudwatch:DescribeAlarms",
            "sns:Publish",
            "sns:ListTopics", 
            "s3:GetObject",
            "s3:GetObjectVersion",
            "codedeploy:CreateApplication", 
            "codedeploy:CreateDeployment", 
            "codedeploy:CreateDeploymentGroup", 
            "codedeploy:GetApplication", 
            "codedeploy:GetDeployment", 
            "codedeploy:GetDeploymentGroup", 
            "codedeploy:ListApplications", 
            "codedeploy:ListDeploymentGroups", 
            "codedeploy:ListDeployments", 
            "codedeploy:StopDeployment", 
            "codedeploy:GetDeploymentTarget", 
            "codedeploy:ListDeploymentTargets", 
            "codedeploy:GetDeploymentConfig", 
            "codedeploy:GetApplicationRevision", 
            "codedeploy:RegisterApplicationRevision", 
            "codedeploy:BatchGetApplicationRevisions", 
            "codedeploy:BatchGetDeploymentGroups", 
            "codedeploy:BatchGetDeployments", 
            "codedeploy:BatchGetApplications", 
            "codedeploy:ListApplicationRevisions", 
            "codedeploy:ListDeploymentConfigs", 
            "codedeploy:ContinueDeployment"           
         ],
         "Resource":"*",
         "Effect":"Allow"
      },{"Action":[
            "iam:PassRole"
         ],
         "Effect":"Allow",
         "Resource":"*",
         "Condition":{"StringLike":{"iam:PassedToService":[
                  "ecs-tasks.amazonaws.com",
                  "codedeploy.amazonaws.com"
               ]
            }
         }
      }]
      }
      ```

------
**Note**  
La première fois que le rôle est utilisé pour exécuter des actions de flux de travail, utilisez le caractère générique dans la déclaration de politique de ressources, puis définissez la stratégie avec le nom de la ressource une fois celle-ci disponible.  

      ```
      "Resource": "*"
      ```

   1. Placez votre curseur après le dernier crochet (`}`).

   1. Appuyez sur **Enter** puis **Ctrl\$1d** pour enregistrer le fichier et quitter cat.

1. Ajoutez la politique de déploiement à AWS :

   ```
   aws iam create-policy \
       --policy-name codecatalyst-ecs-deploy-policy \
       --policy-document file://codecatalyst-ecs-deploy-policy.json
   ```

1. Dans le résultat de la commande, notez la `"arn":` valeur de la politique de déploiement, par exemple,`arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy`. Vous aurez besoin de cet ARN ultérieurement.

1. Créez le rôle de déploiement et associez-y la politique de confiance :

   ```
   aws iam create-role \
         --role-name codecatalyst-ecs-deploy-role \
         --assume-role-policy-document file://codecatalyst-ecs-trust-policy.json
   ```

1. Attachez la politique de déploiement au rôle de déploiement, qui *arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy* est remplacé par l'ARN de la stratégie de déploiement que vous avez mentionnée précédemment.

   ```
   aws iam attach-role-policy \
         --role-name codecatalyst-ecs-deploy-role \
         --policy-arn arn:aws:iam::111122223333:policy/codecatalyst-ecs-deploy-policy
   ```

1. Affichez les détails du rôle de déploiement :

   ```
   aws iam get-role \
         --role-name codecatalyst-ecs-deploy-role
   ```

1. Notez la `"Arn":` valeur du rôle, par exemple`arn:aws:iam::111122223333:role/codecatalyst-ecs-deploy-role`. Vous aurez besoin de cet ARN ultérieurement.

------

## Étape 5 : Ajouter AWS des rôles à CodeCatalyst
<a name="deploy-tut-ecs-import-roles"></a>

Au cours de cette étape, vous ajoutez le rôle de création (`codecatalyst-ecs-build-role`) et le rôle de déploiement (`codecatalyst-ecs-deploy-role`) à la connexion au CodeCatalyst compte dans votre espace.

**Pour ajouter des rôles de création et de déploiement à votre compte, connectez-vous**

1. Dans CodeCatalyst, naviguez jusqu'à votre espace.

1. Choisissez **AWS des comptes**. La liste des connexions au compte s'affiche.

1. Choisissez la connexion au compte qui représente le AWS compte sur lequel vous avez créé vos rôles de création et de déploiement.

1. Choisissez **Gérer les rôles depuis AWS la console de gestion**.

   La page **Ajouter un rôle IAM à Amazon CodeCatalyst Space** s'affiche. Vous devrez peut-être vous connecter pour accéder à la page.

1. Sélectionnez **Ajouter un rôle existant que vous avez créé dans IAM**.

   Une liste déroulante apparaît. La liste affiche tous les rôles IAM dotés d'une politique de confiance qui inclut les principaux de `codecatalyst.amazonaws.com` service `codecatalyst-runner.amazonaws.com` et.

1. Dans la liste déroulante, sélectionnez`codecatalyst-ecs-build-role`, puis choisissez **Ajouter un rôle**.
**Note**  
Si vous le voyez`The security token included in the request is invalid`, c'est peut-être parce que vous ne disposez pas des autorisations appropriées. Pour résoudre ce problème, déconnectez-vous et reconnectez-vous avec le AWS compte que vous avez utilisé lors de la création de votre CodeCatalyst espace. AWS 

1. Choisissez **Ajouter un rôle IAM**, choisissez **Ajouter un rôle existant que vous avez créé dans IAM**, puis dans la liste déroulante, sélectionnez. `codecatalyst-ecs-deploy-role` Choisissez **Ajouter un rôle**.

   Vous avez maintenant ajouté les rôles de création et de déploiement à votre espace.

1. Copiez la valeur du **nom CodeCatalyst d'affichage Amazon**. Vous aurez besoin de cette valeur ultérieurement, lors de la création de votre flux de travail.

## Étape 6 : Création d'un référentiel source
<a name="deploy-tut-ecs-source-repo"></a>

Au cours de cette étape, vous créez un référentiel source dans CodeCatalyst. Ce référentiel stocke les fichiers source du didacticiel, tels que le fichier de définition des tâches.

Pour plus d'informations sur les référentiels sources, consultez[Création d'un référentiel source](source-repositories-create.md).

**Pour créer un référentiel source**

1. Ouvrez la CodeCatalyst console à l'[adresse https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Accédez à votre projet,`codecatalyst-ecs-project`.

1. Dans le volet de navigation, choisissez **Code**, puis sélectionnez **Référentiels sources**. 

1. Choisissez **Ajouter un référentiel**, puis sélectionnez **Créer un référentiel**.

1. Dans **Nom du référentiel**, entrez :

   ```
   codecatalyst-ecs-source-repository
   ```

1. Choisissez **Créer**.

## Étape 7 : Ajouter des fichiers source
<a name="deploy-tut-ecs-source-files"></a>

Dans cette section, vous allez ajouter les fichiers source de Hello World à votre CodeCatalyst dépôt,`codecatalyst-ecs-source-repository`. Ils sont composés de :
+ Un `index.html` fichier — Affiche un message Hello World dans le navigateur. 
+ Un Dockerfile — Décrit l'image de base à utiliser pour votre image Docker et les commandes Docker à appliquer à celle-ci. 
+ Un `taskdef.json` fichier : définit l'image Docker à utiliser lors du lancement de tâches dans votre cluster.

La structure des dossiers est la suivante :

```
.
|— public-html
|  |— index.html
|— Dockerfile
|— taskdef.json
```

**Note**  
Les instructions suivantes vous montrent comment ajouter les fichiers à l'aide de la CodeCatalyst console, mais vous pouvez utiliser Git si vous préférez. Pour en savoir plus, consultez [Clonage d’un référentiel source](source-repositories-clone.md). 

**Topics**
+ [index.html](#deploy-tut-ecs-source-files-index)
+ [Dockerfile](#deploy-tut-ecs-source-files-dockerfile)
+ [taskdef.json](#deploy-tut-ecs-source-files-taskdef)

### index.html
<a name="deploy-tut-ecs-source-files-index"></a>

Le `index.html` fichier affiche un message Hello World dans le navigateur. 

**Pour ajouter le fichier index.html**

1. Dans la CodeCatalyst console, accédez à votre référentiel source,`codecatalyst-ecs-source-repository`.

1. Dans **Fichiers**, choisissez **Créer un fichier**.

1. Dans le **champ Nom du fichier**, entrez :

   ```
   public-html/index.html
   ```
**Important**  
Assurez-vous d'inclure le `public-html/` préfixe pour créer un dossier du même nom. Le devrait `index.html` se trouver dans ce dossier.

1. Dans la zone de texte, entrez le code suivant :

   ```
   <html>
     <head>
       <title>Hello World</title>
       <style>
         body {
         background-color: black;
         text-align: center;
         color: white;
         font-family: Arial, Helvetica, sans-serif;
         }  
       </style>
     </head>
     <body>
       <h1>Hello World</h1>
     </body>
   </html>
   ```

1. Choisissez **Commit**, puis sélectionnez **Commit** à nouveau.

   Le `index.html` est ajouté à votre dépôt dans un `public-html` dossier. 

### Dockerfile
<a name="deploy-tut-ecs-source-files-dockerfile"></a>

Le Dockerfile décrit l'image Docker de base à utiliser et les commandes Docker à lui appliquer. Pour plus d'informations sur le Dockerfile, consultez le [Dockerfile](https://docs.docker.com/engine/reference/builder/) Reference.

Le Dockerfile spécifié ici indique d'utiliser l'image de base d'Apache 2.4 ()`httpd`. Il inclut également des instructions pour copier un fichier source appelé `index.html` dans un dossier du serveur Apache qui sert aux pages Web. L'`EXPOSE`instruction du Dockerfile indique à Docker que le conteneur écoute sur le port 80.

**Pour ajouter le Dockerfile**

1. Dans votre référentiel source, choisissez **Créer un fichier**.

1. Dans le **champ Nom du fichier**, entrez :

   ```
   Dockerfile
   ```

   N'incluez pas d'extension de fichier.
**Important**  
Le Dockerfile doit résider dans le dossier racine de votre dépôt. La `Docker build` commande du flux de travail s'attend à ce qu'il soit présent.

1. Dans la zone de texte, entrez le code suivant :

   ```
   FROM httpd:2.4
   COPY ./public-html/index.html /usr/local/apache2/htdocs/index.html
   EXPOSE 80
   ```

1. Choisissez **Commit**, puis sélectionnez **Commit** à nouveau.

   Le Dockerfile est ajouté à votre dépôt. 

### taskdef.json
<a name="deploy-tut-ecs-source-files-taskdef"></a>

Le `taskdef.json` fichier que vous ajoutez à cette étape est le même que celui que vous avez déjà spécifié [Étape 2 : Déployer une application fictive dans Amazon ECS](#deploy-tut-ecs-placeholder) avec la différence suivante :

Au lieu de spécifier un nom d'image Docker codé en dur dans le `image:` champ (`httpd:2.4`), la définition de la tâche utilise ici quelques variables pour désigner l'image : et. `$REPOSITORY_URI` `$IMAGE_TAG` Ces variables seront remplacées par des valeurs réelles générées par l'action de création du flux de travail lorsque vous exécuterez le flux de travail lors d'une étape ultérieure.

Pour plus de détails sur les paramètres de définition des tâches, consultez la section [Paramètres de définition des tâches](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) dans le manuel *Amazon Elastic Container Service Developer Guide*.

**Pour ajouter le fichier taskdef.json**

1. Dans votre référentiel source, choisissez **Créer un fichier**.

1. Dans le **champ Nom du fichier**, entrez :

   ```
   taskdef.json
   ```

1. Dans la zone de texte, entrez le code suivant :

   ```
   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/codecatalyst-ecs-task-execution-role",
       "containerDefinitions": [
           {
               "name": "codecatalyst-ecs-container",
               # The $REPOSITORY_URI and $IMAGE_TAG variables will be replaced 
               # by the workflow at build time (see the build action in the 
               # workflow)
               "image": $REPOSITORY_URI:$IMAGE_TAG,
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "codecatalyst-ecs-task-def"
   }
   ```

   Dans le code précédent, remplacez

   *arn:aws:iam::account\$1ID:role/codecatalyst-ecs-task-execution-role*

   avec l'ARN du rôle d'exécution de tâche que vous avez noté dans[Pour créer le rôle d'exécution des tâches](#deploy-tut-ecs-create-task-execution-role).

1. Choisissez **Commit**, puis sélectionnez **Commit** à nouveau.

   Le `taskdef.json` fichier est ajouté à votre dépôt. 

## Étape 8 : créer et exécuter un flux de travail
<a name="deploy-tut-ecs-workflow"></a>

Au cours de cette étape, vous créez un flux de travail qui prend vos fichiers source, les intègre dans une image Docker, puis déploie l'image sur votre cluster Amazon ECS. Ce déploiement remplace l'application fictive Apache existante.

Le flux de travail comprend les éléments de base suivants qui s'exécutent de manière séquentielle :
+ Un déclencheur : ce déclencheur lance automatiquement l'exécution du flux de travail lorsque vous apportez une modification à votre référentiel source. Pour plus d'informations sur les déclencheurs, consultez [Démarrage d'un flux de travail exécuté automatiquement à l'aide de déclencheurs](workflows-add-trigger.md).
+ Une action de génération (`BuildBackend`) — Au déclenchement, l'action crée l'image Docker à l'aide du Dockerfile et envoie l'image vers Amazon ECR. L'action de génération met également à jour le `taskdef.json` avec la valeur de `image` champ correcte, puis crée un artefact de sortie de ce fichier. Cet artefact est utilisé comme entrée pour l'action de déploiement, qui est la suivante.

  Pour plus d'informations sur l'action de génération, consultez[Construire avec des flux de travail](build-workflow-actions.md).
+ Une action de déploiement (`DeployToECS`) : une fois l'action de création terminée, l'action de déploiement recherche l'artefact de sortie généré par l'action de génération (`TaskDefArtifact`), en trouve l'`taskdef.json`intérieur et l'enregistre auprès de votre service Amazon ECS. Le service suit ensuite les instructions du `taskdef.json` fichier pour exécuter trois tâches Amazon ECS et les conteneurs Hello World Docker associés au sein de votre cluster Amazon ECS. 

**Pour créer un flux de travail**

1. **Dans le volet de navigation de la CodeCatalyst console, choisissez **CI/CD**, puis Workflows.**

1. Choisissez **Créer un flux de travail**.

1. Pour **Référentiel source**, choisissez`codecatalyst-ecs-source-repository`.

1. Pour **Branch**, choisissez`main`.

1. Choisissez **Créer**.

1. Supprimez l'exemple de code YAML.

1. Ajoutez le code YAML suivant :
**Note**  
Dans le code YAML qui suit, vous pouvez omettre les `Connections:` sections si vous le souhaitez. Si vous omettez ces sections, vous devez vous assurer que le rôle spécifié dans le champ **Rôle IAM par défaut** de votre environnement inclut les autorisations et les politiques de confiance des deux rôles décrits dans. [Étape 5 : Ajouter AWS des rôles à CodeCatalyst](#deploy-tut-ecs-import-roles) Pour plus d'informations sur la configuration d'un environnement doté d'un rôle IAM par défaut, consultez[Création d'un environnement](deploy-environments-creating-environment.md).

   ```
   Name: codecatalyst-ecs-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo
           - Name: IMAGE_TAG
             Value: ${WorkflowSource.CommitId}
       Configuration:
         Steps:
           #pre_build:
           - Run: echo Logging in to Amazon ECR...
           - Run: aws --version
           - Run: aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com
           #build:
           - Run: echo Build started on `date`
           - Run: echo Building the Docker image...
           - Run: docker build -t $REPOSITORY_URI:latest .
           - Run: docker tag $REPOSITORY_URI:latest $REPOSITORY_URI:$IMAGE_TAG
           #post_build:
           - Run: echo Build completed on `date`
           - Run: echo Pushing the Docker images...
           - Run: docker push $REPOSITORY_URI:latest
           - Run: docker push $REPOSITORY_URI:$IMAGE_TAG
           # Replace the variables in taskdef.json
           - Run: find taskdef.json -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find taskdef.json -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat taskdef.json
           # The output artifact will be a zip file that contains a task definition file.
       Outputs:
         Artifacts:
           - Name: TaskDefArtifact
             Files: 
               - taskdef.json
     DeployToECS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/ecs-deploy@v1
       Environment:
         Name: codecatalyst-ecs-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-ecs-deploy-role
       Inputs:
         Sources: []
         Artifacts:
           - TaskDefArtifact
       Configuration:
         region: us-west-2
         cluster: codecatalyst-ecs-cluster
         service: codecatalyst-ecs-service
         task-definition: taskdef.json
   ```

   Dans le code précédent, remplacez :
   + Les deux instances portent *codecatalyst-ecs-environment* le nom de l'environnement dans lequel vous l'avez créé[Conditions préalables](#deploy-tut-ecs-prereqs).
   + Dans les deux cas, *codecatalyst-account-connection* avec le nom d'affichage de la connexion à votre compte. Le nom d'affichage peut être un chiffre. Pour de plus amples informations, veuillez consulter [Étape 5 : Ajouter AWS des rôles à CodeCatalyst](#deploy-tut-ecs-import-roles).
   + *codecatalyst-ecs-build-role*avec le nom du rôle de build que vous avez créé dans[Étape 4 : Création de AWS rôles](#deploy-tut-ecs-build-deploy-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-ecs-image-repo*(dans la `Value:` propriété) avec l'URI du référentiel Amazon ECR dans [Étape 3 : créer un référentiel d'images Amazon ECR](#deploy-tut-ecs-ecr) lequel vous l'avez créé.
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com*(dans la `Run: aws ecr` commande) avec l'URI du référentiel Amazon ECR sans le suffixe d'image ()`/codecatalyst-ecs-image-repo`.
   + *codecatalyst-ecs-deploy-role*avec le nom du rôle de déploiement que vous avez créé dans[Étape 4 : Création de AWS rôles](#deploy-tut-ecs-build-deploy-roles).
   + Dans les deux cas, *us-west-2* avec votre code de AWS région. Pour obtenir la liste des codes de région, consultez la section [Points de terminaison régionaux](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints) dans le *Références générales AWS*.
**Note**  
Si vous avez décidé de ne pas créer de rôles de création et de déploiement, remplacez *codecatalyst-ecs-build-role* et *codecatalyst-ecs-deploy-role* par le nom du `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle. Pour plus d’informations sur ce rôle, consultez [Étape 4 : Création de AWS rôles](#deploy-tut-ecs-build-deploy-roles).
**Astuce**  
Au lieu d'utiliser les `sed` commandes `find` et indiquées dans le code de flux de travail précédent pour mettre à jour le référentiel et le nom de l'image, vous pouvez utiliser l'action de **définition de tâche Render Amazon ECS** à cette fin. Pour de plus amples informations, veuillez consulter [Modification d'une définition de tâche Amazon ECS](render-ecs-action.md).

1. (Facultatif) Choisissez **Valider** pour vous assurer que le code YAML est valide avant de valider.

1. Choisissez **Commit (Valider)**.

1. Dans la boîte de dialogue du **flux de travail de validation**, entrez les informations suivantes :

   1. Pour le **message de validation**, supprimez le texte et entrez :

      ```
      Add first workflow
      ```

   1. Pour **Repository**, choisissez`codecatalyst-ecs-source-repository`.

   1. Pour **Nom de la branche**, choisissez main.

   1. Choisissez **Commit (Valider)**.

   Vous venez de créer un flux de travail. L'exécution d'un flux de travail démarre automatiquement en raison du déclencheur défini en haut du flux de travail. Plus précisément, lorsque vous avez validé (et transféré) le `workflow.yaml` fichier dans votre référentiel source, le déclencheur a lancé l'exécution du flux de travail.

**Pour consulter la progression de l'exécution du flux de travail**

1. **Dans le volet de navigation de la CodeCatalyst console, choisissez **CI/CD**, puis Workflows.**

1. Choisissez le flux de travail que vous venez de créer,`codecatalyst-ecs-workflow`.

1. Choisissez **BuildBackend**de voir la progression de la construction.

1. Choisissez **DeployToECS** pour voir la progression du déploiement.

   Pour plus d'informations sur l'affichage des détails des exécutions, consultez[Afficher le statut et les détails de l'exécution du flux de travail](workflows-view-run.md).

**Pour vérifier le déploiement**

1. Ouvrez la console Amazon ECS Classic à l'adresse [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

1. Choisissez votre cluster,`codecatalyst-ecs-cluster`.

1. Choisissez l'onglet **Tasks.** 

1. Choisissez l'une des trois tâches.

1. Dans le champ **IP publique**, choisissez une **adresse ouverte**.

   Une page « Hello World » apparaît dans le navigateur, indiquant que le service Amazon ECS a correctement déployé votre application.

## Étape 9 : Apportez une modification à vos fichiers source
<a name="deploy-tut-ecs-change"></a>

Dans cette section, vous allez modifier le `index.html` fichier dans votre référentiel source. Cette modification oblige le flux de travail à créer une nouvelle image Docker, à l'étiqueter avec un ID de validation, à la transmettre à Amazon ECR et à la déployer sur Amazon ECS. 

**Pour modifier le fichier index.html**

1. Dans la CodeCatalyst console, dans le volet de navigation, choisissez **Code**, puis **Référentiels sources**, puis choisissez votre référentiel,`codecatalyst-ecs-source-repository`.

1. Choisissez `public-html` et `index.html`.

   Le contenu de `index.html` apparaît.

1. Choisissez **Modifier**. 

1. À la ligne 14, remplacez le `Hello World` texte par`Tutorial complete!`.

1. Choisissez **Commit**, puis sélectionnez **Commit** à nouveau.

   La validation entraîne le démarrage d'un nouveau flux de travail. 

1. (Facultatif) Accédez à la page principale de votre dépôt source, choisissez **Afficher les validations**, puis notez l'ID de validation associé à la `index.html` modification.

1. Suivez la progression du déploiement :

   1. **Dans le volet de navigation, choisissez **CI/CD**, puis Workflows.**

   1. Choisissez `codecatalyst-ecs-workflow` d'afficher la dernière édition.

   1. Choisissez **BuildBackend**, et **DeployToECS** pour voir la progression de l'exécution du flux de travail.

1. Vérifiez que votre application a été mise à jour, comme suit :

   1. Ouvrez la console Amazon ECS Classic à l'adresse [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).

   1. Choisissez votre cluster,`codecatalyst-ecs-cluster`.

   1. Choisissez l'onglet **Tasks.** 

   1. Choisissez l'une des trois tâches.

   1. Dans le champ **IP publique**, choisissez une **adresse ouverte**.

      Une `Tutorial complete!` page apparaît.

1. (Facultatif) Dans AWS, passez à la console Amazon ECR et vérifiez que la nouvelle image Docker a été étiquetée avec l'ID de validation indiqué à l'étape 6.

## Nettoyage
<a name="deploy-tut-ecs-cleanup"></a>

Nettoyez les fichiers et les services utilisés dans ce didacticiel pour éviter de vous les faire facturer.

Dans le AWS Management Console, nettoyez dans cet ordre :

1. Dans Amazon ECS, procédez comme suit :

   1. Supprimer`codecatalyst-ecs-service`.

   1. Supprimer`codecatalyst-ecs-cluster`.

   1. Désenregistrer`codecatalyst-ecs-task-definition`.

1. Dans Amazon ECR, supprimez`codecatalyst-ecs-image-repo`.

1. Dans Amazon EC2, supprimez. `codecatalyst-ecs-security-group`

1. Dans IAM Identity Center, supprimez :

   1. `CodeCatalystECSUser`

   1. `CodeCatalystECSPermissionSet`

Dans la CodeCatalyst console, nettoyez comme suit :

1. Supprimer`codecatalyst-ecs-workflow`.

1. Supprimer`codecatalyst-ecs-environment`.

1. Supprimer`codecatalyst-ecs-source-repository`.

1. Supprimer`codecatalyst-ecs-project`.

Dans ce didacticiel, vous avez appris à déployer une application sur un service Amazon ECS à l'aide d'un CodeCatalyst flux de travail et d'une action **Deploy to Amazon ECS**.