Prérequis Étape 1 : Installer les composants d'intégration Étape 2 : Déployer les ressources App Mesh Étape 3 : Créer ou mettre à jour des services Étape 4 : Nettoyer

Premiers pas avec AWS App Mesh Kubernetes

Lorsque vous intégrez AWS App Mesh Kubernetes à l'aide du contrôleur App Mesh pour Kubernetes, vous gérez les ressources App Mesh, telles que les maillages, les services virtuels, les nœuds virtuels, les routeurs virtuels et les itinéraires via Kubernetes. Vous ajoutez également automatiquement les images du conteneur App Mesh aux spécifications du pod Kubernetes. Ce didacticiel vous guide tout au long de l'installation du contrôleur App Mesh pour Kubernetes afin de permettre cette intégration.

Le contrôleur est accompagné par le déploiement des définitions de ressources personnalisées Kubernetes suivantes : meshes, virtual services, virtual nodes et virtual routers. Le contrôleur surveille la création, la modification et la suppression des ressources personnalisées et apporte des modifications aux ressources App MeshMailles de service,Services virtuels,Nœuds virtuels, Passerelle itinéraires de passerelle, Routeurs virtuels (y comprisAcheminements) correspondantes via l'API App Mesh. Pour en savoir plus ou contribuer au contrôleur, consultez le GitHubprojet.

Le contrôleur installe également un webhook qui injecte les conteneurs suivants dans les pods Kubernetes étiquetés avec un nom que vous spécifiez.

Proxy App Mesh Envoy — Envoy utilise la configuration définie dans le plan de contrôle App Mesh pour déterminer où envoyer le trafic de votre application.
Gestionnaire de routes proxy App Mesh : met à jour iptables les règles de l'espace de noms réseau d'un pod qui acheminent le trafic entrant et sortant via Envoy. Ce conteneur fonctionne comme un conteneur init Kubernetes à l'intérieur du pod.

Prérequis

Compréhension existante des concepts de l'App Mesh. Pour plus d’informations, consultez Qu'est-ce qu'AWS App Mesh ?.
Connaissances des concepts Kubernetes. Pour plus d'informations, consultez Qu'est-ce que Kubernetes dans la documentation Kubernetes.
Un cluster Kubernetes existant. Si vous n'avez pas de cluster existant, consultez Getting Started with Amazon EKS dans le guide de l'utilisateur Amazon EKS. Si vous utilisez votre propre cluster Kubernetes sur Amazon EC2, assurez-vous que Docker est authentifié auprès du référentiel Amazon ECR dans lequel se trouve l'image Envoy. Pour plus d'informations, consultez l'image d'Envoy, l'authentification du registre dans le guide de l'utilisateur d'Amazon Elastic Container Registry et l'extraction d'une image d'un registre privé dans la documentation de Kubernetes.
App Mesh prend en charge les services Linux enregistrés auprès du DNS AWS Cloud Map, ou des deux. Pour utiliser ce guide de démarrage, nous vous recommandons d'avoir trois services existants enregistrés avec DNS. Les procédures décrites dans cette rubrique supposent que les services existants sont nommés serviceA serviceBv2 et que tous les services sont détectables via un espace de noms nommé. serviceB apps.local

Vous pouvez créer un maillage de service et ses ressources même si les services n'existent pas, mais vous ne pouvez pas utiliser le maillage tant que vous n'avez pas déployé des services réels.
La AWS CLI version 1.18.116 ou ultérieure ou 2.0.38 ou ultérieure est installée. Pour installer ou mettre à niveau le AWS CLI, reportez-vous à la section Installation du AWS CLI.
Un client kubectl configuré pour communiquer avec votre cluster Kubernetes. Si vous utilisez Amazon Elastic Kubernetes Service, vous pouvez suivre les instructions d'installation et de configuration d'un fichier. kubectl kubeconfig
Helm version 3.0 ou ultérieure installée. Si Helm n'est pas installé, consultez la section Utilisation de Helm avec Amazon EKS dans le guide de l'utilisateur Amazon EKS.
Amazon EKS ne prend actuellement en charge IPv6_ONLY que IPv4_ONLY les préférences IP, car Amazon EKS ne prend actuellement en charge que les pods capables de traiter uniquement du IPv4 trafic ou uniquement IPv6 du trafic.

Les étapes restantes supposent que les services réels sont nommés serviceA, serviceB et serviceBv2, et que tous les services peuvent être détectés via un espace de noms nommé apps.local.

Étape 1 : Installer les composants d'intégration

Installez les composants d'intégration une fois sur chaque cluster hébergeant les pods que vous souhaitez utiliser avec App Mesh.

Pour installer les composants d'intégration

Les étapes restantes de cette procédure nécessitent un cluster sans qu'une version préalable du contrôleur soit installée. Si vous avez installé une version préliminaire, ou si vous n'êtes pas certain de l'avoir fait, vous pouvez télécharger et exécuter un script qui vérifie si une version préliminaire est installée sur votre cluster.
```
curl -o pre_upgrade_check.sh https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/upgrade/pre_upgrade_check.sh
sh ./pre_upgrade_check.sh
```
Si le script retourne Your cluster is ready for upgrade. Please proceed to the installation instructions, vous pouvez passer à l'étape suivante. Si un autre message est renvoyé, vous devrez effectuer les étapes de mise à niveau avant de continuer. Pour plus d'informations sur la mise à niveau d'une version préliminaire, consultez la section Mise à niveau sur GitHub.

