Comment créer un cluster Kubernetes avec AWS CLI

Elastic Kubernetes Service (EKS) est un service Kubernetes géré qui est hébergé sur AWS.

La principale raison d’utiliser EKS est de supprimer la charge de la gestion des pods, des nœuds, etc. L’exécution de Kubernetes dans AWS nécessite actuellement une grande expertise technique et ne relève souvent pas de la timonerie de nombreuses organisations. Avec EKS, l’infrastructure requise est gérée par l’équipe « interne » d’Amazon, laissant aux utilisateurs un moteur Kubernetes entièrement géré qui peut être utilisé soit via une API, soit via l’outillage standard kubectl.

EKS prendra en charge toutes les fonctionnalités de Kubernetes, notamment les espaces de noms, les paramètres de sécurité, les quotas et tolérances de ressources, les stratégies de déploiement, les autoscalers et bien plus encore. EKS te permettra d’exécuter ton propre plan de contrôle, mais s’intègre aussi à AWS IAM pour que tu puisses maintenir ton propre contrôle d’accès à l’API.

EKS a été construit au-dessus de la solution « Kubernetes-as-a-Service » existante d’Amazon appelée Elastic Container Service for Kubernetes (EKS) est un service géré par AWS qui simplifie le déploiement, la gestion et l’exploitation des clusters Kubernetes dans le cloud AWS.

Si tu exécutes Kubernetes sur AWS, tu es responsable de la gestion du plan de contrôle (c’est-à-dire les nœuds maîtres et les nœuds ouvriers). Tu dois aussi t’assurer que le serveur api est hautement disponible et tolérant aux pannes, etc.

EKS t’a ôté la charge de gérer le plan de contrôle, ce qui te permet de te concentrer sur l’exécution de tes charges de travail Kubernetes. Il est le plus souvent utilisé pour les applications sans état comme les microservices puisque le plan de contrôle est géré par Amazon (EKS).

Dans ce guide, nous allons apprendre à créer un cluster Kubernetes sur AWS avec EKS. Tu apprendras comment créer un utilisateur administratif pour ton cluster Kubernetes. Tu apprendras aussi comment déployer une application sur le cluster. Enfin, tu testeras ton cluster pour t’assurer que tout fonctionne correctement.

C’est parti !

Conditions préalables

• Un compte AWS.
• Cet article part du principe que tu connais Kubernetes et AWS. Si ce n’est pas le cas, prends le temps de parcourir la documentation sur les deux avant de commencer ce guide.

Créer un utilisateur Admin avec des permissions

Commençons par créer un utilisateur administrateur pour ton cluster.

1. Connecte-toi à ta console AWS et va dans IAM. Clique sur Utilisateurs > Ajouter des utilisateurs.

2. Sur l’écran suivant, donne un nom d’utilisateur comme admin. SélectionneClé d’accès – Accès programmé. Clique sur Suivant: Permissions

3.Sur l’écran suivant, sélectionne Attacher directement les politiques existantes. Clique sur AdministratorAccess. Clique sur Suivant: Tags.

La politique AdministratorAccess est une politique intégrée à Amazon Elastic Container Service (ECS). Elle offre un accès complet à toutes les ressources ECS et à toutes les actions dans la console ECS. Le principal avantage de cette politique est que nous n’avons pas besoin de créer ou de gérer un utilisateur supplémentaire avec des privilèges supplémentaires pour accéder au service AWS EKS.

Ton utilisateur admin peut créer des instances EC2, des piles CloudFormation, des buckets S3, etc. Tu dois faire très attention à qui tu donnes ce genre d’accès.

3.Sur l’écran suivant, clique sur Suivant: Réviser

4.Sur l’écran suivant, clique sur Créer un utilisateur.

5. Sur l’écran suivant, tu obtiendras un message vert de réussite. L’ ID de la clé d’accès et leSecret
sont également affichés dans cet écran. Tu auras besoin de ces clés pour configurer tes outils CLI plus tard, alors note ces clés à un autre endroit.

Créer une Instance EC2

Maintenant que tu as créé l’utilisateur administratif , créons une instance EC2 à utiliser comme nœud maître Kubernetes.

