De la Conteneurisation à

l’Orchestration avec kubernetes

Optimiser le développement et le déploiement de vos

applications
Plan
Technologie des conteneurs

Historique des conteneurs

De la virtualisation à la conteneurisation
Introduction à Docker
Cycle de vie d'une image, de sa création à sa suppression
Cycle de vie d'un conteneur avec les commandes du client Docker
La création d’images
Démarrage des conteneurs
Docker CLI
Les types de réseau
Les volumes
Docker compose
Présentation de Amazon ECS (Amazon Elastic Container Service)

Travaux Pratiques
Orchestration des conteneurs avec Kubernetes

Motivation et utilisation d’un orchestrateur

Origine et introduction de Kubernetes
Bénéfices de Kubernetes
Architecture de Kubernetes
Principaux objets de base – Deployment, Pods, Services, ConfigMap, Secret, Volumes, Namespaces
Bonne Pratiques et Sécurité
Plan

Les outils pour créer des clusters kubernetes

➔ Kubeadm
➔ Google Kubernetes Engine (GKE)
➔ Amazon Elastic Kubernetes Service (Amazon EKS)
➔ Service Azure Kubernetes (AKS)
➔ VMware TKG (VMware Tanzu Kubernetes Grid)
➔ Kops
➔ Kubespray

Présentation détaillée de Amazon EKS (Amazon Elastic Kubernetes Service)

Travaux Pratiques
Technologie des conteneurs
Historique des conteneurs

Les conteneurs logiciels, également connus sous le nom de conteneurs d'application ou de conteneurs virtuels,
sont une technologie de virtualisation qui permet aux développeurs de packager des applications et leurs
dépendances en un seul paquet portable qui peut être exécuté sur n'importe quelle machine ou plateforme
prenant en charge les conteneurs.

L'histoire des conteneurs logiciels remonte au début des années 2000, lorsque des développeurs ont
commencé à utiliser des technologies de virtualisation pour isoler les applications et les environnements de
développement les uns des autres. Au fil du temps, cette pratique est devenue plus sophistiquée, avec
l'avènement des technologies telles que Solaris Containers, qui ont permis aux développeurs de créer des
conteneurs légers et portables.

Cependant, la véritable percée des conteneurs est survenue en 2013, avec l'introduction de Docker, une
plateforme de conteneurisation open-source qui a simplifié la création, la distribution et la gestion de
conteneurs. Docker a introduit un format de conteneur standardisé, qui a été adopté par de nombreux
développeurs et entreprises, et a rapidement gagné en popularité en raison de sa facilité d'utilisation et de sa
compatibilité avec une grande variété d'environnements de déploiement.

Depuis lors, de nombreuses autres plateformes de conteneurisation ont émergé, telles que rkt, une alternative
open-source à Docker. Les conteneurs sont désormais largement utilisés dans les environnements de
développement, de test et de production, offrant une plus grande flexibilité et une meilleure portabilité des
applications pour les développeurs et les opérateurs.
De la virtualisation à la conteneurisation

● une machine virtuelle

Lorsque vous utilisez une machine virtuelle (VM), vous faites ce qu’on appelle de la virtualisation
lourde. En effet, vous recréez un système complet dans le système hôte, pour qu’il ait ses propres
ressources.

L'isolation avec le système hôte est donc totale ; cependant, cela apporte plusieurs contraintes :

❌ Une machine virtuelle prend du temps à démarrer ;

❌ Une machine virtuelle réserve les ressources (CPU/RAM) sur le système hôte.

Mais il arrive très souvent que l'application qu'elle fait tourner ne consomme pas l'ensemble des
ressources disponibles sur la machine virtuelle. Ainsi est né un nouveau système de virtualisation plus
léger : les conteneurs.

● Un conteneur

Un conteneur Linux est un processus ou un ensemble de processus isolés du reste du système, tout en
étant légers.

