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éploiement d'une application sur Amazon EKS
<a name="deploy-tut-eks"></a>

Dans ce didacticiel, vous apprendrez à déployer une application conteneurisée dans Amazon Elastic Kubernetes Service à l'aide d'un flux de travail Amazon, CodeCatalyst d'Amazon EKS et de quelques autres services. AWS L'application déployée est une simple application « Hello, World \$1 » site Web construit sur une image Docker d'un serveur Web Apache. Le didacticiel explique les tâches de préparation requises, telles que la configuration d'une machine de développement et d'un cluster Amazon EKS, puis décrit comment créer un flux de travail pour créer l'application et la déployer dans le cluster.

Une fois le déploiement initial terminé, le didacticiel vous demande de modifier la source de votre application. Cette modification entraîne la création d'une nouvelle image Docker et son transfert vers votre référentiel d'images Docker avec de nouvelles informations de révision. La nouvelle version de l'image Docker est ensuite déployée dans Amazon EKS.

**Astuce**  
Au lieu de suivre ce didacticiel, vous pouvez utiliser un plan qui effectue une configuration complète d'Amazon EKS pour vous. Vous devez utiliser le plan de **déploiement de l'application EKS**. 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-eks-prereqs)
+ [

## Étape 1 : Configuration de votre machine de développement
](#deploy-tut-eks-dev-env-create)
+ [

## Étape 2 : créer un cluster Amazon EKS
](#deploy-tut-eks-cluster)
+ [

## Étape 3 : Création d'un référentiel d'images Amazon ECR
](#deploy-tut-eks-ecr)
+ [

## Étape 4 : Ajouter des fichiers source
](#deploy-tut-eks-source-files)
+ [

## Étape 5 : Création de AWS rôles
](#deploy-tut-eks-roles)
+ [

## Étape 6 : Ajouter AWS des rôles à CodeCatalyst
](#deploy-tut-eks-import-roles)
+ [

## Étape 7 : mettez à jour le ConfigMap
](#deploy-tut-eks-configmap)
+ [

## Étape 8 : créer et exécuter un flux de travail
](#deploy-tut-eks-workflow)
+ [

## Étape 9 : Apportez une modification à vos fichiers source
](#deploy-tut-eks-change)
+ [

## Nettoyage
](#deploy-tut-eks-cleanup)

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

Avant de commencer ce didacticiel :
+ Vous avez besoin d'un CodeCatalyst **espace** Amazon 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-eks-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 **dépôt CodeCatalyst source** vide appelé :

  ```
  codecatalyst-eks-source-repository
  ```

  Pour de plus amples informations, veuillez consulter [Stockez du code et collaborez sur celui-ci avec des référentiels de sources dans CodeCatalystStockez du code et collaborez sur celui-ci avec des référentiels de sources](source.md).
+ Dans votre projet, vous avez besoin d'un environnement CodeCatalyst CI/CD (et non d'un **environnement** de développement) appelé :

  ```
  codecatalyst-eks-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 : Configuration de votre machine de développement
<a name="deploy-tut-eks-dev-env-create"></a>

La première étape de ce didacticiel consiste à configurer une machine de développement avec quelques outils que vous utiliserez tout au long de ce didacticiel. Ces outils sont les suivants :
+ l'`eksctl`utilitaire — pour la création de clusters
+ l'`kubectl`utilité — une condition préalable à `eksctl`
+ le AWS CLI — également une condition préalable pour `eksctl`

Vous pouvez installer ces outils sur votre machine de développement existante si vous en avez une, ou vous pouvez utiliser un CodeCatalyst environnement de développement basé sur le cloud. L'avantage d'un environnement CodeCatalyst de développement est qu'il est facile à installer et à démonter, et qu'il est intégré à d'autres CodeCatalyst services, ce qui vous permet de suivre ce didacticiel en moins d'étapes.

Ce didacticiel part du principe que vous utiliserez un CodeCatalyst environnement de développement.

Les instructions suivantes décrivent un moyen rapide de lancer un environnement de CodeCatalyst développement et de le configurer avec les outils requis, mais si vous souhaitez obtenir des instructions détaillées, consultez :
+ [Création d’un environnement de développement](devenvironment-create.md) dans ce guide.
+ [Installation de kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) dans le guide de l'**utilisateur Amazon EKS**.
+ [Installation ou mise à niveau d'eksctl](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) dans le guide de **l'utilisateur Amazon EKS**.
+ [Installation ou mise à jour de la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) dans le *guide de AWS Command Line Interface l'utilisateur*.

**Pour lancer un environnement de développement**

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

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

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

1. Choisissez le nom de votre dépôt source,`codecatalyst-eks-source-repository`.

1. En haut, choisissez **Create Dev Environment**, puis choisissez **AWS Cloud9 (dans le navigateur)**.

1. Assurez-vous que les options **Travailler dans la branche et la branche **principale** existantes** sont sélectionnées, puis choisissez **Créer**.

   Votre environnement de développement s'ouvre dans un nouvel onglet du navigateur, et votre dépôt (`codecatalyst-eks-source-repository`) y est cloné.

**Pour installer et configurer kubectl**

1. Dans le terminal Dev Environment, entrez :

   ```
   curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.18.9/2020-11-02/bin/linux/amd64/kubectl
   ```

1. Entrez :

   ```
   chmod +x ./kubectl
   ```

1. Entrez :

   ```
   mkdir -p $HOME/bin && cp ./kubectl $HOME/bin/kubectl && export PATH=$PATH:$HOME/bin
   ```

1. Entrez :

   ```
   echo 'export PATH=$PATH:$HOME/bin' >> ~/.bashrc
   ```

1. Entrez :

   ```
   kubectl version --short --client
   ```

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

   Vous êtes maintenant installé`kubectl`.

**Pour installer et configurer eksctl**
**Note**  
`eksctl`n'est pas strictement obligatoire car vous pouvez utiliser à la `kubectl` place. Cependant, il `eksctl` présente l'avantage d'automatiser une grande partie de la configuration du cluster, et c'est donc l'outil recommandé pour ce didacticiel.

1. Dans le terminal Dev Environment, entrez :

   ```
   curl --silent --location "https://github.com/weaveworks/eksctl/releases/latest/download/eksctl_$(uname -s)_amd64.tar.gz" | tar xz -C /tmp
   ```

1. Entrez :

   ```
   sudo cp /tmp/eksctl /usr/bin
   ```

1. Entrez :

   ```
   eksctl version
   ```

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

   Vous êtes maintenant installé`eksctl`.

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

1. Dans le terminal Dev Environment, entrez :

   ```
   aws --version
   ```

1. Vérifiez qu'une version apparaît pour vérifier qu'elle AWS CLI est installée.

   Effectuez les procédures restantes pour configurer le AWS CLI avec les autorisations d'accès nécessaires AWS.

**Pour configurer le AWS CLI**

Vous devez le configurer AWS CLI avec des clés d'accès et un jeton de session pour lui donner accès aux AWS services. Les instructions suivantes fournissent un moyen rapide de configurer les clés et le jeton, mais si vous souhaitez obtenir des instructions détaillées, reportez-vous AWS CLIà [la section Configuration du](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *guide de l'AWS Command Line Interface utilisateur*.

1. Créez un utilisateur IAM Identity Center, comme suit :

   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/).

      (Vous devrez peut-être choisir **Activer** si vous ne vous êtes jamais connecté à IAM Identity Center auparavant.)
**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 :

      ```
      codecatalyst-eks-user
      ```

   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 le **champ Prénom**, entrez :

      ```
      codecatalyst-eks-user
      ```

   1. Dans **Nom de famille**, entrez :

      ```
      codecatalyst-eks-user
      ```

   1. Dans **Nom d'affichage**, conservez :

      ```
      codecatalyst-eks-user codecatalyst-eks-user
      ```

   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 dans un fichier texte. Les informations de connexion comprennent l'URL du portail d' AWS accès, un nom d'utilisateur et un mot de passe à usage unique.

   1. Choisissez **Fermer**.

1. Créez un ensemble d'autorisations, comme suit :

   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**, supprimez `AdministratorAccess` et entrez :

      ```
      codecatalyst-eks-permission-set
      ```

   1. Choisissez **Suivant**.

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

1. Attribuez l'ensemble d'autorisations à`codecatalyst-eks-user`, comme suit :

   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`codecatalyst-eks-user`.

   1. Choisissez **Suivant**.

   1. Cochez la case située à côté de`codecatalyst-eks-permission-set`.

   1. Choisissez **Suivant**.

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

      Vous les avez maintenant assignés `codecatalyst-eks-user` et `codecatalyst-eks-permission-set` à votre Compte AWS, en les liant ensemble.

1. Les clés `codecatalyst-eks-user` d'accès et le jeton de session d'Obtain, comme suit :

   1. Assurez-vous de disposer de l'URL du portail AWS d'accès, du nom d'utilisateur et du mot de passe à usage unique pour`codecatalyst-eks-user`. 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 `codecatalyst-eks-user` 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 :
      + **Nom d'utilisateur** :

        ```
        codecatalyst-eks-user
        ```
      + **Mot de passe** :

        *one-time-password*

   1. Dans **Définir un nouveau mot de passe**, entrez un nouveau mot de passe et 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'`codecatalyst-eks-user`utilisateur et le jeu d'autorisations.

   1. À côté de`codecatalyst-eks-permission-set`, choisissez **Ligne de commande ou accès par programmation**.

   1. Copiez les commandes au milieu de la page. Ils ressemblent à ce qui suit :

      ```
      export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE" 
      export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" 
      export AWS_SESSION_TOKEN="session-token"
      ```

      ... où se *session-token* trouve une longue chaîne aléatoire.

1. Ajoutez les clés d'accès et le jeton de session au AWS CLI, comme suit :

   1. Retournez à votre CodeCatalyst environnement de développement.

   1. À l'invite du terminal, collez les commandes que vous avez copiées. Appuyez sur Entrée.

      Vous avez maintenant configuré le AWS CLI avec des clés d'accès et un jeton de session. Vous pouvez désormais utiliser AWS CLI pour effectuer les tâches requises par ce didacticiel.
**Important**  
Si, à tout moment au cours de ce didacticiel, vous voyez des messages similaires aux suivants :  
`Unable to locate credentials. You can configure credentials by running "aws configure".`  
Ou:  
`ExpiredToken: The security token included in the request is expired`  
... c'est parce que votre AWS CLI session a expiré. Dans ce cas, n'exécutez *pas* la `aws configure` commande. Utilisez plutôt les instructions de l'étape 4 de cette procédure qui commence par `Obtain codecatalyst-eks-user's access key and session token` pour actualiser votre session.

## Étape 2 : créer un cluster Amazon EKS
<a name="deploy-tut-eks-cluster"></a>

Dans cette section, vous allez créer un cluster dans Amazon EKS. Les instructions ci-dessous décrivent un moyen rapide de créer le cluster à l'aide de`eksctl`, mais si vous souhaitez obtenir des instructions détaillées, consultez :
+ [Commencer à utiliser eksctl dans le guide](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) de l'utilisateur **Amazon EKS**

  or
+ [Démarrage avec la console et AWS CLI](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) dans le **guide de l'utilisateur Amazon EKS** (cette rubrique fournit des `kubectl` instructions pour créer le cluster) 

**Note**  
Les [clusters privés](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) ne sont pas pris en charge par l' CodeCatalyst intégration avec Amazon EKS.

**Avant de commencer**

Assurez-vous d'avoir effectué les tâches suivantes sur votre machine de développement :
+ L'`eksctl`utilitaire a été installé.
+ L'`kubectl`utilitaire a été installé.
+ Vous l'avez installé AWS CLI et configuré avec des clés d'accès et un jeton de session.

Pour plus d'informations sur la façon d'effectuer ces tâches, consultez[Étape 1 : Configuration de votre machine de développement](#deploy-tut-eks-dev-env-create).

**Pour créer un cluster**
**Important**  
N'utilisez pas l'interface utilisateur du service Amazon EKS pour créer le cluster car celui-ci ne sera pas configuré correctement. Utilisez l'`eksctl`utilitaire, comme décrit dans les étapes suivantes.

1. Accédez à votre environnement de développement.

1. Créez un cluster et des nœuds :

   ```
   eksctl create cluster --name codecatalyst-eks-cluster --region us-west-2
   ```

   Où :
   + *codecatalyst-eks-cluster*est remplacé par le nom que vous souhaitez donner à votre cluster.
   + *us-west-2*est remplacé par votre région.

   Après 10 à 20 minutes, un message semblable au suivant apparaît : 

   `EKS cluster "codecatalyst-eks-cluster" in "us-west-2" region is ready`
**Note**  
Vous verrez plusieurs `waiting for CloudFormation stack` messages lors de la AWS création de votre cluster. Ceci est normal.

1. Vérifiez que votre cluster a été créé avec succès :

   ```
   kubectl cluster-info
   ```

   Vous verrez un message similaire au suivant, indiquant une création de cluster réussie :

   ```
   Kubernetes master is running at https://long-string.gr7.us-west-2.eks.amazonaws.com
   CoreDNS is running at https://long-string.gr7.us-west-2.eks.amazonaws.com/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
   ```

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

Dans cette section, vous allez créer un référentiel d'images privé dans Amazon Elastic Container Registry (Amazon ECR). Ce référentiel stocke l'image Docker pour le didacticiel.

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. Accédez à votre environnement de développement.

1. Créez un référentiel vide dans Amazon ECR :

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

   *codecatalyst-eks-image-repo*Remplacez-le par le nom que vous souhaitez attribuer au référentiel Amazon ECR.

   Ce didacticiel part du principe que vous avez donné un nom à votre dépôt`codecatalyst-eks-image-repo`.

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

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

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

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

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

Dans cette section, vous allez ajouter les fichiers source de l'application à votre référentiel source (`codecatalyst-eks-source-repository`). Ils sont composés de :
+ Un `index.html` fichier — Affiche un message « Bonjour tout le monde \$1 » message dans le navigateur.
+ Un Dockerfile — Décrit l'image de base à utiliser pour votre image Docker et les commandes Docker à appliquer à celle-ci.
+ Un `deployment.yaml` fichier : le manifeste Kubernetes qui définit le service et le déploiement de Kubernetes. 

La structure des dossiers est la suivante :

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

**Topics**
+ [

### index.html
](#deploy-tut-eks-source-files-index)
+ [

### Dockerfile
](#deploy-tut-eks-source-files-dockerfile)
+ [

### deployment.yaml
](#deploy-tut-eks-source-files-deployment-yml)

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

Le `index.html` fichier affiche un message « Bonjour tout le monde \$1 » message dans le navigateur. 

**Pour ajouter le fichier index.html**

1. Accédez à votre environnement de développement.

1. Dans`codecatalyst-eks-source-repository`, créez un dossier appelé`public-html`.

1. Dans`/public-html`, créez un fichier appelé `index.html` avec le contenu 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. À l'invite du terminal, entrez :

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1. Ajoutez, validez et envoyez :

   ```
   git add .
   git commit -m "add public-html/index.html"
   git push
   ```

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

### Dockerfile
<a name="deploy-tut-eks-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`codecatalyst-eks-source-repository`, créez un fichier appelé `Dockerfile` avec le contenu suivant :

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

   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. Ajoutez, validez et envoyez :

   ```
   git add .
   git commit -m "add Dockerfile"
   git push
   ```

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

### deployment.yaml
<a name="deploy-tut-eks-source-files-deployment-yml"></a>

Dans cette section, vous allez ajouter un `deployment.yaml` fichier à votre dépôt. Le `deployment.yaml` fichier est un manifeste Kubernetes qui définit deux types ou *types* de ressources Kubernetes à exécuter : un « service » et un « déploiement ».
+ Le « service » déploie un équilibreur de charge dans Amazon EC2. L'équilibreur de charge vous fournit une URL publique connectée à Internet et un port standard (port 80) que vous pouvez utiliser pour accéder à « Hello, World \$1 » application. 
+ Le « déploiement » déploie trois pods, et chaque pod contiendra un conteneur Docker avec le message « Hello, World \$1 » application. Les trois pods sont déployés sur les nœuds créés lorsque vous avez créé le cluster.

Le manifeste présenté dans ce didacticiel est court ; toutefois, un manifeste peut inclure un certain nombre de types de ressources Kubernetes, tels que des pods, des jobs, des entrées et des politiques réseau. En outre, vous pouvez utiliser plusieurs fichiers manifestes si votre déploiement est complexe.

**Pour ajouter un fichier de déploiement .yaml**

1. Dans`codecatalyst-eks-source-repository`, créez un dossier appelé`Kubernetes`.

1. Dans`/Kubernetes`, créez un fichier appelé `deployment.yaml` avec le contenu suivant :

   ```
   apiVersion: v1
   kind: Service
   metadata:
     name: my-service
     labels:
       app: my-app
   spec:
     type: LoadBalancer
     selector:
       app: my-app
     ports:
       - protocol: TCP
         port: 80
         targetPort: 80
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-deployment
     labels:
       app: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: codecatalyst-eks-container
           # The $REPOSITORY_URI and $IMAGE_TAG placeholders will be replaced by actual values supplied by the build action in your workflow
           image: $REPOSITORY_URI:$IMAGE_TAG
           ports:
           - containerPort: 80
   ```

1. Ajoutez, validez et envoyez :

   ```
   git add .
   git commit -m "add Kubernetes/deployment.yaml"
   git push
   ```

   Le `deployment.yaml` fichier est ajouté à votre dépôt dans un dossier appelé`Kubernetes`. 

Vous avez maintenant ajouté tous vos fichiers sources.

Prenez le temps de vérifier votre travail et de vous assurer que vous avez placé tous les fichiers dans les bons dossiers. La structure des dossiers est la suivante :

```
|— codecatalyst-eks-source-repository
   |— Kubernetes
      |— deployment.yaml
   |— public-html
   |  |— index.html
   |— Dockerfile
```

## Étape 5 : Création de AWS rôles
<a name="deploy-tut-eks-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 Kubernetes cluster** (dans le flux de travail) l'autorisation d'accéder à votre compte AWS et à Amazon EKS.

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, suivez la série de procédures suivante.

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

1. Accédez à votre environnement de développement.

1. Dans le `Cloud9-long-string` répertoire, créez un fichier appelé `codecatalyst-eks-trust-policy.json` avec le contenu suivant :

**2. Pour créer la politique de build pour le rôle de build**
+ Dans le `Cloud9-long-string` répertoire, créez un fichier appelé `codecatalyst-eks-build-policy.json` avec le contenu 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": "*"
  ```

**3. Pour créer la politique de déploiement pour le rôle de déploiement**
+ Dans le `Cloud9-long-string` répertoire, créez un fichier appelé `codecatalyst-eks-deploy-policy.json` avec le contenu suivant :

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

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "eks:DescribeCluster",
                  "eks:ListClusters"
              ],
              "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": "*"
  ```

Vous avez maintenant ajouté trois documents de politique à votre environnement de développement. La structure de votre répertoire ressemble maintenant à ceci :

```
|— Cloud9-long-string
   |— .c9
   |— codecatalyst-eks-source-repository
      |— Kubernetes
      |— public-html
      |— Dockerfile
   codecatalyst-eks-build-policy.json
   codecatalyst-eks-deploy-policy.json
   codecatalyst-eks-trust-policy.json
```

**4. Pour ajouter la politique de construction à AWS**

1. Dans le terminal Dev Environment, entrez :

   ```
   cd /projects
   ```

1. Entrez :

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

1. Appuyez sur **Entrée**.

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

**5. Pour ajouter la politique de déploiement à AWS**

1. Entrez :

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

1. Appuyez sur **Entrée**.

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-eks-deploy-policy`. Vous aurez besoin de cet ARN ultérieurement.

**6. Pour créer le rôle de build**

1. Entrez : 

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

1. Appuyez sur **Entrée**.

1. Entrez :

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

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

1. Appuyez sur **Entrée**.

1. À l'invite du terminal, entrez :

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

1. Appuyez sur **Entrée**.

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

**7. Pour créer le rôle de déploiement**

1. Entrez :

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

1. Appuyez sur **Entrée**.

1. Entrez :

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

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

1. Appuyez sur **Entrée**.

1. Entrez :

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

1. Appuyez sur **Entrée**.

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

Vous avez maintenant créé des rôles de construction et de déploiement et les avez notés ARNs.

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

Au cours de cette étape, vous ajoutez le rôle de construction (`codecatalyst-eks-build-role`) et le rôle de déploiement (`codecatalyst-eks-deploy-role`) au rôle Compte AWS que vous avez connecté à votre espace. Les rôles peuvent ainsi être utilisés dans votre flux de travail.

**Pour ajouter des rôles de création et de déploiement à votre Compte AWS**

1. Dans la CodeCatalyst console, accédez à votre espace.

1. En haut, choisissez **Réglages**.

1. Dans le volet de navigation, sélectionnez **AWS Accounts**. La liste des comptes s'affiche.

1. Dans la colonne du **nom CodeCatalyst d'affichage d'Amazon**, copiez le nom d'affichage de l' Compte AWS endroit où vous avez créé vos rôles de création et de déploiement. (Il peut s'agir d'un chiffre.) Vous aurez besoin de cette valeur ultérieurement, lors de la création de votre flux de travail.

1. Choisissez le nom d'affichage.

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. Il se peut que vous deviez 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 les rôles de création et de déploiement, ainsi que tous les autres rôles IAM dotés d'une politique de confiance incluant les principes `codecatalyst-runner.amazonaws.com` et les principaux `codecatalyst.amazonaws.com` de service.

1. Dans la liste déroulante, ajoutez :
   + `codecatalyst-eks-build-role`
   + `codecatalyst-eks-deploy-role`
**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. Retournez à la CodeCatalyst console et actualisez la page.

   Les rôles de création et de déploiement devraient désormais apparaître sous les **rôles IAM**.

   Ces rôles peuvent désormais être utilisés dans les CodeCatalyst flux de travail.

## Étape 7 : mettez à jour le ConfigMap
<a name="deploy-tut-eks-configmap"></a>

Vous devez ajouter le rôle de déploiement que vous avez créé dans le `ConfigMap` fichier Kubernetes [Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles) pour permettre à l'action **Deploy to Kubernetes cluster** (dans votre flux de travail) d'accéder à votre cluster et d'interagir avec celui-ci. Vous pouvez utiliser `eksctl` ou `kubectl` pour exécuter cette tâche.

**Pour configurer le fichier Kubernetes ConfigMap à l'aide de eksctl**
+ Dans le terminal Dev Environment, entrez : 

  ```
  eksctl create iamidentitymapping --cluster codecatalyst-eks-cluster --arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role --group system:masters --username codecatalyst-eks-deploy-role --region us-west-2
  ```

  Où :
  + *codecatalyst-eks-cluster*est remplacé par le nom du cluster Amazon EKS.
  +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*est remplacé par l'ARN du rôle de déploiement que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).
  +  *codecatalyst-eks-deploy-role*(à côté de`--username`) est remplacé par le nom du rôle de déploiement que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).
**Note**  
Si vous avez décidé de ne pas créer de rôle de déploiement, *codecatalyst-eks-deploy-role* remplacez-le par le nom du `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle. Pour plus d’informations sur ce rôle, consultez [Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).
  +  *us-west-2*est remplacé par votre région.

  Pour plus de détails sur cette commande, voir [Gérer les utilisateurs et les rôles IAM](https://eksctl.io/usage/iam-identity-mappings/).

  Un message similaire au suivant s'affiche :

  ```
  2023-06-09 00:58:29 [ℹ]  checking arn arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role against entries in the auth ConfigMap
  2023-06-09 00:58:29 [ℹ]  adding identity "arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role" to auth ConfigMap
  ```

**Pour configurer le fichier Kubernetes ConfigMap à l'aide de kubectl**

1. Dans le terminal Dev Environment, entrez :

   ```
   kubectl edit configmap -n kube-system aws-auth
   ```

   Le ConfigMap fichier apparaît à l'écran.

1. Ajoutez le texte en italique rouge :

   ```
   # Please edit the object below. Lines beginning with a '#' will be ignored,
   # and an empty file will abort the edit. If an error occurs while saving this file will be
   # reopened with the relevant failures.
   #
   apiVersion: v1
   data:
     mapRoles: |
       - groups:
         - system:bootstrappers
         - system:nodes
         rolearn: arn:aws:iam::111122223333:role/eksctl-codecatalyst-eks-cluster-n-NodeInstanceRole-16BC456ME6YR5
         username: system:node:{{EC2PrivateDNSName}}
       - groups:
         - system:masters
         rolearn: arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role
         username: codecatalyst-eks-deploy-role
     mapUsers: |
       []
   kind: ConfigMap
   metadata:
     creationTimestamp: "2023-06-08T19:04:39Z"
     managedFields:
     ...
   ```

   Où :
   +  *arn:aws:iam::111122223333:role/codecatalyst-eks-deploy-role*est remplacé par l'ARN du rôle de déploiement que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles). 
   +  *codecatalyst-eks-deploy-role*(à côté de`username:`) est remplacé par le nom du rôle de déploiement que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).
**Note**  
Si vous avez décidé de ne pas créer de rôle de déploiement, *codecatalyst-eks-deploy-role* remplacez-le par le nom du `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle. Pour plus d’informations sur ce rôle, consultez [Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).

   Pour plus de détails, consultez la section [Activation de l'accès principal IAM à votre cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) dans le **guide de l'utilisateur Amazon EKS**.

Vous avez maintenant accordé au rôle de déploiement, et par extension à l'action **Deploy to Amazon EKS**, `system:masters` des autorisations sur votre cluster Kubernetes.

## Étape 8 : créer et exécuter un flux de travail
<a name="deploy-tut-eks-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 dans des capsules d'arbres de votre cluster Amazon EKS.

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 les `$IMAGE_TAG` variables `$REPOSITORY_URI` et du `deployment.yaml` fichier avec les valeurs correctes, puis crée un artefact de sortie de ce fichier et de tous les autres éléments du `Kubernetes` dossier. Dans ce didacticiel, le seul fichier du `Kubernetes` dossier l'est`deployment.yaml`, mais vous pouvez inclure d'autres fichiers. L'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 (`DeployToEKS`) : une fois l'action de génération terminée, l'action de déploiement recherche l'artefact de sortie généré par l'action de génération (`Manifests`) et trouve le `deployment.yaml` fichier qu'il contient. L'action suit ensuite les instructions du `deployment.yaml` fichier pour exécuter trois pods, chacun contenant un seul « Hello, World \$1 » Conteneur Docker : à l'intérieur de votre cluster Amazon EKS. 

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

1. Accédez à la CodeCatalyst console.

1. Accédez à votre projet (`codecatalyst-eks-project`).

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

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

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

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

1. Choisissez **Créer**.

1. Supprimez l'exemple de code YAML.

1. Ajoutez le code YAML suivant pour créer un nouveau fichier de définition de flux de travail :
**Note**  
Pour plus d'informations sur le fichier de définition du flux de travail, consultez[Définition du flux de travail YAML](workflow-reference.md).
**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 6 : Ajouter AWS des rôles à CodeCatalyst](#deploy-tut-eks-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-eks-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: PUSH
       Branches:
         - main
   Actions:
     BuildBackend:
       Identifier: aws/build@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-build-role
       Inputs:
         Sources:
           - WorkflowSource
         Variables:
           - Name: REPOSITORY_URI
             Value: 111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-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 deployment.yaml
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$REPOSITORY_URI|$REPOSITORY_URI|g"
           - Run: find Kubernetes/ -type f | xargs sed -i "s|\$IMAGE_TAG|$IMAGE_TAG|g"
           - Run: cat Kubernetes/*
           # The output artifact will be a zip file that contains Kubernetes manifest files.
       Outputs:
         Artifacts:
           - Name: Manifests
             Files: 
               - "Kubernetes/*"
     DeployToEKS:
       DependsOn: 
         - BuildBackend
       Identifier: aws/kubernetes-deploy@v1
       Environment:
         Name: codecatalyst-eks-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-eks-deploy-role
       Inputs:
         Artifacts:
           - Manifests
       Configuration:
         Namespace: default
         Region: us-west-2
         Cluster: codecatalyst-eks-cluster
         Manifests: Kubernetes/
   ```

   Dans le code précédent, remplacez :
   + Les deux instances portent *codecatalyst-eks-environment* le nom de l'environnement dans lequel vous l'avez créé[Conditions préalables](#deploy-tut-eks-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 6 : Ajouter AWS des rôles à CodeCatalyst](#deploy-tut-eks-import-roles).
   + *codecatalyst-eks-build-role*avec le nom du rôle de build que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).
   + *111122223333.dkr.ecr.us-west-2.amazonaws.com/codecatalyst-eks-image-repo*(dans la `Value:` propriété) avec l'URI du référentiel Amazon ECR dans [Étape 3 : Création d'un référentiel d'images Amazon ECR](#deploy-tut-eks-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-eks-image-repo`.
   + *codecatalyst-eks-deploy-role*avec le nom du rôle de déploiement que vous avez créé dans[Étape 5 : Création de AWS rôles](#deploy-tut-eks-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) 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-eks-build-role* et *codecatalyst-eks-deploy-role* par le nom du `CodeCatalystWorkflowDevelopmentRole-spaceName` rôle. Pour plus d’informations sur ce rôle, consultez [Étape 5 : Création de AWS rôles](#deploy-tut-eks-roles).

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

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

1. Choisissez **DeployToEKS** 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 EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Sur la gauche, vers le bas, choisissez **Load Balancers**.

1. Sélectionnez l'équilibreur de charge créé dans le cadre de votre déploiement Kubernetes. Si vous ne savez pas quel équilibreur de charge choisir, recherchez les balises suivantes sous l'onglet **Tags :**
   + `kubernetes.io/service-name`
   + `kubernetes.io/cluster/ekstutorialcluster`

1. Une fois le bon équilibreur de charge sélectionné, cliquez sur l'onglet **Description**.

1. Copiez et collez la valeur **du nom DNS** dans la barre d'adresse de votre navigateur.

   Le « Hello, World \$1 » Une page Web apparaît dans votre navigateur, indiquant que vous avez correctement déployé votre application.

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

Dans cette section, vous allez apporter une modification au `index.html` fichier dans votre dépôt 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. Accédez à votre environnement de développement.

1. À l'invite du terminal, accédez à votre référentiel source :

   ```
   cd /projects/codecatalyst-eks-source-repository
   ```

1.  Importez les dernières modifications apportées au flux de travail :

   ```
   git pull
   ```

1. Ouvrir `codecatalyst-eks-source-repository/public-html/index.html`.

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

1. Ajoutez, validez et envoyez :

   ```
   git add .
   git commit -m "update index.html title"
   git push
   ```

   L'exécution d'un flux de travail démarre automatiquement.

1. (Facultatif) Entrez :

   ```
   git show HEAD
   ```

   Notez l'ID de validation associé à la `index.html` modification. Cet ID de validation sera associé à l'image Docker qui sera déployée par le flux de travail que vous venez de démarrer.

1. Suivez la progression du déploiement :

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

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

   1. Choisissez **BuildBackend**, et **DeployToEKS** 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 EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

   1. Sur la gauche, vers le bas, choisissez **Load Balancers**.

   1. Sélectionnez l'équilibreur de charge créé dans le cadre de votre déploiement Kubernetes.

   1. Copiez et collez la valeur **du nom DNS** dans la barre d'adresse de votre navigateur.

      Le « Tutoriel terminé \$1 » Une page Web apparaît dans votre navigateur, indiquant que vous avez déployé avec succès une nouvelle version de votre application.

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 7 de cette procédure.

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

Vous devez nettoyer votre environnement afin de ne pas être facturé inutilement pour les ressources de stockage et de calcul utilisées dans ce didacticiel.

**Pour nettoyer**

1. Supprimez votre cluster :

   1. Dans le terminal Dev Environment, entrez :

     ```
     eksctl delete cluster --region=us-west-2 --name=codecatalyst-eks-cluster
     ```

     Où :
     + *us-west-2*est remplacé par votre région.
     + *codecatalyst-eks-cluster*est remplacé par le nom du cluster que vous avez créé.

     Après 5 à 10 minutes, le cluster et les ressources associées sont supprimés, notamment les CloudFormation piles, les groupes de nœuds (dans Amazon EC2) et les équilibreurs de charge.
**Important**  
Si la `eksctl delete cluster` commande ne fonctionne pas, vous devrez peut-être actualiser vos AWS informations d'identification ou vos `kubectl` informations d'identification. Si vous n'êtes pas sûr des informations d'identification à actualiser, AWS actualisez-les d'abord. Pour actualiser vos AWS informations d'identification, consultez[Comment corriger les erreurs « Impossible de localiser les informations d'identification » et ExpiredToken « » ?](troubleshooting-workflows.md#troubleshooting-workflows-auth-errors-eks). Pour actualiser vos `kubectl` informations d'identification, consultez[Comment corriger les erreurs « Impossible de se connecter au serveur » ?](troubleshooting-workflows.md#troubleshooting-workflows-unable-connect-eks).

1. Dans la AWS console, nettoyez comme suit :

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

   1. Dans IAM Identity Center, supprimez :

      1. `codecatalyst-eks-user`

      1. `codecatalyst-eks-permission-set`

   1. Dans IAM, supprimez :
      + `codecatalyst-eks-build-role`
      + `codecatalyst-eks-deploy-role`
      + `codecatalyst-eks-build-policy`
      + `codecatalyst-eks-deploy-policy`

1. Dans la CodeCatalyst console, nettoyez comme suit :

   1. Supprimer`codecatalyst-eks-workflow`.

   1. Supprimer`codecatalyst-eks-environment`.

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

   1. Supprimez votre environnement de développement.

   1. Supprimer`codecatalyst-eks-project`.

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