Ajoutez le référentiel eks-charts à Helm.


helm repo add eks https://aws.github.io/eks-charts

Installez les définitions de ressources personnalisées (CRD) App Mesh Kubernetes.


kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"

Créez un espace de noms Kubernetes pour le contrôleur.
```
kubectl create ns appmesh-system
```
Définissez les variables suivantes à utiliser pour les étapes ultérieures. Remplacez cluster-name et Region-code par les valeurs de votre cluster existant.
```
export CLUSTER_NAME=cluster-name
export AWS_REGION=Region-code
```
(Facultatif) Si vous souhaitez exécuter le contrôleur sur Fargate, vous devez créer un profil Fargate. Si ce n'est pas le cas, consultez la section Installation ou mise à niveau eksctl dans le guide de l'utilisateur Amazon EKS. eksctl Si vous préférez créer le profil à l'aide de la console, consultez la section Création d'un profil Fargate dans le guide de l'utilisateur Amazon EKS.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name appmesh-system --namespace appmesh-system
```
Créez un fournisseur d'identité OpenID Connect (OIDC) pour votre cluster. Si ce n'est pas le cas, vous pouvez l'installer en suivant les instructions de la section Installation ou mise eksctl à niveau du guide de l'utilisateur Amazon EKS. eksctl Si vous préférez créer le fournisseur à l'aide de la console, consultez la section Activation des rôles IAM pour les comptes de service de votre cluster dans le guide de l'utilisateur Amazon EKS.
```
eksctl utils associate-iam-oidc-provider \
    --region=$AWS_REGION \
    --cluster $CLUSTER_NAME \
    --approve
```
Créez un rôle IAM, associez-y les politiques AWSCloudMapFullAccess AWS gérées AWSAppMeshFullAccesset liez-le au compte de service appmesh-controller Kubernetes. Le rôle permet au contrôleur d'ajouter, de supprimer et de modifier des ressources App Mesh.

Note
La commande crée un rôle AWS IAM avec un nom généré automatiquement. Vous ne pouvez pas spécifier le nom de rôle IAM créé.
```
eksctl create iamserviceaccount \
    --cluster $CLUSTER_NAME \
    --namespace appmesh-system \
    --name appmesh-controller \
    --attach-policy-arn  arn:aws:iam::aws:policy/AWSCloudMapFullAccess,arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
    --override-existing-serviceaccounts \
    --approve
```
Si vous préférez créer le compte de service à l'aide du AWS Management Console ou AWS CLI, consultez la section Création d'un rôle et d'une politique IAM pour votre compte de service dans le guide de l'utilisateur Amazon EKS. Si vous utilisez le AWS Management Console ou AWS CLI pour créer le compte, vous devez également associer le rôle à un compte de service Kubernetes. Pour plus d'informations, consultez la section Spécification d'un rôle IAM pour votre compte de service dans le guide de l'utilisateur Amazon EKS.
Déployez le contrôleur App Mesh. Pour obtenir la liste de toutes les options de configuration, voir Configuration activée GitHub.
1. Pour déployer le contrôleur App Mesh pour un cluster privé, vous devez d'abord activer les points de terminaison Amazon VPC App Mesh et Service Discovery sur le sous-réseau privé lié. Vous devez également définir leaccountId.
```
--set accountId=$AWS_ACCOUNT_ID
```
  Pour activer le suivi X-Ray dans un cluster privé, activez les points de terminaison Amazon VPC X-Ray et Amazon ECR. Le contrôleur l'utilise public.ecr.aws/xray/aws-xray-daemon:latest par défaut, alors extrayez cette image en local et insérez-la dans votre référentiel ECR personnel.
  
  Note
  Les points de terminaison Amazon VPC ne sont actuellement pas compatibles avec les référentiels publics Amazon ECR.
  
  L'exemple suivant montre le déploiement du contrôleur avec des configurations pour X-Ray.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
    --namespace appmesh-system \
    --set region=$AWS_REGION \
    --set serviceAccount.create=false \
    --set serviceAccount.name=appmesh-controller \
    --set accountId=$AWS_ACCOUNT_ID \
    --set log.level=debug \
    --set tracing.enabled=true \
    --set tracing.provider=x-ray \
    --set xray.image.repository=your-account-id.dkr.ecr.your-region.amazonaws.com/your-repository \
    --set xray.image.tag=your-xray-daemon-image-tag
```
  Vérifiez si le daemon X-Ray est correctement injecté lorsque vous liez le déploiement de l'application à votre nœud virtuel ou à votre passerelle.
  
  Pour plus d'informations, consultez la section Clusters privés dans le guide de l'utilisateur Amazon EKS.
2. Déployez le contrôleur App Mesh pour d'autres clusters. Pour obtenir la liste de toutes les options de configuration, voir Configuration activée GitHub.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
    --namespace appmesh-system \
    --set region=$AWS_REGION \
    --set serviceAccount.create=false \
    --set serviceAccount.name=appmesh-controller