Le conteneur permet de faire de la virtualisation légère, c'est-à-dire qu'il ne virtualise pas les
ressources, il ne crée qu'une isolation des processus. Le conteneur partage donc les ressources avec le
système hôte.
Les conteneurs, au sens d'OpenVZ et LXC, apportent une isolation importante des processus systèmes ;
cependant, les ressources CPU, RAM et disque sont totalement partagées avec l'ensemble du système.
Introduction à Docker

Docker est une plateforme logicielle qui permet de créer, de déployer et de gérer des applications dans des
conteneurs logiciels. Les conteneurs Docker sont des environnements isolés et légers qui contiennent tout le
nécessaire pour exécuter une application, y compris le code, les dépendances et les bibliothèques.

Les avantages de l'utilisation de Docker sont nombreux. Tout d'abord, il permet de créer des environnements
de développement et de production identiques, ce qui facilite la mise en production des applications. Ensuite,
les conteneurs Docker sont portables, ce qui signifie qu'ils peuvent être exécutés sur n'importe quel système
d'exploitation et sur n'importe quelle plateforme de cloud. Enfin, Docker permet de faciliter la gestion des
applications en automatisant certaines tâches telles que la création, la mise à jour et la suppression de
conteneurs.

Pour utiliser Docker, il faut d'abord installer le logiciel Docker sur son ordinateur. Ensuite, on peut créer une
image Docker en écrivant un Dockerfile, qui contient les instructions pour construire l'image. Une fois que
l'image est créée, on peut lancer un conteneur en utilisant cette image.

Il est également possible de publier des images Docker sur des registres publics ou privés, tels que Docker
Hub, pour faciliter le partage et la collaboration entre développeurs.

En résumé, Docker est une technologie essentielle pour les développeurs et les ingénieurs en informatique qui
cherchent à créer, à déployer et à gérer des applications de manière efficace et portable.
Cycle de vie d'une image, de sa création à sa suppression

Avec Docker, on part d'un fichier Dockerfile pour construire une image de conteneur. Cette image
servira à démarrer des conteneurs qui utiliseront le contenu de cette image.
Voici un schéma illustrant le cycle de vie d'un conteneur avec les commandes du client Docker :
La création d’images
La première chose que vous devez faire est de créer un fichier nommé "Dockerfile". Le fichier Dockerfile décrit
comment une image est construite. La commande docker build construit une image à partir de ce fichier
Dockerfile.

Voici la syntaxe du Dockerfile pour décrire l'image et la manière dont elle est créée :

MAINTAINER <name>
Auteur de l'image
FROM <image>
nom de l'image de base existante qui sert de base à l'image à créer afin de ne pas partir de rient de tout mais
du contenu d'une image existante pour une image fonctionnant sur Ubuntu, l'image de base peut être
Ubuntu
ENV <key> <value>
Définir une variable d'environnement
ADD <src> <dest>
Ajouter un fichier local dans l'image
VOLUME ["/<dir>"]
Répertoire monté au démarrage du conteneur qui est externe au conteneur.
Ceci permet de conserver les fichiers après arrêt du conteneur
USER <user>
Indique l'utilisateur Linux utilisé lors du démarrage du conteneur
EXPOSE <port>
Indique le port réseau exposé par le conteneur
Ceci est utilisé pour définir sur quels ports réseau communiquent les conteneurs entre eux ou vers l'extérieur
de la machine hôte de Docker
RUN <command>

RUN ["executable", "param1", "param2"]

Exécute la commande sur l'image

CMD <command>
CMD ["executable", "param1", "param2"]

Il ne doit y avoir qu'un seul CMD dans le fichier Dockerfile

Il s'agit de la commande qui est lancée à chaque démarrage d'un conteneur basé sur cette image : par
exemple, si l'image contient le serveur Tomcat, il peut s'agir de lancer l'exécution du serveur Tomcat au
démarrage du conteneur.

La commande n'est lancée qu'à l'exécution du conteneur et non durant la construction de l'image
Cette commande peut être redéfinie dans la commande de lancement du conteneur.
Voici un exemple simple de fichier Dockerfile :

