**Aidez à améliorer cette page**
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.
Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.
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.
# Démarrage rapide : déploiement d’une application Web et stockage des données
[Ce didacticiel de démarrage rapide vous explique les étapes à suivre pour déployer l'exemple d'application de jeu 2048 et conserver ses données sur un cluster Amazon EKS Auto Mode à l'aide d'eksctl.](https://eksctl.io/)
[Le mode automatique d'Amazon EKS](automode.md) simplifie la gestion des clusters en automatisant les tâches de routine telles que le stockage par blocs, la mise en réseau, l'équilibrage de charge et le dimensionnement automatique du calcul. Lors de l'installation, il gère la création de nœuds avec des instances EC2 gérées, des équilibreurs de charge d'applications et des volumes EBS.
En résumé, vous allez déployer un exemple de charge de travail avec les annotations personnalisées nécessaires pour une intégration fluide aux AWS services.
## Dans ce tutoriel
À l’aide du modèle de cluster `eksctl` ci-dessous, vous créez un cluster avec le mode automatique EKS pour le provisionnement automatisé des nœuds.
+ **Configuration VPC** : Lorsque vous utilisez le modèle de cluster eksctl ci-dessous, eksctl crée automatiquement un Virtual Private Cloud ( IPv4 VPC) pour le cluster. Par défaut, eksctl configure un VPC qui répond à toutes les exigences de mise en réseau, en plus de créer des points de terminaison publics et privés.
+ **Gestion des instances** : le mode automatique EKS ajoute ou supprime dynamiquement des nœuds dans votre cluster EKS en fonction des demandes de vos applications Kubernetes.
+ **Persistance des données** : utilisez la capacité de stockage par blocs du mode automatique d'EKS pour garantir la persistance des données d'application, même dans les scénarios impliquant le redémarrage ou la défaillance du pod.
+ **Accès aux applications externes** : utilisez la fonctionnalité d'équilibrage de charge du mode automatique d'EKS pour provisionner dynamiquement un Application Load Balancer (ALB).
## Conditions préalables
Avant de commencer, assurez-vous d’avoir effectué les tâches suivantes :
+ [Configuration de votre environnement pour Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Installation de la dernière version d’eksctl](https://eksctl.io/installation/)
## Configurer le cluster
Dans cette section, vous allez créer un cluster à l’aide du mode automatique EKS pour le provisionnement dynamique des nœuds.
Créez un fichier `cluster-config.yaml` et collez-y le contenu suivant. Remplacez `region-code` par une région valide (par exemple,`us-east-1`).
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: web-quickstart
region:
autoModeConfig:
enabled: true
```
Nous sommes maintenant prêts à créer le cluster.
Créez le cluster EKS à l'aide de `cluster-config.yaml`` :
```
eksctl create cluster -f cluster-config.yaml
```
**Important**
Si vous n’utilisez pas eksctl pour créer le cluster, vous devez baliser manuellement les sous-réseaux VPC.
## Créez IngressClass
Créez une `IngressClass` Kubernetes pour le mode automatique EKS. IngressClass définit la manière dont le mode automatique EKS gère les ressources d'entrée. Cette étape configure la capacité d’équilibrage de charge du mode automatique EKS. Lorsque vous créez des ressources d'entrée pour vos applications, le mode automatique d'EKS les utilise pour provisionner et gérer automatiquement les équilibreurs de charge, en intégrant vos applications Kubernetes aux services d'équilibrage de charge. IngressClass AWS
Enregistrez le fichier yaml suivant sous le nom `ingressclass.yaml` :
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
ingressclass.kubernetes.io/is-default-class: "true"
spec:
controller: eks.amazonaws.com/alb
```
Appliquez le IngressClass à votre cluster :
```
kubectl apply -f ingressclass.yaml
```
## Déployer l’application exemple de jeu 2048
Dans cette section, nous vous guidons à travers les étapes de déploiement du célèbre « jeu 2048 » en tant qu’application exemple au sein du cluster. Le manifeste fourni comprend des annotations personnalisées pour l’Application Load Balancer (ALB). Ces annotations s'intègrent à EKS et indiquent à EKS de traiter le trafic HTTP entrant comme « orienté vers Internet » et de l'acheminer vers le service approprié dans l'`game-2048`espace de noms en utilisant le type de cible « ip ».
**Note**
L’image `docker-2048` de l’exemple est une image de conteneur `x86_64` et ne fonctionnera pas sur d’autres architectures.
1. Créez un espace de noms Kubernetes appelé `game-2048` avec l’indicateur `--save-config`.
```
kubectl create namespace game-2048 --save-config
```
Le résultat de la réponse devrait être le suivant :
```
namespace/game-2048 created
```
1. Déployez l’[application exemple de jeu 2048](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml).
```
kubectl apply -n game-2048 -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml
```
Ce manifeste configure un déploiement, un service et un ingress Kubernetes pour l’espace de noms `game-2048`, créant ainsi les ressources nécessaires pour déployer et exposer l’application `game-2048` au sein du cluster. Il inclut la création d’un service nommé `service-2048` qui expose le déploiement sur le port `80`, et une ressource Ingress nommée `ingress-2048` qui définit les règles de routage pour le trafic HTTP entrant et les annotations pour un Application Load Balancer (ALB) connecté à Internet. Le résultat de la réponse devrait être le suivant :
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```
1. Exécutez la commande suivante pour obtenir la ressource Ingress pour l’espace de noms `game-2048`.
```
kubectl get ingress -n game-2048
```
Le résultat de la réponse devrait être le suivant :
```
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress-2048 alb * k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com 80 31s
```
Vous devrez patienter quelques minutes pour que l’Application Load Balancer (ALB) soit provisionné avant de passer aux étapes suivantes.
1. Ouvrez un navigateur Web et saisissez l’`ADDRESS` de l’étape précédente pour accéder à l’application Web. Par exemple :
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Le jeu 2048 devrait s’afficher dans votre navigateur. Lire \$1
![\[Jouer au jeu 2048\]](http://docs.aws.amazon.com/fr_fr/eks/latest/userguide/images/quick2048.png)
## Conserver les données à l’aide du mode automatique Amazon EKS
Maintenant que le jeu 2048 est opérationnel sur votre cluster Amazon EKS, il est temps de vous assurer que les données de votre jeu sont conservées en toute sécurité à l’aide de la fonctionnalité de stockage en bloc du mode automatique Amazon EKS.
1. Créez un fichier nommé `storage-class.yaml`:
```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: auto-ebs-sc
annotations:
storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.eks.amazonaws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
type: gp3
encrypted: "true"
```
1. Appliquez le `StorageClass` :
```
kubectl apply -f storage-class.yaml
```
1. Créez une demande de volume persistant (PVC) pour demander du stockage pour les données de votre jeu. Créez un fichier nommé `ebs-pvc.yaml` et ajoutez-y le contenu suivant :
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: game-data-pvc
namespace: game-2048
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
storageClassName: auto-ebs-sc
```
1. Appliquez le PVC à votre cluster :
```
kubectl apply -f ebs-pvc.yaml
```
Le résultat de la réponse devrait être le suivant :
```
persistentvolumeclaim/game-data-pvc created
```
1. Vous devez maintenant mettre à jour le déploiement de votre jeu 2048 afin d’utiliser ce PVC pour stocker les données. Le déploiement suivant est configuré pour utiliser le PVC pour stocker les données du jeu. Créez un fichier nommé `ebs-deployment.yaml` et ajoutez-y le contenu suivant :
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
replicas: 3 # Adjust the number of replicas as needed
selector:
matchLabels:
app.kubernetes.io/name: app-2048
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- name: app-2048
image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
ports:
- containerPort: 80
volumeMounts:
- name: game-data
mountPath: /var/lib/2048
volumes:
- name: game-data
persistentVolumeClaim:
claimName: game-data-pvc
```
1. Appliquez le déploiement mis à jour :
```
kubectl apply -f ebs-deployment.yaml
```
Le résultat de la réponse devrait être le suivant :
```
deployment.apps/deployment-2048 configured
```
Grâce à ces étapes, votre jeu 2048 sur le cluster est désormais configuré pour conserver les données à l’aide de la fonctionnalité de stockage en blocs du mode automatique Amazon EKS. Cela garantit la sécurité de la progression et des données de votre jeu, même en cas de défaillance d’un pod ou d’un nœud.
Si vous avez apprécié ce tutoriel, veuillez nous en faire part afin que nous puissions vous proposer d’autres tutoriels de démarrage rapide spécifiques à des cas d’utilisation comme celui-ci.
## Nettoyage
Pour éviter d'encourir de futurs frais, vous devez supprimer manuellement la CloudFormation pile associée pour supprimer toutes les ressources créées au cours de ce guide, y compris le réseau VPC.
Supprimez la CloudFormation pile :
```
eksctl delete cluster -f ./cluster-config.yaml
```