```
Note
Si votre famille de clusters Amazon EKS l'estIPv6, veuillez définir le nom du cluster lors du déploiement du contrôleur App Mesh en ajoutant l'option suivante à la commande précédente--set clusterName=$CLUSTER_NAME.
Important
Si votre cluster se trouve dans les af-south-1 régionsme-south-1,,,,,,,ap-east-1,,ap-southeast-3,,eu-south-1,,il-central-1,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
Remplacez account-id et Region-code par l'un des ensembles de valeurs appropriés.
- Pour l'image du sidecar :
  
  --set image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/amazon/appmesh-controller
  
  772975370895.dkr. ecr.me-south-1.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
  
  856666278305.dkr. ecr.ap-east-1.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
  
  909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
  
  422531588944.dkr. ecr.eu-south-1.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
  
  564877687649.dkr. ecr.il-central-1.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
  
  924023996002.dkr. ecr.af-south-1.amazonaws.com /aws-appmesh-envoy:v1.29.5.0-prod
- Les anciens URI des images se trouvent dans le journal des modifications. GitHub Les AWS comptes sur lesquels les images sont présentes ont changé de versionv1.5.0. Les anciennes versions des images sont hébergées sur des AWS comptes figurant dans les registres d'images de conteneurs Amazon Elastic Kubernetes Service Amazon.
- Pour l'image du contrôleur :
  
  --set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
  
  772975370895.dkr. ecr.me-south-1.amazonaws.com /amazon/appmesh-controller:v1.13.0
  
  856666278305.dkr. ecr.ap-east-1.amazonaws.com /amazon/appmesh-controller:v1.13.0
  
  909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /amazon/appmesh-controller:v1.13.0
  
  422531588944.dkr. ecr.eu-south-1.amazonaws.com /amazon/appmesh-controller:v1.13.0
  
  564877687649.dkr. ecr.il-central-1.amazonaws.com /amazon/appmesh-controller:v1.13.0
  
  924023996002.dkr. ecr.af-south-1.amazonaws.com /amazon/appmesh-controller:v1.13.0
- Pour l'image d'initialisation du sidecar :
  
  --set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
  
  772975370895.dkr. ecr.me-south-1.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
  
  856666278305.dkr. ecr.ap-east-1.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
  
  909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
  
  422531588944.dkr. ecr.eu-south-1.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
  
  564877687649.dkr. ecr.il-central-1.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
  
  924023996002.dkr. ecr.af-south-1.amazonaws.com /aws-appmesh-proxy-route-manager:v7-prod
Important
Seule la version v1.9.0.0-prod ou ultérieure est prise en charge pour une utilisation avec App Mesh.
Vérifiez que la version du contrôleur est v1.4.0 ou une version ultérieure. Vous pouvez consulter le journal des modifications GitHub.
```
kubectl get deployment appmesh-controller \
    -n appmesh-system \
    -o json  | jq -r ".spec.template.spec.containers[].image" | cut -f2 -d ':'
```
Note
Si vous affichez le journal du conteneur en cours d'exécution, une ligne contenant le texte suivant peut s'afficher. Vous pouvez l'ignorer en toute sécurité.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```

Étape 2 : Déployer les ressources App Mesh

Lorsque vous déployez une application dans Kubernetes, vous créez également les ressources personnalisées Kubernetes afin que le contrôleur puisse créer les ressources App Mesh correspondantes. La procédure suivante vous aide à déployer des ressources App Mesh avec certaines de leurs fonctionnalités. Vous pouvez trouver des exemples de manifestes pour le déploiement d'autres fonctionnalités des ressources App Mesh dans les v1beta2 sous-dossiers de nombreux dossiers de fonctionnalités répertoriés dans les procédures pas à pas d'App Mesh sur. GitHub

Important

Une fois que le contrôleur a créé une ressource App Mesh, nous vous recommandons de ne modifier ou de supprimer la ressource App Mesh qu'à l'aide du contrôleur. Si vous modifiez ou supprimez la ressource à l'aide d'App Mesh, le contrôleur ne modifiera ni ne recréera la ressource App Mesh modifiée ou supprimée pendant dix heures, par défaut. Vous pouvez configurer cette durée afin qu'elle soit inférieure. Pour plus d'informations, consultez Configuration sur GitHub.

Pour déployer des ressources App Mesh

Créez un espace de noms Kubernetes dans lequel déployer les ressources App Mesh.
1. Enregistrez le contenu suivant dans un fichier nommé namespace.yaml sur votre ordinateur.
```
apiVersion: v1
kind: Namespace
metadata:
  name: my-apps
  labels:
    mesh: my-mesh
    appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
2. Créez l'espace de noms.
```
kubectl apply -f namespace.yaml
```

Créez un maillage de service App Mesh.

Enregistrez le contenu suivant dans un fichier nommé mesh.yaml sur votre ordinateur. Le fichier est utilisé pour créer une ressource de maillage nomméemy-mesh. Un maillage de service est une limite logique pour le trafic réseau entre les services qui résident dans celui-ci.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
  name: my-mesh
spec:
  namespaceSelector:
    matchLabels:
      mesh: my-mesh
```
Créez le maillage.
```
kubectl apply -f mesh.yaml
```

Affichez les détails de la ressource de maillage Kubernetes créée.


kubectl describe mesh my-mesh

Sortie