FROM debian:9

RUN apt-get update -yq \

&& apt-get install curl gnupg -yq \
&& curl -sL https://deb.nodesource.com/setup_10.x | bash \
&& apt-get install nodejs -yq \
&& apt-get clean -y

ADD . /app/
WORKDIR /app
RUN npm install

EXPOSE 2368
VOLUME /app/logs

CMD npm run start

Lancer la commande de création de l'image en indiquant le répertoire contenant le fichier Dockerfile

$ docker build -t node-app:0.1 .

Démarrage des conteneurs

Lancer la commande suivante pour démarrer un conteneur à partir d’une image crée :

$ docker run <nom_de_l’image> ou docker run <identifiant>

$ docker container run -d --name <container_name> -p extport:intport <nom_de_l’image> ou

$ docker container run -d --name <container_name> -p extport:intport <identifiant>
Docker CLI

Suivre les logs d’un conteneur spécifique

$ docker container logs -f [container-name|container-id]

Lister les conteneurs actifs (en cours d’exécution)

$ docker container ps

Lister tous les conteneurs

$ docker container ps -a

Arrêter un conteneur
$ docker container stop [container-name|container-id]

Supprimer un conteneur
$ docker container rm [container-name|container-id]

Forcer l’arrêt et la suppression d’un conteneur

$ docker container rm -f [container-name|container-id]

Supprimer tous les conteneurs

$ docker container rm -f $(docker ps-aq)

Supprimer tous les conteneurs arrêtés

$ docker container rm $(docker ps -q -f “status=exited”)

Exécuter un nouveau processus dans un conteneur existant

$ docker container exec -it [container-name|container-id] bash
Construire une image en utilisant un Dockerfile :
#Construire une image
$ docker image build -t <image-name>[:tag] <dockerfile-path>
#Construire une image appelée myimage en utilisant le Dockerfile situé dans le même dossier
$ docker image build -t myimage:latest .

Vérifier l’historique d’une image

# Vérifier l’historique d’une image
$ docker image history <image-name>[:tag]

Lister les images:

$ docker images

Supprimer une image du local registry:

$ docker rmi <image-name>[:tag]

Tagger une image:

# Créer une nouvelle image avec le dernier tag

$ docker image tag <image-name> <new-image-name>
Les types de réseau

Sous Docker il existe trois types de réseaux par défaut :

Bridge

Par défaut, Docker attache les containers au réseau « bridge » qui a été créé à l’installation de Docker.
Il s’agit donc d’un pont qu’on retrouve côté machine hôte, côté Docker et côté conteneur.
Les hôtes dans ce type de réseau sont attachés à un commutateur virtuel (dockerX) et sont NATés de sorte
qu’ils sont dans un réseau IP isolé et joignable de l’extérieur en exposant un port.

None

Dans ce cas, le conteneur n’est pas attaché au réseau, il n’a pas d’autre adresse IP que localhost/127.0.0.1.

Host

Le conteneur est dans ce cas directement lié à la carte réseau de l’hôte. Il ne faut jamais utiliser ce genre de
configuration en production car il n’y a pas d’isolation réseau.
Les volumes

Dans Docker, les volumes sont un moyen de stocker des données de manière persistante, même lorsque les
conteneurs qui les utilisent sont supprimés ou redémarrés. Les volumes permettent également de partager
des données entre plusieurs conteneurs.
Pour créer un volume dans Docker, vous pouvez utiliser la commande docker volume create suivie du nom du
volume que vous souhaitez créer. Par exemple :

$ docker volume create mon-volume

Vous pouvez également créer un volume en même temps que vous démarrez un conteneur en utilisant
l'option -v suivi du nom du volume et du chemin d'accès à monter dans le conteneur. Par exemple :

$ docker container run -d --name mon-conteneur -v mon-volume:/app/data mon-image