1. Tape EC2 dans le champ de recherche. Clique sur le lien EC2. Clique surLancer l’instance.

2. Sélectionne l’ AMI (HVM) Amazon Linux 2 pour ton instance EC2. Nous utiliserons cette AMI Amazon Linux pour faciliter l’installation de Kubernetes et d’autres outils nécessaires plus tard, tels que : kubectl !, docker, etc.

3. Sur l’écran suivant, clique sur Suivant: Configurer les détails de l’instance.

3. Sur l’écran suivant, active l‘option Auto-assign Public IP. Comme le serveur se trouve dans un sous-réseau privé, il ne sera pas accessible de l’extérieur. Tu peux donner à tes serveurs des adresses IP publiques en associant une adresse IP Elastic à l’instance. En faisant cela, ton EC2 et ton ELK sont accessibles. Clique surSuivant: Stockage.

3. Sur l’écran suivant, clique sur Suivant : Ajouter des balises > Suivant : Configurer le groupe de sécurité.

4. Sur l’écran suivant, clique surRéviser et lancer>Lancer.

5. Une boîte de dialogue de paire de clés s’affiche. Clique sur Créer une nouvelle paire de clés. Donne-lui un nom, puis télécharge et stocke le fichier .pem dans un emplacement sécurisé. Clique sur Lancer l ‘instance.

Configurer les outils de la ligne de commande

Maintenant que tu as créé une instance EC2, tu dois installer le client correspondant. En termes d’AWS, un client est un outil en ligne de commande qui te permet de gérer les objets du cloud. Dans cette section, tu vas apprendre à configurer les outils de l’interface de ligne de commande (CLI).

1. Accède à ton tableau de bord EC2. Tu devrais voir ta nouvelle instance EC2 en cours d’exécution. Si ce n’est pas le cas, il se peut que ton instance fasse son premier démarrage, attends 5 minutes et réessaie. Une fois que ton instance est en cours d’exécution, clique sur Connecter.

2. Sur l’écran suivant, clique sur Connecter.

Tu seras dirigé vers une session SSH interactive sur ton navigateur. SSH te permet de te connecter et d’opérer en toute sécurité sur un serveur distant. La session SSH interactive nous permettra d’installer les outils de ligne de commande pour EKS et Kubernetes directement sur ton instance EC2.

Une fois que tu t’es connecté à la session SSH, la première chose à faire est de vérifier la version de ton aws-cli. Ceci afin de t’assurer que tu utilises la dernière version de l’AWS CLI. L’AWS CLI est utilisé pour configurer, gérer et travailler avec ton cluster.

Si ta version est périmée, tu risques de rencontrer des problèmes et des erreurs pendant le processus de création du cluster. Si ta version est inférieure à 2.0, tu dois la mettre à niveau.

3.exécute la commande suivante pour vérifier la version de ton CLI.

aws --version

Comme tu peux le voir dans la sortie ci-dessous, nous exécutons la version 1.18.147 de aws-cli, qui est très obsolète. Mettons le CLI à niveau vers la dernière version disponible, qui est v2+ au moment où nous écrivons ces lignes.

4. exécute la commande ci-dessous pour télécharger la dernière version disponible d’AWS CLI sur ton instance EC2. curl téléchargera ton fichier à partir de l’url donnée, -o le nommera comme tu le souhaites, et « awscli-exe-linux-x86_64.zip » est le fichier à télécharger

curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"

5.Une fois le téléchargement terminé, exécute la commande ci-dessous pour extraire le contenu de ton fichier téléchargé dans le répertoire actuel.

unzip awscliv2.zip

6. Ensuite, exécute la commande which aws pour définir ton lien avec la dernière version d’AWS CLI. Cette commande t’indiquera où le trouver dans le PATH de ton environnement, afin que tu puisses l’exécuter depuis n’importe quel répertoire.

which aws

Comme tu peux le voir dans la sortie ci-dessous, la version périmée d’AWS CLI se trouve dans /usr/bin/aws.

7. Tu dois maintenant configurer ton aws-cli en exécutant une commande de mise à jour avec certains paramètres. Le premier paramètre./aws/install nous aidera à installer AWS CLI dans le répertoire actuel. Le deuxième paramètre –bin-dir indique l’emplacement de l’AWS CLI dans le PATH de ton environnement, et le troisième paramètre –install-dir est un chemin relatif à bin-dir. Cette commande te permettra de t’assurer que tous tes chemins sont à jour.