Name:         my-mesh
Namespace:
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"Mesh","metadata":{"annotations":{},"name":"my-mesh"},"spec":{"namespaceSelector":{"matchLa...
API Version:  appmesh.k8s.aws/v1beta2
Kind:         Mesh
Metadata:
  Creation Timestamp:  2020-06-17T14:51:37Z
  Finalizers:
    finalizers.appmesh.k8s.aws/mesh-members
    finalizers.appmesh.k8s.aws/aws-appmesh-resources
  Generation:        1
  Resource Version:  6295
  Self Link:         /apis/appmesh.k8s.aws/v1beta2/meshes/my-mesh
  UID:               111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
  Aws Name:  my-mesh
  Namespace Selector:
    Match Labels:
      Mesh:  my-mesh
Status:
  Conditions:
    Last Transition Time:  2020-06-17T14:51:37Z
    Status:                True
    Type:                  MeshActive
  Mesh ARN:                arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh
  Observed Generation:     1
Events:                    <none>

Consultez les détails du maillage de service App Mesh créé par le contrôleur.


aws appmesh describe-mesh --mesh-name my-mesh

Sortie


{
    "mesh": {
        "meshName": "my-mesh",
        "metadata": {
            "arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh",
            "createdAt": "2020-06-17T09:51:37.920000-05:00",
            "lastUpdatedAt": "2020-06-17T09:51:37.920000-05:00",
            "meshOwner": "111122223333",
            "resourceOwner": "111122223333",
            "uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
            "version": 1
        },
        "spec": {},
        "status": {
            "status": "ACTIVE"
        }
    }
}

Créez un nœud virtuel App Mesh. Un nœud virtuel agit comme un pointeur logique vers un déploiement Kubernetes.

Enregistrez le contenu suivant dans un fichier nommé virtual-node.yaml sur votre ordinateur. Le fichier est utilisé pour créer un nœud virtuel App Mesh nommé my-service-a dans l'espace de my-appsnoms. Le nœud virtuel représente un service Kubernetes créé dans une étape ultérieure. La valeur de hostname est le nom d'hôte DNS complet du service réel que ce nœud virtuel représente.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualNode
metadata:
  name: my-service-a
  namespace: my-apps
spec:
  podSelector:
    matchLabels:
      app: my-app-1
  listeners:
    - portMapping:
        port: 80
        protocol: http
  serviceDiscovery:
    dns:
      hostname: my-service-a.my-apps.svc.cluster.local
```
Les nœuds virtuels possèdent des fonctionnalités, telles que le end-to-end chiffrement et les contrôles de santé, qui ne sont pas abordées dans ce didacticiel. Pour plus d’informations, consultez Nœuds virtuels. Pour afficher tous les paramètres disponibles pour un nœud virtuel que vous pouvez définir dans la spécification précédente, exécutez la commande suivante.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
Déployez le nœud virtuel.
```
kubectl apply -f virtual-node.yaml
```

Affichez les détails de la ressource de nœud virtuel Kubernetes créée.


kubectl describe virtualnode my-service-a -n my-apps

Sortie


Name:         my-service-a
Namespace:    my-apps
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualNode","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"},"s...
API Version:  appmesh.k8s.aws/v1beta2
Kind:         VirtualNode
Metadata:
  Creation Timestamp:  2020-06-17T14:57:29Z
  Finalizers:
    finalizers.appmesh.k8s.aws/aws-appmesh-resources
  Generation:        2
  Resource Version:  22545
  Self Link:         /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualnodes/my-service-a
  UID:               111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
  Aws Name:  my-service-a_my-apps
  Listeners:
    Port Mapping:
      Port:      80
      Protocol:  http
  Mesh Ref:
    Name:  my-mesh
    UID:   111a11b1-c11d-1e1f-gh1i-j11k1l111m711
  Pod Selector:
    Match Labels:
      App:  nginx
  Service Discovery:
    Dns:
      Hostname:  my-service-a.my-apps.svc.cluster.local
Status:
  Conditions:
    Last Transition Time:  2020-06-17T14:57:29Z
    Status:                True
    Type:                  VirtualNodeActive
  Observed Generation:     2
  Virtual Node ARN:        arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
Events:                    <none>

Affichez les détails du nœud virtuel créé par le contrôleur dans App Mesh.

Note

Même si le nom du nœud virtuel créé dans Kubernetes est my-service-a, le nom du nœud virtuel créé dans App Mesh est my-service-a_my-apps. Le contrôleur ajoute le nom de l'espace de noms Kubernetes au nom du nœud virtuel App Mesh lorsqu'il crée la ressource App Mesh. Le nom de l'espace de noms est ajouté car dans Kubernetes, vous pouvez créer des nœuds virtuels portant le même nom dans différents espaces de noms, mais dans App Mesh, le nom d'un nœud virtuel doit être unique au sein d'un maillage.


aws appmesh describe-virtual-node --mesh-name my-mesh --virtual-node-name my-service-a_my-apps

Sortie


{
    "virtualNode": {
        "meshName": "my-mesh",
        "metadata": {
            "arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps",
            "createdAt": "2020-06-17T09:57:29.840000-05:00",
            "lastUpdatedAt": "2020-06-17T09:57:29.840000-05:00",
            "meshOwner": "111122223333",
            "resourceOwner": "111122223333",
            "uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
            "version": 1
        },
        "spec": {
            "backends": [],
            "listeners": [
                {
                    "portMapping": {
                        "port": 80,
                        "protocol": "http"
                    }
                }
            ],
            "serviceDiscovery": {
                "dns": {
                    "hostname": "my-service-a.my-apps.svc.cluster.local"
                }
            }
        },
        "status": {
            "status": "ACTIVE"
        },
        "virtualNodeName": "my-service-a_my-apps"
    }
}

Créez un routeur virtuel App Mesh. Les routeurs virtuels gèrent le trafic d'un ou de plusieurs services virtuels au sein de votre mesh.

Enregistrez le contenu suivant dans un fichier nommé virtual-router.yaml sur votre ordinateur. Le fichier est utilisé pour créer un routeur virtuel afin d'acheminer le trafic vers le nœud virtuel nommé my-service-a qui a été créé à l'étape précédente. Le contrôleur crée le routeur virtuel App Mesh et achemine les ressources. Vous pouvez spécifier beaucoup d'autres fonctionnalités pour vos routages et utiliser des protocoles autres que http. Pour plus d’informations, consultez Routeurs virtuels et Acheminements. Notez que le nom du nœud virtuel référencé est le nom du nœud virtuel Kubernetes, et non le nom du nœud virtuel App Mesh créé dans App Mesh par le contrôleur.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
  namespace: my-apps
  name: my-service-a-virtual-router
spec:
  listeners:
    - portMapping:
        port: 80
        protocol: http
  routes:
    - name: my-service-a-route
      httpRoute:
        match:
          prefix: /
        action:
          weightedTargets:
            - virtualNodeRef:
                name: my-service-a
              weight: 1
```
(Facultatif) Pour voir tous les paramètres disponibles pour un routeur virtuel que vous pouvez définir dans la spécification précédente, exécutez la commande suivante.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Pour voir tous les paramètres disponibles pour un itinéraire que vous pouvez définir dans la spécification précédente, exécutez la commande suivante.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
Déployez le routeur virtuel.
```
kubectl apply -f virtual-router.yaml
```

Affichez la ressource de routeur virtuel Kubernetes qui a été créée.


kubectl describe virtualrouter my-service-a-virtual-router -n my-apps

Sortie abrégée


Name:         my-service-a-virtual-router
Namespace:    my-apps
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualRouter","metadata":{"annotations":{},"name":"my-service-a-virtual-router","namespac...
API Version:  appmesh.k8s.aws/v1beta2
Kind:         VirtualRouter
...
Spec:
  Aws Name:  my-service-a-virtual-router_my-apps
  Listeners:
    Port Mapping:
      Port:      80
      Protocol:  http
  Mesh Ref:
    Name:  my-mesh
    UID:   111a11b1-c11d-1e1f-gh1i-j11k1l111m711
  Routes:
    Http Route:
      Action:
        Weighted Targets:
          Virtual Node Ref:
            Name:  my-service-a
          Weight:  1
      Match:
        Prefix:  /
    Name:        my-service-a-route
Status:
  Conditions:
    Last Transition Time:  2020-06-17T15:14:01Z
    Status:                True
    Type:                  VirtualRouterActive
  Observed Generation:     1
  Route AR Ns:
    My - Service - A - Route:  arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route
  Virtual Router ARN:          arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps
Events:                        <none>

Affichez la ressource de routeur virtuel créée par le contrôleur dans App Mesh. Vous spécifiez my-service-a-virtual-router_my-apps pourname, car lorsque le contrôleur a créé le routeur virtuel dans App Mesh, il a ajouté le nom de l'espace de noms Kubernetes au nom du routeur virtuel.


aws appmesh describe-virtual-router --virtual-router-name my-service-a-virtual-router_my-apps --mesh-name my-mesh

Sortie


{
    "virtualRouter": {
        "meshName": "my-mesh",
        "metadata": {
            "arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps",
            "createdAt": "2020-06-17T10:14:01.547000-05:00",
            "lastUpdatedAt": "2020-06-17T10:14:01.547000-05:00",
            "meshOwner": "111122223333",
            "resourceOwner": "111122223333",
            "uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
            "version": 1
        },
        "spec": {
            "listeners": [
                {
                    "portMapping": {
                        "port": 80,
                        "protocol": "http"
                    }
                }
            ]
        },
        "status": {
            "status": "ACTIVE"
        },
        "virtualRouterName": "my-service-a-virtual-router_my-apps"
    }
}

Affichez la ressource d'itinéraire créée par le contrôleur dans App Mesh. Une ressource de route n'a pas été créée dans Kubernetes car la route fait partie de la configuration du routeur virtuel dans Kubernetes. Les informations de route ont été affichées dans le détail de la ressource Kubernetes dans la sous-étape c. Le contrôleur n'a pas ajouté le nom de l'espace de noms Kubernetes au nom de l'itinéraire App Mesh lorsqu'il a créé l'itinéraire dans App Mesh, car les noms des itinéraires sont uniques à un routeur virtuel.


aws appmesh describe-route \
    --route-name my-service-a-route \
    --virtual-router-name my-service-a-virtual-router_my-apps \
    --mesh-name my-mesh

Sortie


{
    "route": {
        "meshName": "my-mesh",
        "metadata": {
            "arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route",
            "createdAt": "2020-06-17T10:14:01.577000-05:00",
            "lastUpdatedAt": "2020-06-17T10:14:01.577000-05:00",
            "meshOwner": "111122223333",
            "resourceOwner": "111122223333",
            "uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
            "version": 1
        },
        "routeName": "my-service-a-route",
        "spec": {
            "httpRoute": {
                "action": {
                    "weightedTargets": [
                        {
                            "virtualNode": "my-service-a_my-apps",
                            "weight": 1
                        }
                    ]
                },
                "match": {
                    "prefix": "/"
                }
            }
        },
        "status": {
            "status": "ACTIVE"
        },
        "virtualRouterName": "my-service-a-virtual-router_my-apps"
    }
}

Créez un service virtuel App Mesh. Un service virtuel est une abstraction d'un service réel qui est fournie directement ou indirectement par un nœud virtuel, via un routeur virtuel. Les services dépendants appellent votre service virtuel par son nom. Bien que le nom n'ait pas d'importance pour App Mesh, nous recommandons de nommer le service virtuel comme le nom de domaine complet du service réel que le service virtuel représente. En nommant vos services virtuels de cette façon, vous n'avez pas besoin de modifier votre code d'application pour référencer un autre nom. Ces demandes sont acheminées vers le nœud virtuel ou le routeur virtuel qui est spécifié en tant que fournisseur pour le service virtuel.

Enregistrez le contenu suivant dans un fichier nommé virtual-service.yaml sur votre ordinateur. Le fichier est utilisé pour créer un service virtuel qui utilise un fournisseur de routeur virtuel pour acheminer le trafic vers le nœud virtuel nommé my-service-a qui a été créé à l'étape précédente. La valeur de awsName dans le spec correspond au nom de domaine complet (FQDN) du service Kubernetes réel que ce service virtuel résume. Le service Kubernetes est créé dans Étape 3 : Créer ou mettre à jour des services. Pour plus d’informations, consultez Services virtuels.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualService
metadata:
  name: my-service-a
  namespace: my-apps
spec:
  awsName: my-service-a.my-apps.svc.cluster.local
  provider:
    virtualRouter:
      virtualRouterRef:
        name: my-service-a-virtual-router
```
Pour afficher tous les paramètres disponibles pour un nœud virtuel que vous pouvez définir dans la spécification précédente, exécutez la commande suivante.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
Créez le service virtuel.
```
kubectl apply -f virtual-service.yaml
```

Affichez les détails de la ressource de service virtuel Kubernetes créée.


kubectl describe virtualservice my-service-a -n my-apps

Sortie


Name:         my-service-a
Namespace:    my-apps
Labels:       <none>
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualService","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"}...
API Version:  appmesh.k8s.aws/v1beta2
Kind:         VirtualService
Metadata:
  Creation Timestamp:  2020-06-17T15:48:40Z
  Finalizers:
    finalizers.appmesh.k8s.aws/aws-appmesh-resources
  Generation:        1
  Resource Version:  13598
  Self Link:         /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualservices/my-service-a
  UID:               111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
  Aws Name:  my-service-a.my-apps.svc.cluster.local
  Mesh Ref:
    Name:  my-mesh
    UID:   111a11b1-c11d-1e1f-gh1i-j11k1l111m711
  Provider:
    Virtual Router:
      Virtual Router Ref:
        Name:  my-service-a-virtual-router
Status:
  Conditions:
    Last Transition Time:  2020-06-17T15:48:40Z
    Status:                True
    Type:                  VirtualServiceActive
  Observed Generation:     1
  Virtual Service ARN:     arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local
Events:                    <none>

Affichez les détails de la ressource de service virtuel créée par le contrôleur dans App Mesh. Le contrôleur Kubernetes n'a pas ajouté le nom de l'espace de noms Kubernetes au nom du service virtuel App Mesh lorsqu'il a créé le service virtuel dans App Mesh, car le nom du service virtuel est un FQDN unique.


aws appmesh describe-virtual-service --virtual-service-name my-service-a.my-apps.svc.cluster.local --mesh-name my-mesh

Sortie


{
    "virtualService": {
        "meshName": "my-mesh",
        "metadata": {
            "arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local",
            "createdAt": "2020-06-17T10:48:40.182000-05:00",
            "lastUpdatedAt": "2020-06-17T10:48:40.182000-05:00",
            "meshOwner": "111122223333",
            "resourceOwner": "111122223333",
            "uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
            "version": 1
        },
        "spec": {
            "provider": {
                "virtualRouter": {
                    "virtualRouterName": "my-service-a-virtual-router_my-apps"
                }
            }
        },
        "status": {
            "status": "ACTIVE"
        },
        "virtualServiceName": "my-service-a.my-apps.svc.cluster.local"
    }
}

Bien que cela ne soit pas abordé dans ce didacticiel, le contrôleur peut également déployer App Mesh Passerelle etitinéraires de passerelle. Pour une présentation détaillée du déploiement de ces ressources avec le contrôleur, consultez la section Configuration de la passerelle entrante ou un exemple de manifeste incluant les ressources sur. GitHub

Étape 3 : Créer ou mettre à jour des services

Les conteneurs annexes App Mesh doivent être ajoutés à tous les pods que vous souhaitez utiliser avec App Mesh. L'injecteur ajoute automatiquement les conteneurs sidecar à n'importe quel pod déployé dans un espace de noms avec l'étiquette que vous spécifiez.

Activez l'autorisation proxy. Nous vous recommandons d'activer chaque déploiement Kubernetes pour diffuser uniquement la configuration de son propre nœud virtuel App Mesh.
1. Enregistrez le contenu suivant dans un fichier nommé proxy-auth.json sur votre ordinateur. Assurez-vous de remplacer les valeurs d'autre couleur par les vôtres.
```
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "appmesh:StreamAggregatedResources",
            "Resource": [
                "arn:aws:appmesh:Region-code:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps"
            ]
        }
    ]
}
```
2. Créez la politique.
```
aws iam create-policy --policy-name my-policy --policy-document file://proxy-auth.json
```
3. Créez un rôle IAM, associez-y la politique que vous avez créée à l'étape précédente, créez un compte de service Kubernetes et liez la politique au compte de service Kubernetes. Le rôle permet au contrôleur d'ajouter, de supprimer et de modifier des ressources App Mesh.
```
eksctl create iamserviceaccount \
    --cluster $CLUSTER_NAME \
    --namespace my-apps \
    --name my-service-a \
    --attach-policy-arn  arn:aws:iam::111122223333:policy/my-policy \
    --override-existing-serviceaccounts \
    --approve