Dans cet exemple, le conteneur mon-conteneur utilise le volume mon-volume et monte le dossier /app/data
dans le conteneur.

Pour lister tous les volumes existants, vous pouvez utiliser la commande docker volume ls. Pour supprimer un
volume, vous pouvez utiliser la commande docker volume rm suivie du nom du volume que vous souhaitez
supprimer. Par exemple :

$ docker volume rm mon-volume

Il est important de noter que les données stockées dans un volume sont persistantes, même si le conteneur
qui les utilise est supprimé. Cependant, si vous supprimez un volume, toutes les données qu'il contient seront
également supprimées.
Docker compose

Docker Compose est un outil open-source qui permet de définir et d'exécuter des applications
multi-conteneurs Docker. Il permet de décrire une application à l'aide d'un fichier YAML et de l'exécuter avec
une seule commande. Le fichier YAML contient des informations sur les conteneurs qui composent
l'application, leurs configurations, leurs dépendances et la manière dont ils doivent être connectés entre eux.

Avec Docker Compose, vous pouvez facilement créer des applications complexes à partir de plusieurs
conteneurs Docker. Cela peut inclure des bases de données, des serveurs Web, des caches et d'autres services.
Docker Compose peut également aider à gérer l'échelle et la mise à jour des conteneurs.

En utilisant Docker Compose, vous pouvez :

➔ Créer et lancer des conteneurs Docker avec des configurations personnalisées.

➔ Gérer plusieurs conteneurs en même temps.
➔ Définir des liens et des dépendances entre les conteneurs.
➔ Configurer les variables d'environnement pour les conteneurs.
➔ Mettre à jour et redéployer les conteneurs.
Exemple :

version: '3'
services:
db:
image: mysql:5.7
volumes:
- db_data:/var/lib/mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress

wordpress:
depends_on:
- db
image: wordpress:latest
ports:
- "8000:80"
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
WORDPRESS_DB_NAME: wordpress

volumes:
db_data: {}
Présentation de Amazon ECS (Amazon Elastic Container Service)
https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html

Présentation d'Amazon ECS

Amazon ECS est un service d'orchestration de conteneurs entièrement géré qui vous permet de déployer, de gérer et de
mettre à l'échelle en toute simplicité les applications conteneurisées. Il s'intègre parfaitement à l'environnement AWS
pour fournir une solution facile à utiliser pour exécuter des charges de travail liées à des conteneurs dans le cloud et sur
site, avec des fonctionnalités de sécurité avancées utilisant Amazon ECS Anywhere.

Fonctionnalités d'Amazon ECS

Intégré et sans serveur par défaut avec AWS Fargate : AWS Fargate est intégré à Amazon ECS, ce qui signifie que vous
n’avez plus à vous soucier de la gestion des serveurs, de la gestion de la planification de la capacité ou de savoir comment
isoler les charges de travail de conteneur pour assurer la sécurité.

Déploiements hybrides : Avec Amazon ECS Anywhere, vous pouvez utiliser les mêmes consoles Amazon ECS et outils
d’opérateur que vous connaissez déjà pour gérer les charges de travail de conteneur sur site afin de garantir une
expérience homogène dans vos applications basées sur des conteneurs.

Sécurité et isolation dans la conception : Amazon ECS est intégré de manière native aux outils de sécurité, d’identité
ainsi que de gestion et de gouvernance dans lesquels vous avez déjà confiance, ce qui vous permet de passer
rapidement et avec succès à la production.

Support conforme aux normes du secteur : Amazon ECS prend en charge Docker et vous permet d'exécuter et de
gérer des conteneurs Docker. Il est même intégré à la CLI Docker Compose, pour que vous puissiez définir et exécuter
des applications multi-conteneurs.
Travaux Pratiques

● Installation de Docker
● Construire et déployer une application avec Docker
● Déployer une application stateful avec Docker-compose
● Déployer une application sur Amazon ECS
Orchestration des conteneurs
avec Kubernetes
Motivation et utilisation d’un orchestrateur

