**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éploiement d’une charge de travail de l’équilibreur de charge en mode automatique EKS
Ce guide explique comment déployer une version conteneurisée du jeu 2048 sur Amazon EKS, avec équilibreur de charge et accès Internet.
## Prérequis
+ Un cluster du mode automatique EKS
+ `kubectl` configuré pour interagir avec votre cluster
+ Autorisations IAM nécessaires pour créer des ressources ALB
## Étape 1 : créer l’espace de noms
Créez d’abord un espace de noms dédié pour l’application de jeu 2048.
Créez un fichier nommé `01-namespace.yaml`:
```
apiVersion: v1
kind: Namespace
metadata:
name: game-2048
```
Appliquez la configuration de l’espace de noms :
```
kubectl apply -f 01-namespace.yaml
```
## Étape 2 : déployer l’application
L’application exécute plusieurs réplicas du conteneur du jeu 2048.
Créez un fichier nommé `02-deployment.yaml`:
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
selector:
matchLabels:
app.kubernetes.io/name: app-2048
replicas: 5
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
name: app-2048
ports:
- containerPort: 80
resources:
requests:
cpu: "0.5"
```
**Note**
Si vous recevez une erreur lors du chargement de l’image `public.ecr.aws/l6m2t8p7/docker-2048:latest`, vérifiez que votre rôle IAM de nœud possède les autorisations nécessaires pour extraire les images depuis ECR. Pour de plus amples informations, consultez [Rôle IAM de nœud](auto-learn-iam.md#auto-learn-node-iam-role). De plus, l’image `docker-2048` utilisée dans l’exemple est une image `x86_64` et ne fonctionnera pas sur d’autres architectures.
**Composants clés :**
+ Déploiement de 5 réplicas de l’application
+ Utilisation d’une image ECR publique
+ Demande de 0,5 cœur de processeur par pod
+ Exposition du port 80 pour le trafic HTTP
Appliquez le déploiement :
```
kubectl apply -f 02-deployment.yaml
```
## Étape 3 : créer le service
Le service expose le déploiement au réseau du cluster.
Créez un fichier nommé `03-service.yaml`:
```
apiVersion: v1
kind: Service
metadata:
namespace: game-2048
name: service-2048
spec:
ports:
- port: 80
targetPort: 80
protocol: TCP
selector:
app.kubernetes.io/name: app-2048
```
**Composants clés :**
+ Création d’un service NodePort
+ Mappage du port 80 vers le port 80 du conteneur
+ Utilisation d’un sélecteur d’étiquettes pour cibler les pods
Appliquez le service :
```
kubectl apply -f 03-service.yaml
```
## Étape 4 : configurer l’équilibrage de charge
Vous allez configurer un objet Ingress pour exposer l’application sur Internet.
Commencez par créer la `IngressClass`. Créez un fichier nommé `04-ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
labels:
app.kubernetes.io/name: LoadBalancerController
name: alb
spec:
controller: eks.amazonaws.com/alb
```
**Note**
Le mode automatique EKS nécessite l’ajout de balises sur les sous-réseaux afin d’identifier les sous-réseaux publics et privés.
Si vous avez créé votre cluster avec `eksctl`, ces balises sont déjà présentes.
Découvrez comment [Baliser les sous-réseaux pour le mode automatique EKS](tag-subnets-auto.md).
Créez ensuite la ressource Ingress. Créez un fichier nommé `05-ingress.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
namespace: game-2048
name: ingress-2048
annotations:
alb.ingress.kubernetes.io/scheme: internet-facing
alb.ingress.kubernetes.io/target-type: ip
spec:
ingressClassName: alb
rules:
- http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: service-2048
port:
number: 80
```
**Composants clés :**
+ Création d’un ALB orienté Internet
+ Utilisation du type de cible IP pour un routage direct vers les pods
+ Routage de tout le trafic (/) vers le service du jeu
Appliquez les configurations Ingress :
```
kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml
```
## Étape 5 : vérifier le déploiement
1. Vérifiez que tous les pods sont en cours d’exécution :
```
kubectl get pods -n game-2048
```
1. Vérifiez que le service a été créé :
```
kubectl get svc -n game-2048
```
1. Obtenez le point de terminaison de l’ALB :
```
kubectl get ingress -n game-2048
```
Le champ ADDRESS dans le résultat Ingress affiche le point de terminaison de votre ALB. Attendez 2 à 3 minutes pour que l’ALB soit entièrement provisionné et enregistre toutes les cibles.
## Étape 6 : accéder au jeu
Ouvrez votre navigateur web et accédez à l’URL du point de terminaison de l’ALB obtenue à l’étape précédente. L’interface du jeu 2048 devrait s’afficher.
## Étape 7 : nettoyage
Pour supprimer toutes les ressources créées dans ce tutoriel :
```
kubectl delete namespace game-2048
```
Cela supprimera toutes les ressources de l’espace de noms, y compris les ressources Déploiement, Service et Ingress.
## Ce qui se passe dans les coulisses
1. Le déploiement crée 5 pods exécutant le jeu 2048
1. Le service fournit un accès réseau stable à ces pods
1. Mode automatique EKS :
+ Crée un équilibreur de charge Application Load Balancer dans AWS
+ Configure les groupes cibles pour les pods
+ Définit les règles de routage pour transmettre le trafic au service
## Résolution des problèmes
Si le jeu ne se charge pas :
+ Assurez-vous que tous les pods sont en cours d’exécution : `kubectl get pods -n game-2048`
+ Vérifiez l’état de la ressource Ingress : `kubectl describe ingress -n game-2048`
+ Vérifiez la surveillance de l’état de l’ALB : consultez l’état du groupe cible dans la console AWS