sudo ./aws/install --bin-dir /usr/bin --install-dir /usr/bin/aws-cli --update

8. Relance la commande aws –version pour t’assurer que tu utilises la dernière version.

aws --version

Tu devrais voir la version d’AWS CLI actuellement installée. Comme tu peux le voir dans la sortie ci-dessous, nous utilisons maintenant la version 2.4.7 d’AWS CLI. Il s’agit de la dernière version et elle ne te posera aucun problème lors de la configuration des prochaines étapes.

9. Maintenant que ton environnement est correctement configuré, il est temps pour toi de configurer le compte AWS avec lequel tu veux communiquer via l’AWS CLI. Exécute la commande suivante pour répertorier les variables d’environnement de ton compte actuellement configurées avec l’alias que tu veux utiliser avec.

aws configure

Cela te montrera toutes les variables d’environnement de ton compte AWS qui sont actuellement configurées. Tu devrais voir quelque chose comme ça dans la sortie ci-dessous. Tu dois définir certains paramètres de configuration pour que l’AWS CLI puisse communiquer avec tes comptes nécessaires. Exécute la commande ci-dessous, qui te fera passer par un assistant de configuration pour configurer ton compte AWS.

• ID de la clé d’accès AWS [Aucun] : Saisis la clé d’accès AWS que tu as notée précédemment.
• Clé d’accès secrète AWS [Aucune] : Saisis la clé d’accès secrète AWS que tu as notée plus tôt.
• Tu dois également indiquer le nom de la région par défaut où se trouvera ton cluster EKS. Tu dois choisir une région AWS où se trouvera le cluster EKS que tu souhaites et qui est la plus proche de toi. Dans ce tutoriel, nous avons choisi us-east-1 en raison de sa situation géographique proche de nous et de sa facilité d’utilisation pour les prochaines étapes du tutoriel.
• Format de sortie par défaut [Aucun] : Entre json comme format de sortie par défaut car il nous sera très utile pour visualiser les fichiers de configuration plus tard.

Maintenant que tu as configuré tes outils AWS CLI. Il est temps de configurer l’outil CLI Kubernetes nommé kubectl dans ton environnement afin de pouvoir interagir avec ton cluster EKS.

Kubectl est l’interface de ligne de commande pour Kubernetes. Avec Kubectl, tu peux gérer les applications exécutées sur les clusters Kubernetes. Kubectl n’est pas installé par défaut sur les systèmes Linux et MacOS. Tu peux installer Kubectl sur d’autres systèmes en suivant les instructions du site Web de Kubernetes.

10. Exécute la commande ci-dessous pour télécharger le binaire kubectl. Un binaire est un fichier informatique portant l’extension « .bin », qui n’est exécutable que sur certains types d’ordinateurs. C’est un moyen facile pour des types d’ordinateurs disparates de partager des fichiers. Nous utilisons le binaire kubectl car il est agnostique par rapport aux plateformes. Il fonctionnera sur tout système capable d’exécuter un système d’exploitation de type Unix, y compris Linux et Mac OS.

curl -o kubectl https://amazon-eks.s3.us-west-2.amazonaws.com/1.16.8/2020-04-16/bin/linux/amd64/kubectl

11. Exécute la commande chmod ci-dessous pour rendre le binaire kubectl exécutable. La commande chmod est une commande Unix et Linux utilisée pour modifier les autorisations d’accès aux fichiers ou aux répertoires. La commande chmod de Linux utilise le système de chiffres octaux pour spécifier les permissions pour chaque utilisateur. Kubectl peut maintenant être utilisé sur ta machine locale.

chmod +x ./kubectl

