Introduction à kubernetes

Qu’est ce que Kubernetes ?

C’est un orchestrateur de container, il permet de d’automatiser le déploiement des applications en container. (Architecture dynamique) Il est open source.
kubernetes va gérer le bon fonctionnement de nos applications via la déclaration d’un « état souhaité » (nombre de CPU, RAM, réplicat ext …)

Avantages :
Vitesse de déploiement, notion de micro service
Capacité à absorber rapidement les changements
Capacité à récupérer rapidement (Perte de l’état souhaité, correction rapide)
Abstraction de la complexité du cluster, charge à l’administrateur de définir l’environnement pour le développeur qui peut se concentrer sur l’application.

Principe de Kubernetes
On va définir notre application kubernetes dans une configuration déclarative (état souhaité ou manifeste). Suite à cela Kubernetes va tout mettre en œuvre pour conserver l’état inscris dans notre déclaration.(Via les objets contrôleurs, qui vont vérifier régulièrement l’état du cluster)
A l’opposé de ce mode de fonctionnement actuellement on travail de façon impérative. (Administration manuel d’un SI, ajout de ressources CPU/RAM ext …)
On va pouvoir interagir avec Kubernetes via son serveur API.

Principe de l’API Kubernetes

Kubernetes est constitué d’une collection de primitives qui représentent l’état du système.
Pour intéragir avec Kubernetes on va passer par l’API RESTful qui s’exécute en HTTP ou HTTPS via le format JSON stocké dans une BDD interne.

Quelques objets de Kubernetes

• POD : Un seul ou plusieurs container que l’on va déployer comme une « unité »
• Contrôleur : Permette de maintenir notre cluster dans l’état souhaité
• Service : Fournisse un point d’accès permanent dans l’application
• Stockage : Appelé volume, cela permet de stocker les données de façon persistantes

Détail sur les PODS
Un POD est une unité de travail élémentaire (la plus petite pour kubernetes), il peut contenir un ou plusieurs container. Kubernetes va gérer notre POD, pas le container. Il va contenir notre application. Si le container interne au pod disparait, le POD disparait avec lui, même réaction dans le cas d’un POD multi container.
Le travail de Kubernetes sera donc de garder en état de fonctionnement notre POD, il va suivre son état. On va utiliser des sondes d’activité afin de surveiller le bon fonctionnement de notre application, « Liveness Probes ». (Ping vers un serveur WEB par exemple pour vérifier la bonne réponse du serveur WEB dans le POD)

Détail sur les contrôleurs
Il va créer et gérer les PODS pour nous. Après définition de l’état souhaité, le contrôleur sera chargé de vérifier à ce que ca corresponde à notre définition.
Dans un contrôleur, l’objet principal sera « ReplicaSet » (nombre de réplicas, ou nombres de POD), il utilisera également l’objet « Deployment » qui va gérer les replicaSet.

Détail sur les services
Les services ajoute de la persistance, Kubernetes attribut une IP et un Nom DNS au service. Il permet d’exposer les PODS au monde exterieur. Il peut également faaire du loaod balancing, NAT, PAT.

Détail sur le stockage
On va définir des PersitentVolume, un stockage indépendant du POD qui est définit par l’administrateur au niveau du cluster. Les pods vont pouvoir accéder à ce stockage via une demande (PersitentVolumeClaim) Permet de dissocier facilement le POD du stockage.

Architecture et composants de Kubernetes

• Master : Il contient, API SERVER/Scheduler/Cluster Store/Controler Manager (kubectl) et permet l’administration du cluster
• Worker : Permettent de démarrer les PODS, et s’assure que tout soit opérationnel, ils font également la mise en réseaux, généralement plusieurs noeuds en fonction de la charge de travail
• Add-On : Kubernetes ne gère pas de façon native la gestion réseau, on va utiliser des addons pour répondre à cela.

Détail sur le master
Il se compose d’un « Kube-API Server », il est le composant qui expose cette API. il s’agit du front-end pour le plan de contrôle Kubernetes.
Il contient également le « planificateur » (Scheduler, Kube-Scheduler), il va surveiller les pods nouvellement crées qui ne sont pas assignées à un noeud et sélectionne un noeud sur lequel ils vont s’exécuter. les facteurs pris en compte pour les décisions de planification comprennent les exigences individuelles et collectives en ressources, les contraintes matérielles/logicielles/politiques, les spécifications d’affinités et d’anti-affinité, la localisation des données.
Afin de gérer l’état du Système Kubernetes utilise une base de données clée/valeur (ETCD).
Enfin le gestionnaire ede cycle de vie des contrôleurs on vaa utiliser le « kube-controller-manager ».
Parmis les contrôleurs on va citer : Node Contrôleur, Replication Contrôleur, Endpoint contrôleur (Joint les services aux Pods), Service Account contrôleur et token controleur permettent de créer les comptes par défaut et les jetons d’accès à l’API pour les namespaces.

Détail sur les workers
Un worker ou node, ils démarrent les PODS, ils font la mise en réseaux. On peut trouver kublet (démarrage des pods, kube proxy (mise en réseau des pods, et mise en oeuvre de l’abstraction des pods) et le runtime des container (Docker par exemple). Tout ces éléments tournent sur l’ensemble des nœuds du cluster. Même sur les maître.

• Kublet : Surveille le serveur API pour obtenir les changements. Démarrage et arrêt de PODS, signal l’état du nœud et des PODS. Surveille l’état des PODS. Tout cela sera envoyé au serveur API. Il peut exécuter les sondes d’activité et de disponibilités.
• Kube-proxy : Responsable de tout les composants réseaux qui s’exécute sur chaque nœud du cluster. Il peut utiliser la couche de filtrage de paquets du système d’exploitation si il y en a une sinon il le fait lui même. Flanel, Calico, Weavs
• Runtime de container : Il s’agit de l’environnement d’exécution de conteneurs.

Le déploiement de Kubernetes peut se faire à la main, ou via minikube ou Kubeadm qui va permettre de « tout » déployer « rapidement ». Côté réseau pour dialoguer on va devoir autoriser les flux sur un certain nombre de ports :

• API : 6443
• ETCD : 2379-2380
• Scheduler : 10251
• Controler Manager : 10252
• Kublet service : 10250

Les paquets nécessaires, sont : kublet, kubeadm, kubectl, Container Runtime(Docker)

Pour gérer le processus de création du cluster, on va utiliser kubeadm, détail par étape lors de la création d’une nouveau cluster kubernetes :
kubeadm –init

• 1 Vérification des prérequis, CPU, RAM, ContainerRuntime
• 2 Téléchargement des images de container pour le serveur API
• 3 création d’une autorité de certification
• 4 Générer les fichiers de configuration(kubeconfig)
• 5 Générer des manifest de pods(Config des pods)
• 6 Démarrage des différents éléments en pod (API, BDD ext ..)
• 7 Verrouillage du maître (taint du master)
• 8 Création des token de fonction au cluster

Détail sur l’autorité de certification
Création d’une autorité auto signé pour la création de certificat (HTTPS), pour chiffrer le traffic de l’API, des utilisateurs et du service kubelets et seront distribué sur chaque noeud

Les fichiers kubeconfig
Les fichiers sont présent dans /etc/kubernetes/, on aura un fichier par élément.
admin.conf (kubernetes-admin) contient le certificat admin et autres informations d’admin
kublet.conf, controller-manaager.conf, scheduler.conf

LABS :