```
  Si vous préférez créer le compte de service à l'aide du AWS Management Console ou AWS CLI, consultez la section Création d'un rôle et d'une politique IAM pour votre compte de service dans le guide de l'utilisateur Amazon EKS. Si vous utilisez le AWS Management Console ou AWS CLI pour créer le compte, vous devez également associer le rôle à un compte de service Kubernetes. Pour plus d'informations, consultez la section Spécification d'un rôle IAM pour votre compte de service dans le guide de l'utilisateur Amazon EKS.
(Facultatif) Si vous souhaitez déployer votre déploiement sur des pods Fargate, vous devez créer un profil Fargate. Si ce n'est pas le cas, vous pouvez l'installer en suivant les instructions de la section Installation ou mise eksctl à niveau du guide de l'utilisateur Amazon EKS. eksctl Si vous préférez créer le profil à l'aide de la console, consultez la section Création d'un profil Fargate dans le guide de l'utilisateur Amazon EKS.
```
eksctl create fargateprofile --cluster my-cluster --region Region-code --name my-service-a --namespace my-apps
```

Créez un service et un déploiement Kubernetes. Si vous avez un déploiement existant que vous souhaitez utiliser avec App Mesh, vous devez déployer un nœud virtuel, comme vous l'avez fait à la sous-étape 3 deÉtape 2 : Déployer les ressources App Mesh. Mettez à jour votre déploiement pour vous assurer que son étiquette correspond à celle que vous avez définie sur le nœud virtuel, afin que les conteneurs annexes soient automatiquement ajoutés aux pods et que les pods soient redéployés.

Enregistrez le contenu suivant dans un fichier nommé example-service.yaml sur votre ordinateur. Si vous modifiez le nom de l'espace de noms et que vous utilisez des pods Fargate, assurez-vous que le nom de l'espace de noms correspond à celui défini dans votre profil Fargate.
```
apiVersion: v1
kind: Service
metadata:
  name: my-service-a
  namespace: my-apps
  labels:
    app: my-app-1