12. Exécute la commande ci-dessous pour créer un répertoire kubectl dans ton dossier $HOME/bin et y copier le binaire kubectl. La commande mkdir -p $HOME/bin crée un sous-répertoire bin dans ton répertoire personnel. La commande mkdir est utilisée pour créer de nouveaux répertoires ou dossiers. L’option -p indique à la commande mkdir de créer automatiquement tous les répertoires parents nécessaires pour le nouveau répertoire. Le $HOME/bin est une variable d’environnement qui stocke le chemin de ton répertoire personnel. Chaque utilisateur de Linux a le répertoire $HOME/bin dans son système de fichiers. La construction && est appelée opérateur logique AND. Elle est utilisée pour regrouper des commandes afin que plusieurs d’entre elles puissent être exécutées en même temps. Le construct && n’est pas nécessaire pour que cette commande fonctionne, mais il est là en tant que meilleure pratique.

La commande cp ./kubectl $HOME/bin/kubectl copie le fichier binaire kubectl local dans ton répertoire kubectl et renomme le fichier en kubectl. Enfin, la commande export fait ce qu’elle dit – elle exporte une variable d’environnement dans la mémoire du shell afin qu’elle puisse être utilisée par tout programme exécuté à partir de ce shell. Dans notre cas, nous devons indiquer à kubectl où se trouve notre répertoire kubectl pour qu’il puisse trouver le binaire kubectl.

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

13. Exécute la commande kubectl version ci-dessous pour vérifier que kubectl est installé correctement. La commande kubectl version –short –client produit une version abrégée de la version de kubectl dans une réponse à l’API REST de Kubernetes bien formatée et lisible par l’homme. L’option –client permet à kubectl d’imprimer la version formatée de la réponse à l’API REST de Kubernetes, qui est cohérente d’une version à l’autre.

L’option –short indique à kubectl de fournir les informations de base sous une forme compacte avec une décimale pour les flottants et un format d’heure abrégé qui est le même que –format. Tu devrais voir une sortie comme celle ci-dessous. Cette sortie nous indique que nous avons installé kubectl avec succès et qu’il utilise la bonne version.

La dernière chose que tu dois faire dans cette section est de configurer l’outil eksctl cli pour utiliser ton cluster Amazon EKS. L’outil eksctl cli est une interface en ligne de commande qui permet de gérer les clusters Amazon EKS. Il peut générer des identifiants de cluster, mettre à jour les spécifications du cluster, créer ou supprimer des nœuds de travail et effectuer de nombreuses autres tâches.

14. Exécute les commandes suivantes pour installer l’outil eksctl cli et vérifier sa version.

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

eksctl version

Provisionner un cluster EKS

Maintenant que tu as ton EC2 et les outils AWS CLI, tu peux provisionner ton premier cluster EKS.

1. Exécute la commande eksctl create cluster ci-dessous pour provisionner un cluster nommé dev dans la région us-east-1 avec un nœud maître et trois nœuds centraux.

eksctl create cluster --name dev --version 1.21 --region us-east-1 --nodegroup-name standard-workers --node-type t3.micro --nodes 3 --nodes-min 1 --nodes-max 4 --managed

La commande eksctl create cluster crée un cluster EKS dans la région us-east-1 en utilisant les valeurs par défaut recommandées par Amazon pour cette configuration spécifique et transmet tous les arguments entre guillemets (  » ) ou comme variables ( ${ } ) en conséquence.

Le paramètre name est utilisé pour définir le nom de ce cluster EKS et il s’agit simplement d’une étiquette amicale pour ta commodité. version est la version que tu veux que le cluster utilise, pour cet exemple, nous nous en tiendrons à Kubernetes v1.21.2 mais n’hésite pas à explorer d’autres options également.

nodegroup-name est le nom d’un groupe de nœuds que ce cluster doit utiliser pour gérer les nœuds de travailleurs. Dans cet exemple, tu vas rester simple et utiliser les travailleurs standard, ce qui signifie que tes nœuds de travailleurs auront un vCPU et 3 Go de mémoire par défaut.

nodes est le nombre total de nœuds travailleurs de base que tu veux dans ton cluster. Dans cet exemple, trois nœuds sont demandés. nodes-min et nodes-max contrôlent le nombre minimum et maximum de nœuds autorisés dans ton cluster. Dans cet exemple, au moins un mais pas plus de quatre nœuds de travailleur seront créés.

2. Tu peux naviguer dans ta console CloudFormation pour surveiller la progression du provisionnement.

Comme indiqué ci-dessous, tu peux voir que ta pile dev est en cours de création.