Tout d’abord, un orchestrateur de conteneur Docker est un outil de gestion qui facilite le déploiement, la mise
à l'échelle, la gestion et la coordination des conteneurs Docker dans un environnement de production.

La principale motivation pour l'utilisation d'un orchestrateur de conteneurs Docker est la nécessité de gérer et
de coordonner efficacement les conteneurs dans un environnement de production. Sans orchestrateur, la
gestion des conteneurs devient fastidieuse, car il est nécessaire de suivre manuellement chaque conteneur et
de s'assurer que chacun fonctionne correctement.

Les orchestrateurs de conteneurs Docker offrent plusieurs d'avantages, notamment:

Facilitation de déploiement : Les orchestrateurs de conteneurs Docker facilitent grandement le déploiement

des applications dans un environnement de production. Avec un orchestrateur, il suffit de définir les
configurations des conteneurs et de les déployer automatiquement sur un cluster de serveurs.

Évolutivité: Mise à l'échelle des applications en ajoutant ou en supprimant des conteneurs en fonction de la
demande.

Haute disponibilité: Haute disponibilité en redémarrant automatiquement les conteneurs en cas d'échec.

Gestion des services: Gestion efficace des services en fournissant des outils pour surveiller et gérer les services.

Sécurité: Fonctionnalités de sécurité intégrées pour la protection des applications contre les menaces
potentielles.
Origine et introduction de Kubernetes

Kubernetes (aussi connu sous le nom de K8s) est un système open source de gestion d'orchestration de
conteneurs, développé à l'origine par Google. Le projet a été lancé en 2014 sous le nom de "Project Seven of
Nine" avant d'être rebaptisé Kubernetes.

L’objectif de Kubernetes est d’automatiser le déploiement, la mise à l'échelle et la gestion d'applications

conteneurisées.

Kubernetes fournit un ensemble d'outils pour gérer et coordonner la création, la mise à l'échelle et la
surveillance des conteneurs. Il permet également la gestion des ressources, la tolérance aux pannes et la mise
à jour des applications sans interruption de service.

Depuis son lancement, Kubernetes est devenu une technologie de choix pour de nombreuses entreprises
cherchant à déployer des applications dans des environnements de conteneurs. Il est soutenu par une grande
communauté de développeurs et d'entreprises, notamment Google, Microsoft, Amazon, Red Hat et bien
d'autres.
Bénéfices de Kubernetes

Kubernetes offre de nombreux avantages :

Portabilité : Kubernetes permet de déployer des applications dans n'importe quel environnement, qu'il s'agisse
de datacenters locaux, de clouds publics ou de clusters hybrides.

Évolutivité : Kubernetes peut facilement mettre à l'échelle les applications en fonction de la demande de trafic,
en ajoutant ou en supprimant des conteneurs en temps réel.

Automatisation : Kubernetes automatise les tâches de déploiement, de mise à l'échelle et de gestion des
conteneurs, ce qui réduit considérablement la charge de travail des équipes DevOps.

Disponibilité : Kubernetes offre des fonctionnalités de haute disponibilité, telles que la redondance des nœuds
et la tolérance aux pannes, ce qui permet de maintenir les applications en ligne en cas de défaillance d'un ou
plusieurs composants.

Sécurité : Kubernetes offre des fonctionnalités de sécurité robustes, telles que l'isolation des conteneurs, la
gestion des autorisations et la mise en place de politiques de sécurité.

Flexibilité : Kubernetes prend en charge une grande variété de technologies de conteneurisation, telles que
Docker, rkt, CRI-O et d'autres, ce qui permet de choisir la technologie de conteneurisation la mieux adaptée à
chaque application.

Communauté active : Kubernetes est soutenu par une grande communauté de développeurs et d'entreprises,
ce qui garantit une évolution rapide du projet et une grande disponibilité de ressources et de documentation.
Architecture de Kubernetes