spec:
  selector:
    app: my-app-1
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-service-a
  namespace: my-apps
  labels:
    app: my-app-1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app-1
  template:
    metadata:
      labels:
        app: my-app-1
    spec:
      serviceAccountName: my-service-a
      containers:
      - name: nginx
        image: nginx:1.19.0
        ports:
        - containerPort: 80
```
Important
La valeur de la spécification app matchLabels selector dans la spécification doit correspondre à la valeur que vous avez spécifiée lors de la création du nœud virtuel dans la sous-étape 3 de Étape 2 : Déployer les ressources App Mesh, sinon les conteneurs sidecar ne seront pas injectés dans le conteneur. Dans l'exemple précédent, la valeur de l'étiquette est my-app-1. Si vous déployez une passerelle virtuelle plutôt qu'un nœud virtuel, le Deployment manifeste ne doit inclure que le conteneur Envoy. Pour plus d'informations sur l'image à utiliser, consultezImage de l'envoyé. Pour un exemple de manifeste, consultez l'exemple de déploiement sur GitHub.
Déployez le service.
```
kubectl apply -f example-service.yaml
```

Consultez le service et le déploiement.


kubectl -n my-apps get pods

Sortie


NAME                            READY   STATUS    RESTARTS   AGE
my-service-a-54776556f6-2cxd9   2/2     Running   0          10s
my-service-a-54776556f6-w26kf   2/2     Running   0          18s
my-service-a-54776556f6-zw5kt   2/2     Running   0          26s

Consultez les détails de l'un des pods qui a été déployé.


kubectl -n my-apps describe pod my-service-a-54776556f6-2cxd9

Sortie abrégée


Name:         my-service-a-54776556f6-2cxd9
Namespace:    my-app-1
Priority:     0
Node:         ip-192-168-44-157.us-west-2.compute.internal/192.168.44.157
Start Time:   Wed, 17 Jun 2020 11:08:59 -0500
Labels:       app=nginx
              pod-template-hash=54776556f6
Annotations:  kubernetes.io/psp: eks.privileged
Status:       Running
IP:           192.168.57.134
IPs:
  IP:           192.168.57.134
Controlled By:  ReplicaSet/my-service-a-54776556f6
Init Containers:
  proxyinit:
    Container ID:   docker://e0c4810d584c21ae0cb6e40f6119d2508f029094d0e01c9411c6cf2a32d77a59
    Image:          111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2
    Image ID:       docker-pullable://111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager
    Port:           <none>
    Host Port:      <none>
    State:          Terminated
      Reason:       Completed
      Exit Code:    0
      Started:      Fri, 26 Jun 2020 08:36:22 -0500
      Finished:     Fri, 26 Jun 2020 08:36:22 -0500
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:     10m
      memory:  32Mi
    Environment:
      APPMESH_START_ENABLED:         1
      APPMESH_IGNORE_UID:            1337
      APPMESH_ENVOY_INGRESS_PORT:    15000
      APPMESH_ENVOY_EGRESS_PORT:     15001
      APPMESH_APP_PORTS:             80
      APPMESH_EGRESS_IGNORED_IP:     169.254.169.254
      APPMESH_EGRESS_IGNORED_PORTS:  22
      AWS_ROLE_ARN:                  arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
      AWS_WEB_IDENTITY_TOKEN_FILE:   /var/run/secrets/eks.amazonaws.com/serviceaccount/token
    ...
Containers:
  nginx:
    Container ID:   docker://be6359dc6ecd3f18a1c87df7b57c2093e1f9db17d5b3a77f22585ce3bcab137a
    Image:          nginx:1.19.0
    Image ID:       docker-pullable://nginx
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 26 Jun 2020 08:36:28 -0500
    Ready:          True
    Restart Count:  0
    Environment:
      AWS_ROLE_ARN:                 arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
      AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
    ...
  envoy:
    Container ID:   docker://905b55cbf33ef3b3debc51cb448401d24e2e7c2dbfc6a9754a2c49dd55a216b6
    Image:          840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod
    Image ID:       docker-pullable://840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy
    Port:           9901/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Fri, 26 Jun 2020 08:36:36 -0500
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:     10m
      memory:  32Mi
    Environment:
      APPMESH_RESOURCE_ARN:         arn:aws:iam::111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
      APPMESH_PREVIEW:              0
      ENVOY_LOG_LEVEL:              info
      AWS_REGION:                   us-west-2
      AWS_ROLE_ARN:                 arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
      AWS_WEB_IDENTITY_TOKEN_FILE:  /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Events:
  Type    Reason     Age   From                                                   Message
  ----    ------     ----  ----                                                   -------
  Normal  Pulling    30s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Pulling image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
  Normal  Pulled     23s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Successfully pulled image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
  Normal  Created    21s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Created container proxyinit
  Normal  Started    21s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Started container proxyinit
  Normal  Pulling    20s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Pulling image "nginx:1.19.0"
  Normal  Pulled     16s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Successfully pulled image "nginx:1.19.0"
  Normal  Created    15s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Created container nginx
  Normal  Started    15s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Started container nginx
  Normal  Pulling    15s   kubelet, ip-192-168-44-157.us-west-2.compute.internal  Pulling image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
  Normal  Pulled     8s    kubelet, ip-192-168-44-157.us-west-2.compute.internal  Successfully pulled image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
  Normal  Created    7s    kubelet, ip-192-168-44-157.us-west-2.compute.internal  Created container envoy
  Normal  Started    7s    kubelet, ip-192-168-44-157.us-west-2.compute.internal  Started container envoy

Dans la sortie précédente, vous pouvez voir que les conteneurs proxyinit et envoy ont été ajoutés au pod. Si vous avez déployé l'exemple de service sur Fargate, envoy le conteneur a été ajouté au pod par le contrôleur, mais pas proxyinit le conteneur.

(Facultatif) Installez des modules complémentaires tels que Prometheus, Grafana, Jaeger et AWS X-Ray Datadog. Pour plus d'informations, consultez les modules complémentaires App Mesh GitHub et la section Observabilité du guide de l'utilisateur d'App Mesh.

Note

Pour plus d'exemples et de procédures pas à pas pour App Mesh, consultez le référentiel d'exemples d'App Mesh.

Étape 4 : Nettoyer

Supprimez toutes les ressources d'exemple créées dans ce didacticiel. Le contrôleur supprime également les ressources créées dans le maillage du service my-mesh App Mesh.


kubectl delete namespace my-apps

Si vous avez créé un profil Fargate pour le service d'exemple, supprimez-le.


eksctl delete fargateprofile --name my-service-a --cluster my-cluster --region Region-code

Supprimez le maillage.


kubectl delete mesh my-mesh

(Facultatif) Vous pouvez supprimer les composants d'intégration Kubernetes.


helm delete appmesh-controller -n appmesh-system

(Facultatif) Si vous avez déployé les composants d'intégration Kubernetes sur Fargate, supprimez le profil Fargate.


eksctl delete fargateprofile --name appmesh-system --cluster my-cluster --region Region-code

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

App Mesh et Amazon ECS

App Mesh et Amazon EC2

Premiers pas avec AWS App Mesh Kubernetes

Prérequis

Étape 1 : Installer les composants d'intégration

Pour installer les composants d'intégration

Note

Déployez le contrôleur App Mesh. Pour obtenir la liste de toutes les options de configuration, voir Configuration activée GitHub.

Note

Note

Important

Pour l'image du sidecar :

Pour l'image du contrôleur :

Pour l'image d'initialisation du sidecar :

Important

Note

Étape 2 : Déployer les ressources App Mesh

Important

Pour déployer des ressources App Mesh

Note

Étape 3 : Créer ou mettre à jour des services

Important

Note

Étape 4 : Nettoyer