3. Clique sur l’hyperlien de la pile de dév. > Événement. Tu verras une liste d’événements liés au processus de création. Attends que le processus de provisionnement soit terminé – cela peut prendre jusqu’à 15 minutes en fonction de tes circonstances spécifiques – et vérifie l’état de la pile dans la console CloudFormation.

4. Après avoir attendu que la pile termine le provisionnement, navigue dans ta console CloudFormation, tu verras que le statut de ta pile dev est CREATE_COMPLETE.

Maintenant, navigue dans ta console EC2. Tu verras un nœud maître et trois nœuds principaux dans le tableau de bord EC2. Cette sortie confirme que tu as bien configuré le cluster EKS.

5. Exécute la commande eksctl ci-dessous pour obtenir les détails du cluster dev, comme le cluster-ID et la région.

eksctl get cluster

6. Exécute la commande aws eks update ci-dessous pour obtenir les informations d’identification du nœud de travailleur distant. Cette commande doit être exécutée sur tout ordinateur que tu veux connecter au cluster. Elle télécharge les informations d’identification pour ton kubectl afin d’accéder au cluster Kubernetes d’EKS à distance, sans utiliser les clés d’accès AWS Access.

aws eks update-kubeconfig --name dev --region us-east-1

Déploiement de ton application sur le cluster EKS

Maintenant que tu as provisionné ton Cluster EKS. Déployons ta première application sur ton Cluster EKS. Dans cette section, tu vas apprendre à déployer un serveur Web nginx avec un équilibreur de charge comme exemple d’application.

1. Exécute la commande ci-dessous pour installer git sur ton système. Tu auras besoin de git pour cloner le code du serveur Web nginx depuis GitHub.

sudo yum install -y git 

2. Exécute la commande git clone ci-dessous pour cloner le code du serveur Web nginx de github dans ton répertoire actuel.

git clone https://github.com/ata-aws-iam/htf-elk.git

3. Exécute la commande cd htf-elk pour changer le répertoire de travail en répertoire des fichiers de configuration de nginx.

cd htf-elk

4. Exécute la commande ls pour répertorier les fichiers dans le répertoire actuel.

ls

Tu verras que les fichiers suivants sont présents dans ton répertoire nginx.

5. Exécute la commande cat ci-dessous pour ouvrir le fichier nginx-deployment.yaml et tu verras le contenu suivant présent dans ce fichier.

cat nginx-deployment.yaml

• apiVersion : apps/v1 est l’API de base de Kubernetes
• kind : Deployment est le type de ressource qui sera créé pour ce fichier. Dans un Deployment, un Pod est créé par conteneur.
• metadata : spécifie les valeurs de métadonnées à utiliser lors de la création d’un objet
• name : nginx-deployment est le nom ou l’étiquette de ce déploiement. S’il n’a pas de valeur, le nom du déploiement est tiré du nom du répertoire.
• labels : fournit des étiquettes pour l’application. Dans ce cas, elle sera utilisée pour le routage des services via Elastic Load Balancing (ELB)
• env : dev décrit une variable d’environnement qui est définie par une valeur de chaîne. C’est ainsi que tu peux fournir des données de configuration dynamiques à ton conteneur.
• spec : c’est là que tu définis le nombre de répliques à créer. Tu peux spécifier les propriétés sur lesquelles tu veux que chaque réplique soit basée.
• répliques : 3 va créer trois répliques de ce pod sur ton cluster. Ils seront distribués sur les nœuds de travail disponibles qui correspondent au sélecteur d’étiquette .
• containerPort : 80 mappera un port du conteneur à un port de l’hôte. Dans ce cas, il mappera le port 80 du conteneur au port 30000 de ta machine locale.

6.exécute la commande cat ci-dessous pour ouvrir le fichier de service nginx-svc.yaml. Tu verras le contenu suivant présent dans ce fichier.

cat nginx-svc.yaml

7. Exécute la commande kubectl apply ci-dessous pour créer le service nginx dans ton Cluster Kubernetes. Il faudra quelques minutes pour que le cluster EKS provisionne ELB pour ce service.

kubectl apply -f ./nginx-svc.yaml