Vue d'ensemble de son architecture :

Master Node : Le Master Node est le cerveau de la plateforme Kubernetes. Il gère les tâches d'orchestration et
prend les décisions nécessaires pour maintenir l'état désiré du cluster. Le Master Node est composé des
composants suivants :
API Server : Il expose l'API Kubernetes qui est utilisée pour gérer les ressources du cluster.

Etcd : Il est la base de données distribuée utilisée pour stocker l'état du cluster.

Controller Manager : Il surveille l'état du cluster et prend des mesures pour le maintenir dans l'état souhaité.

Scheduler : Il est responsable de l'ordonnancement des pods sur les nœuds du cluster en fonction des besoins
de l'application.

Node : Un Node est une machine physique ou virtuelle qui exécute des conteneurs. Chaque nœud dans le
cluster doit exécuter un agent de nœud appelé kubelet qui communique avec le Master Node. Les autres
composants d'un nœud comprennent :
Kubelet : Il est responsable de l'exécution des conteneurs et de la communication avec le Master Node.

Kube-proxy : Il est responsable de la gestion du trafic réseau entre les pods et les services.

Container Runtime : Il est le moteur de conteneurisation utilisé pour exécuter les conteneurs.
Architecture de Kubernetes
Principaux objets de base – Deployment, Pods, Services, ConfigMap, Secret, Volumes, Namespaces

Description des principaux objets Kubernetes :

Deployment : un objet Deployment permet de créer et de gérer des réplicas de Pods (un groupe de un ou plusieurs
conteneurs) pour fournir une haute disponibilité pour une application. Les Deployments permettent également de gérer les
mises à jour de l'application en créant de nouvelles versions de l'application.

Pods : un Pod est la plus petite unité déployable de Kubernetes. Un Pod est un groupe de un ou plusieurs conteneurs qui
partagent un espace de stockage, une adresse IP et un espace de noms réseau.
Services : un Service Kubernetes est un objet qui expose une application en cours d'exécution dans un Pod à l'intérieur
d'un cluster Kubernetes et permet la communication avec d'autres parties du cluster. Les Services Kubernetes peuvent
être configurés pour permettre la communication entre les Pods ou pour exposer une application à l'extérieur du cluster.

ConfigMap : un ConfigMap est un objet Kubernetes qui stocke les données de configuration sous forme de paires
clé-valeur. Les ConfigMaps peuvent être utilisés pour stocker les variables d'environnement, les fichiers de configuration
et les paramètres de configuration pour les applications déployées dans Kubernetes.

Secret : un Secret est un objet Kubernetes qui stocke des données sensibles, telles que des informations d'identification,
des clés d'API ou des certificats SSL/TLS, sous forme de paires clé-valeur chiffrées.

Volumes : un Volume Kubernetes est un espace de stockage qui peut être monté sur un conteneur. Les Volumes
Kubernetes peuvent être utilisés pour stocker des données en mode persistant et pour permettre la communication
entre les conteneurs.

Namespaces : un Namespace est un objet Kubernetes qui permet de segmenter un cluster Kubernetes en plusieurs zones
logiques isolées. Les Namespaces permettent de regrouper des ressources Kubernetes en fonction de leur utilisation ou
de leur application, ce qui facilite la gestion des ressources et des autorisations d'accès.
Bonne Pratiques et Sécurité

Mettre en place l'authentification et l'autorisation : Utiliser des mécanismes d'authentification et d'autorisation robustes
pour contrôler l'accès aux ressources Kubernetes. Utiliser des identités vérifiables telles que les certificats TLS et les jetons
d'accès.

Limiter les privilèges : Éviter d'accorder des privilèges excessifs aux utilisateurs et aux applications. Utiliser le principe du
moindre privilège pour limiter les droits d'accès.

Utiliser les secrets Kubernetes : Les secrets Kubernetes vous permettent de stocker des informations sensibles telles que
les clés d'API et les mots de passe. Utilisez-les pour protéger vos données.

