Dans ce tutoriel Prérequis Configuration du cluster Créez IngressClass Déployez l'exemple d'application de jeu 2048 Persister les données à l'aide du mode automatique d'Amazon EKS Supprimer votre cluster et vos nœuds

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.

Vous souhaitez contribuer à ce guide de l'utilisateur ? Choisissez le GitHub lien Modifier cette page sur qui se trouve dans le volet droit de chaque page. Vos contributions aideront à améliorer notre guide de l'utilisateur pour tout le monde.

Démarrage rapide : déploiement d'une application Web et stockage des données

Déployer une application de jeu et conserver ses données sur Amazon EKS

Ce didacticiel de démarrage rapide 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 de eksctl. Le mode automatique Amazon EKS automatise les tâches de routine relatives au stockage par blocs en cluster, à la mise en réseau, à l'équilibrage de charge et au dimensionnement automatique du calcul.

Au fur et à mesure de notre progression, nous vous expliquerons le processus de configuration du cluster. Amazon EKS Auto Mode automatisera les tâches de création d'un nœud à l'aide d'une instance EC2 gérée, de création d'un équilibreur de charge d'application et de création d'un volume EBS.

Dans l'ensemble, vous déploierez un exemple de charge de travail avec les annotations personnalisées requises pour une intégration complète aux AWS services.

Dans ce tutoriel

À l'aide du modèle de eksctl cluster ci-dessous, vous allez créer un cluster avec le mode automatique EKS pour le provisionnement automatique des nœuds.

Configuration du 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 du réseau, en plus de créer des points de terminaison publics et privés.

Le mode automatique de gestion des instances 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 configurer dynamiquement un Application Load Balancer (ALB).

Prérequis

Avant de commencer, assurez-vous que les conditions préalables suivantes sont configurées pour utiliser Amazon EKS :

Configuration de la AWS CLI et configuration des informations d'identification
Installer eksctl
Installer kubectl

Pour de plus amples informations, veuillez consulter Configuration pour utiliser Amazon EKS.

Configuration du 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 cluster-config.yaml fichier et collez-y le contenu suivant. Remplacez region-code par une région valide, telle que us-east-1 :


apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: web-quickstart
  region: <region-code>

autoModeConfig:
  enabled: true

Nous sommes maintenant prêts à créer le cluster.

Créez le cluster Amazon EKS :


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 un Kubernetes IngressClass 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 ingressclass.yaml le nom :


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éployez l'exemple d'application de jeu 2048

Dans cette section, nous vous expliquons les étapes à suivre pour déployer le célèbre « jeu 2048 » en tant qu'exemple d'application au sein du cluster. Le manifeste fourni inclut des annotations personnalisées pour l'Application Load Balancer (ALB). Ces annotations s'intègrent à l'EKS et indiquent à celui-ci de gérer le trafic HTTP entrant comme « orienté vers Internet » et de l'acheminer vers le service approprié dans l'espace de noms « game-2048 » en utilisant le type de cible « ip ».

Créez un espace de noms Kubernetes appelé game-2048 avec le drapeau. --save-config
```
kubectl create namespace game-2048 --save-config
```
Le résultat de la réponse devrait être le suivant :
```
namespace/game-2048 created
```
Déployez l'application 2048 Game Sample.
```
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 définit un déploiement, un service et une entrée Kubernetes pour l'espace de game-2048 noms, créant ainsi les ressources nécessaires pour déployer et exposer l'application au sein du game-2048 cluster. Cela inclut la création d'un service nommé service-2048 qui expose le déploiement sur le port80, et d'une ressource d'entrée 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
```
Exécutez la commande suivante pour obtenir la ressource Ingress pour l'espace de game-2048 noms.
```
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 attendre plusieurs minutes le temps que l'Application Load Balancer (ALB) soit provisionné avant de commencer les étapes suivantes.
Ouvrez un navigateur Web et entrez le code 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
```
Vous devriez voir le jeu 2048 dans votre navigateur. Jouez !

Persister les données à l'aide du mode automatique d'Amazon EKS

Maintenant que le jeu 2048 est opérationnel sur votre cluster Amazon EKS, il est temps de vous assurer que vos données de jeu sont conservées en toute sécurité grâce à la fonctionnalité de stockage par blocs du mode automatique d'Amazon EKS.

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"

Appliquez le StorageClass :
```
kubectl apply -f storage-class.yaml
```

Créez une réclamation de volume persistante (PVC) pour demander le stockage de vos données de 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

Appliquez le PVC sur votre cluster :
```
kubectl apply -f ebs-pvc.yaml
```
Le résultat de la réponse devrait être le suivant :
```
persistentvolumeclaim/game-data-pvc created
```

Vous devez maintenant mettre à jour le déploiement de votre jeu 2048 pour utiliser ce PVC pour stocker des données. Le déploiement suivant est configuré pour utiliser le PVC pour stocker les données de 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

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 grâce à la capacité de stockage par blocs d'Amazon EKS Auto Mode. Cela garantit la sécurité de votre progression et de vos données dans le jeu, même en cas de défaillance d'un pod ou d'un nœud.

Si vous avez aimé ce didacticiel, faites-le nous savoir en nous faisant part de vos commentaires afin que nous puissions vous proposer d'autres didacticiels de démarrage rapide spécifiques à des cas d'utilisation, comme celui-ci.

Supprimer votre cluster et vos nœuds

Une fois que vous avez terminé d'utiliser le cluster que vous avez créé pour ce didacticiel, vous devez le nettoyer en le supprimant à l'aide de la commande suivante. Si vous souhaitez utiliser davantage ce cluster avant de le nettoyer, reportez-vous à la section Étapes suivantes.


eksctl delete cluster -f ./cluster-config.yaml

EKS nettoie automatiquement tous les nœuds qu'il a provisionnés lorsque le cluster est supprimé.

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

Configurer kubectl et eksctl

Découvrez Amazon EKS