8. Exécute la commande kubectl get service ci-dessous pour obtenir les détails sur le service nginx que tu viens de créer.

kubectl get service

Tu obtiendras la sortie suivante. ClusterIP est l’IP interne de kubernetes attribuée à ce service. Le nom LoadBalancer ELB est un identifiant unique pour ce service. Il créera automatiquement un ELB sur AWS et fournira un point de terminaison public pour ce service qui pourra être atteint par les services de ton choix, comme un navigateur Web (nom de domaine) ou des clients API. Il est accessible par une adresse IP de ton choix.

L’équilibreur de charge ELB avec le nom a6f8c3cf0fe3a468d8828db6059ef05e-953361268.us-east-1.elb.amazonaws.com a le port 32406, qui sera mappé au port 80 du conteneur. Note le nom d’hôte DNS de l’équilibreur de charge ELB dans la sortie ; tu en auras besoin pour accéder au service plus tard.

9. Exécute la commande kubectl apply ci-dessous pour appliquer le déploiement pour ton cluster.

kubectl apply -f ./nginx-deployment.yaml

10. Exécute la commande kubectl get deployment pour obtenir les détails sur le déploiement nginx que tu viens de créer.

kubectl get deployment

11. Exécute la commande ci-dessous pour accéder à ton application nginx via l’équilibreur de charge. Tu verras la page de bienvenue de nginx dans ton terminal/console, ce qui confirme que ton application nginx fonctionne comme prévu. Remplace <LOAD_BALANCER_DNS_HOSTNAME>par le nom d’hôte DNS de l’équilibreur de charge que tu as noté ci-dessus.

curl "<LOAD_BALANCER_DNS_HOSTNAME>"

12. Tu peux aussi accéder à ton application nginx via le navigateur en copiant et collant le nom d’hôte DNS de l’équilibreur de charge dans le navigateur.

Vérification de la fonctionnalité Highly Available(HA) pour ton cluster

Maintenant que tu as créé ton cluster avec succès, tu peux tester la fonctionnalité HA pour vérifier qu’elle fonctionne comme prévu.

Kubernetes prend en charge les déploiements multi-nœuds grâce à l’utilisation de contrôleurs spéciaux qui travaillent en tandem pour créer et gérer des pods ou des services répliqués. Certains de ces contrôleurs sont les Déploiements, ReplicationController, Job et DaemonSet.

Un contrôleur de déploiement est utilisé pour contrôler la réplication au niveau du pod ou du service. Lorsque ton pod n’a plus de ressources, il supprime tous les pods de ce contrôleur de réplication (sauf celui qui fonctionne sur le nœud maître) et crée de nouvelles répliques de ce pod. Cela t’aidera à obtenir un temps de disponibilité très élevé pour tes applications.

1.navigue dans ton tableau de bord EC2 et arrête les trois nœuds de travail.

2. Exécute la commande ci-dessous pour vérifier le statut de tes pods. Tu obtiendras différents statuts : Terminating, Running, et Pending pour tous tes pods. Parce qu’une fois que tu auras arrêté tous les nœuds ouvriers, EKS essaiera de redémarrer tous les nœuds ouvriers et les pods à nouveau. Tu peux aussi voir quelques nouveaux nœuds, que tu peux identifier par leur âge(50 ans).

kubectl get pod

Il faut un certain temps pour démarrer la nouvelle instance EC2 et les pods. Une fois que tous les nœuds ouvriers sont démarrés, tu verras que toutes les nouvelles instances EC2 reviennent au statut Running.

3. Lance à nouveau leservice kubectl get. Tu peux voir que l’ESK créera un nouveau service nginx et un nouveau nom DNS pour ton équilibreur de charge.

kubectl get service 

Copie et colle le nouveauDNS dans ton navigateur. Tu obtiendras à nouveau l’accueil de la page Nginx. Cette sortie confirme que ton HA fonctionne comme prévu.

Conclusion

Dans cet article, tu as appris à configurer ton cluster EKS. Tu as également vérifié que la fonctionnalité Highly Available fonctionne en arrêtant tous tes nœuds de travail et en vérifiant l’état de tes pods. Tu devrais maintenant être capable de créer et de gérer des clusters EKS à l’aide de kubectl.