Éviter d'utiliser les images non vérifiées : N'utilisez pas d'images non vérifiées provenant de sources non fiables. Utiliser
des images signées et vérifiées provenant de sources de confiance.

Limiter l'exposition des API Kubernetes : Utiliser des règles de pare-feu pour limiter l'exposition des API Kubernetes aux
utilisateurs autorisés. Éviter d'exposer l'API Kubernetes directement sur Internet.

Mettre à jour régulièrement : Mettre à jour régulièrement votre version de Kubernetes et des composants connexes pour
corriger les vulnérabilités de sécurité connues.

Sécuriser les applications dans les conteneurs : Utiliser des images de conteneurs sécurisées et des mécanismes de
sécurité tels que les politiques de sécurité des conteneurs pour réduire les risques de compromission des applications.

Utiliser des outils de surveillance : Utiliser des outils de surveillance pour surveiller les activités suspectes et les
vulnérabilités de sécurité dans votre cluster Kubernetes.

Multimasters : Mettre en place le multi-master en production en respectant le quorum.

Stockage externalisé : Utiliser une solution de stockage externalisée en production (GlusterFS, Ceph Storage ...)

Déploiement : Mettre en place des pipelines CI/CD

Régistre d’images : Utiliser un régistre d’image privé

Les outils pour créer des clusters kubernetes

➔ Kubeadm
https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/

➔ Google Kubernetes Engine (GKE)

https://cloud.google.com/kubernetes-engine?hl=fr

➔ Amazon Elastic Kubernetes Service (Amazon EKS)

https://aws.amazon.com/fr/eks/

➔ Service Azure Kubernetes (AKS)

https://azure.microsoft.com/fr-fr/products/kubernetes-service

➔ VMware TKG (VMware Tanzu Kubernetes Grid)

https://docs.vmware.com/fr/VMware-Tanzu-Kubernetes-Grid/index.html

➔ Kops
https://github.com/kubernetes/kops

➔ Kubespray
https://kubespray.io
Présentation de Amazon EKS (Amazon Elastic Kubernetes Service)
https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html

Amazon EKS est un service Kubernetes géré qui exécute des clusters Kubernetes dans le cloud AWS et dans les
centres de données sur site. Dans le cloud, Amazon EKS gère automatiquement la disponibilité et la capacité
de mise à l'échelle des nœuds de plan de contrôle de Kubernetes, qui sont responsables de la planification des
conteneurs, de la gestion de la disponibilité des applications, du stockage des données des clusters et d'autres
tâches clés

Fonctionnalités d'Amazon ECS

Plan de contrôle géré : Amazon EKS propose un plan de contrôle Kubernetes évolutif à haute disponibilité, qui peut être
exécuté dans différentes zones de disponibilité AWS.

Console Kubernetes hébergée : EKS fournit une console intégrée pour les clusters Kubernetes. Les opérateurs de cluster
et les développeurs d'applications peuvent utiliser EKS comme un emplacement unique pour organiser, visualiser et
dépanner leurs applications Kubernetes exécutées sur Amazon EKS.

Groupes de nœuds gérés : Amazon EKS vous permet de créer, de mettre à jour, de mettre à l'échelle ou de résilier des
nœuds de votre cluster au moyen d'une seule commande.

Calcul sans serveur : EKS est compatible avec AWS Fargate et permet d'exécuter vos applications Kubernetes avec des
services de calcul sans serveur.

Connecteur EKS : Amazon EKS vous permet désormais de connecter un cluster Kubernetes compatible à AWS et de le
visualiser dans la console Amazon EKS. Vous pouvez connecter un cluster Kubernetes compatible, y compris des clusters
Amazon EKS Anywhere exécutés sur site, des clusters autogérés sur Amazon EC2.
Travaux Pratiques

● Installation de kubernetes
● Déployer une application sur kubernetes
● Déployer une application stateful sur kubernetes
● Déployer une application stateful sur Amazon EKS