From f80cf55f8872de3e2d29f80bb16a9e89ecd691f9 Mon Sep 17 00:00:00 2001 From: herveleclerc Date: Thu, 5 Sep 2024 15:29:19 +0200 Subject: [PATCH] test mermaid --- .../kubernetes/k8s-architecture.fr.md | 17 +-- .../kubernetes/k8s-core-api-objects.fr.md | 70 ++++++++++- .../k8s-imperative-declarative-commands.fr.md | 36 ++++++ .../kubernetes/k8s-installation.fr.md | 74 +++++++---- .../kubernetes/k8s-networking.fr.md | 67 ++++++++-- .../k8s-observability-monitoring.fr.md | 44 +++---- .../kubernetes/k8s-operations.fr.md | 5 +- .../kubernetes/k8s-resources-handling.fr.md | 33 ++++- .../containers/kubernetes/k8s-security.fr.md | 35 ++++++ cours/containers/kubernetes/k8s-usage.fr.md | 118 +++++++++++------- cours/containers/kubernetes/k8s-volumes.fr.md | 17 ++- .../k8s-workloads-configuration.fr.md | 1 + templates/template.revealjs | 9 +- 13 files changed, 404 insertions(+), 122 deletions(-) diff --git a/cours/containers/kubernetes/k8s-architecture.fr.md b/cours/containers/kubernetes/k8s-architecture.fr.md index 0f30da2..5f09b5e 100644 --- a/cours/containers/kubernetes/k8s-architecture.fr.md +++ b/cours/containers/kubernetes/k8s-architecture.fr.md @@ -44,7 +44,7 @@ ### Kubernetes : `kube-apiserver` -Sans le `kube-apiserver` le cluster ne sert à rien. De plus, il est **LE SEUL** à interagir avec le cluster `etcd`, que ce soit en écriture ou en lecture. +Sans le `kube-apiserver` le cluster ne sert à rien. De plus, il est `LE SEUL` à interagir avec le cluster `etcd`, que ce soit en écriture ou en lecture. - Les configurations d'objets (Pods, Service, RC, etc.) se font via l'API server - Un point d'accès à l'état du cluster aux autres composants via une API REST @@ -134,18 +134,19 @@ Kubernetes n'implémente pas de solution réseau par défaut, mais s'appuie sur ### Kubernetes : Aujourd'hui -- Version 1.24.x : stable en production +- Version 1.30.x : stable en production - Solution complète et une des plus utilisées - Éprouvée par Google - -```console -1.24 -Latest Release:1.24.2 (released: 2022-06-15) -End of Life:2023-09-29 -Patch Releases: 1.24.1, 1.24.2 -Complete 1.24 **Schedule** and **Changelog** +**1.31** + Latest Release:1.31.0 (released: 2024-08-13) + End of Life:2025-10-28 + Patch Releases: n/a + Complete 1.31 [Schedule](https://kubernetes.io/releases/patch-releases/#1-31) and [Changelog](https://git.k8s.io/kubernetes/CHANGELOG/CHANGELOG-1.31.md) + + ``` diff --git a/cours/containers/kubernetes/k8s-core-api-objects.fr.md b/cours/containers/kubernetes/k8s-core-api-objects.fr.md index c3fc81a..3a2e565 100644 --- a/cours/containers/kubernetes/k8s-core-api-objects.fr.md +++ b/cours/containers/kubernetes/k8s-core-api-objects.fr.md @@ -21,17 +21,23 @@ - Les objets existent uniquement au sein d'un namespace donné - Évitent la collision de nom d'objets - Font partie du fqdn du service (DNS) (mon-service.mon-namespace.svc.cluster.local) +- Quotas et limites: Vous pouvez définir des quotas et des limites sur les ressources (CPU, mémoire, nombre de pods, etc.) au niveau du namespace pour contrôler l'utilisation des ressources. +- Défaut: Le namespace `default` existe par défaut dans chaque cluster Kubernetes. + ### Kubernetes : Labels - Système de clé/valeur -- Organisent les différents objets de Kubernetes (Pods, RC, Services, etc.) d'une manière cohérente qui reflète la structure de l'application +- Organisent, filtrent, selectionnent les différents objets de Kubernetes (Pods, RC, Services, etc.) d'une manière cohérente qui reflète la structure de l'application - Corrèlent des éléments de Kubernetes : par exemple un service vers des Pods - Ils contiennent des informations d'identification utilisées par les requêtes qui utilisent un sélecteur ou dans les sections de sélecteurs dans les définitions d'objets - Le nom dans la clé est limité à 63 caractères et le suffixe à 253 caractères - La valeur ne peut dépasser 63 caractères - La valeur doit commencer un aplhanum ou être vide - La valeur peut contenir des `~` `.` et `alphanum` +- Arbitraires: Vous pouvez définir n'importe quelle paire clé-valeur. +- Immuables: Une fois créés, les labels ne peuvent pas être modifiés directement. Pour les changer, il faut créer un nouveau déploiement ou un nouveau pod. +- Multiples: Un objet peut avoir plusieurs labels. ### Kubernetes : Labels @@ -78,8 +84,12 @@ kubectl get po -A -l k8s-app=kube-dns -l pod-template-hash=6d4b75cb6d - Système de clé/valeur - Ce sont des informations qui ne sont pas utilisées pour l'identification de ressources. - Les annotations ne sont pas utilisées en interne par kubernetes +- Stockage de données personnalisées: Pour stocker des informations spécifiques à votre application ou à votre infrastructure. - Elles peuvent être utilisées par des outils externes ou librairies (ex: cert-manager, ingress-controller...) - Le nom dans la clé est limitée à 63 caractères et le suffixe à 253 caractères +- Arbitraires: Vous pouvez définir n'importe quelle paire clé-valeur. +- Mutables: Les annotations peuvent être modifiées après la création de l'objet. +- Multiples: Un objet peut avoir plusieurs annotations. ### Kubernetes : Annotations @@ -115,8 +125,14 @@ spec: - La stack IP (network namespace) - Inter-process communication (PID namespace) - Volumes + - IP: Le pod lui-même dispose d'une adresse IP unique, que tous les conteneurs du pod peuvent utiliser. + - Cycle de vie: Les conteneurs d'un pod sont créés et détruits en même temps + - Node: Tous les conteneurs d'un pod sont généralement co-localisés sur le même nœud du cluster Kubernetes. - C'est la plus petite et la plus simple unité dans Kubernetes +En savoir plus : + + ### Kubernetes : Pod @@ -217,6 +233,36 @@ $ kubectl get pods -o jsonpath='{.status}' | jq ![deployment](images/deployment.png) + +### Kubernetes : Deployment + +```plaintext ++--------------------+ +| Deployment | +| | +| Name: my-deployment| +| Selector: app=web | ++--------------------+ + | + | matches + v ++--------------------+ +| ReplicaSet | +| | +| Selector: app=nginx| ++--------------------+ + | + | matches + v ++--------------------+ +| Pod | +| | +| Labels: app=nginx | ++--------------------+ +``` + + + ### Kubernetes : Deployment ```yaml @@ -228,7 +274,7 @@ spec: replicas: 3 selector: matchLabels: - app:nginx + app: nginx template: metadata: labels: @@ -241,6 +287,13 @@ spec: - containerPort: 80 ``` +ou en ligne de commande + +```console +kubectl create deployment my-deployment --image=nginx:latest --replicas=3 +``` + + ### Kubernetes : DaemonSet - Assure que tous les noeuds exécutent une copie du pod sur tous les noeuds du cluster @@ -444,6 +497,13 @@ spec: restartPolicy: OnFailure ``` +En ligne de commande : + + +```console +kubectl create job exemple-job --image=busybox -- /bin/sh -c "date; echo Hello from the Kubernetes cluster" +``` + ### Kubernetes: CronJob - Un CronJob permet de lancer des Jobs de manière planifiée. @@ -480,3 +540,9 @@ spec: ``` +En ligne de commande : + +```console +kubectl create cronjob exemple-cronjob --image=busybox --schedule="*/5 * * * *" -- /bin/sh -c "date; echo Hello from the Kubernetes cluster" +``` + diff --git a/cours/containers/kubernetes/k8s-imperative-declarative-commands.fr.md b/cours/containers/kubernetes/k8s-imperative-declarative-commands.fr.md index cb4059d..981fa0d 100644 --- a/cours/containers/kubernetes/k8s-imperative-declarative-commands.fr.md +++ b/cours/containers/kubernetes/k8s-imperative-declarative-commands.fr.md @@ -2,17 +2,40 @@ ### La méthode déclarative +L'approche déclarative consiste à décrire l'état désiré des ressources. Vous déclarez ce que vous voulez obtenir, et Kubernetes s'occupe de mettre en place et de maintenir cet état. + - Consiste à définir un objet dans un fichier yaml puis à créer l'objet avec la commande kubectl apply ou kubectl create - Recommandé pour garder un historique de tous les objets créés, puis de faire du versionning - Il facilite également le travail entre équipe. +- Avantages : + - Simplicité: Plus facile à comprendre et à maintenir que les commandes impératives. + - Reproductibilité: Les fichiers de configuration peuvent être versionnés et utilisés pour recréer un environnement à tout moment. + - Idéal pour l'automatisation: Parfaitement adapté aux outils d'intégration continue et de déploiement continu (CI/CD). + - Détection des dérives: Kubernetes compare l'état actuel du cluster à l'état désiré défini dans les fichiers de configuration et effectue les modifications nécessaires pour rétablir la conformité. +- Inconvénients: + - Moins de flexibilité pour certaines opérations: Certaines opérations peuvent nécessiter des commandes impératives pour être effectuées. + + ### La méthode impérative +L'approche impérative consiste à donner des instructions directes à Kubernetes pour effectuer des actions spécifiques. On décrit comment réaliser une tâche, pas seulement le résultat final. + - Permet la création rapide des ressources à l'aide d'une commande - Gain un temps considérable lors de l'examen - Recommandé dans des environnements de lab ou pour tester une commande +- Avantages : + - Flexibilité: Grande liberté dans la façon de gérer les ressources. + - Contrôle précis: Possibilité d'effectuer des actions très spécifiques. +- Inconvénients : + - Erreur humaine: Le risque d'erreur est plus élevé car chaque action doit être spécifiée manuellement. + - Difficulté de suivi: Il peut être difficile de retracer les modifications apportées à un état donné du cluster. + - Moins adapté aux environnements complexes: La gestion manuelle de nombreuses ressources peut devenir rapidement fastidieuse et source d'erreurs. + + + ### La méthode impérative @@ -75,3 +98,16 @@ kubectl create service nodeport nginx --tcp=80:80 --node-port=30080 --dry-run=cl Ceci n'utilisera pas les labels des pods comme sélecteurs. +### Quand utiliser quelle méthode ? + +- Méthode impérative: + - Pour des tâches ponctuelles ou des dépannages. + - Lorsque vous avez besoin d'un contrôle très précis sur les ressources. +- Méthode déclarative: + - Pour la gestion quotidienne des ressources. + - Pour automatiser les déploiements et les mises à jour. + - Pour construire des pipelines CI/CD. + + + + \ No newline at end of file diff --git a/cours/containers/kubernetes/k8s-installation.fr.md b/cours/containers/kubernetes/k8s-installation.fr.md index 8f89605..38a16d1 100644 --- a/cours/containers/kubernetes/k8s-installation.fr.md +++ b/cours/containers/kubernetes/k8s-installation.fr.md @@ -22,39 +22,66 @@ ### Installation de Kubernetes avec kubeadm - Certains pré-requis sont nécessaires avant d'installer Kubernetes : - - Désactiver le swap (Support **alpha** depuis la 1.22) + - Désactiver le `swap` (Support **alpha** depuis la 1.22) - Assurer que les ports requis soient ouverts : - - Installer une Container Runtime compatible CRI (containerd, CRI-O, Docker) + - Installer une Container Runtime compatible CRI (containerd, CRI-O, Docker, ...) ### kubeadm (1) - Installer les composants Kubernetes (kubeadm, kubectl, kubelet) : - Exécuter : - - `kubeadm init` sur le noeud master - - `kubeadm join` sur les autres noeuds (avec le token fournit par la commande `kubeadm init`) + - `kubeadm init` sur le noeud `master`(control plane) + - `kubeadm join` sur les autres noeuds (worker) (avec le token fournit par la commande `kubeadm init`) - Copier le fichier de configuration généré par `kubeadm init` - Installer le plugin Réseau -- Optionnellement: Tester le dploiement d'un pod +- Optionnellement: Tester le déploiement d'un pod ### kubeadm (2) -En plus de l'installation de Kubernetes, kubeadm peut : - -- Renouveler les certificats du Control Plane -- Générer des certificats utilisateurs signés par Kubernetes -- Effectuer des upgrades de Kubernetes (`kubeadm upgrade`) - -### Kubernetes managés "as a Service" - -- Il existe des solutions managées pour Kubernetes sur les cloud publics : - - AWS Elastic Kubernetes Services (EKS): - - Azure Kubernetes Service (AKS): - - Docker Universal Control Plane : - - Google Kubernetes Engine : - - Scaleway Kapsule : - - Alibaba Container Service for Kubernetes (ACK) - -### Installation de Kubernetes +- En plus de l'installation de Kubernetes, kubeadm peut : + + - Génération des fichiers de configuration: Crée les fichiers de configuration nécessaires pour les composants du cluster. + - Gestion des certificats: Génère et distribue les certificats nécessaires pour sécuriser les communications entre les composants du cluster. + - Gestion des tokens: Crée des tokens d'authentification pour les nœuds qui rejoignent le cluster. + - Vérification de la configuration: Valide que le système et les configurations sont compatibles avec Kubernetes. + - Mises à jour et modifications: Facilite les mises à jour des versions de Kubernetes et les modifications de la configuration du cluster. + +" +### Kubernetes managés "as a Service Majeurs + +- Plateformes Cloud Majeures : + - Amazon Elastic Kubernetes Service (EKS): + - Documentation : https://aws.amazon.com/fr/eks/ + - Offre une solution entièrement gérée pour déployer, gérer et mettre à l'échelle des clusters Kubernetes sur AWS. + - Google Kubernetes Engine (GKE): + - Documentation : https://cloud.google.com/kubernetes-engine + - Propose une plateforme hautement disponible et entièrement gérée pour exécuter des applications conteneurisées sur Google Cloud Platform. + - Azure Kubernetes Service (AKS): + - Documentation : https://azure.microsoft.com/fr-fr/services/kubernetes-service/ + - Permet de déployer et gérer des clusters Kubernetes sur Azure avec une intégration profonde avec les autres services Azure. + + +### Kubernetes managés "as a Service Populaires + +- Autres Plateformes Populaires : + - DigitalOcean Kubernetes: + - Documentation : https://www.digitalocean.com/products/kubernetes/ + - Offre une solution simple et abordable pour déployer des clusters Kubernetes sur DigitalOcean. + - Rancher Kubernetes Engine (RKE): + - Documentation : https://rancher.com/docs/rke/latest/en/ + - Solution open-source pour gérer des clusters Kubernetes multi-cloud et sur site. + - Platform9 Managed Kubernetes: + - Documentation : https://platform9.com/docs/ + - Plateforme de gestion de Kubernetes hybride et multi-cloud. + - Red Hat OpenShift: + - Documentation : https://www.openshift.com/ + - Plateforme containerisée complète basée sur Kubernetes, offrant une large gamme de fonctionnalités pour les entreprises. + - Scaleway Kapsule : + - Documentation : https://www.scaleway.com/fr/kubernetes-kapsule/ + - Alibaba Container Service for Kubernetes (ACK) + - Documentation : https://www.alibabacloud.com/fr/product/kubernetes + +### Installateurs de Kubernetes - Via Ansible : `kubespray` - Via Terraform : @@ -63,6 +90,7 @@ En plus de l'installation de Kubernetes, kubeadm peut : - kops : - rancher : - tanzu : + - clusterAPI : ### Conformité kubernetes @@ -76,4 +104,6 @@ Voici quelques outils permettant de certifier les déploiements des cluster kube - - kube-bench - +- Kube-hunter: + - diff --git a/cours/containers/kubernetes/k8s-networking.fr.md b/cours/containers/kubernetes/k8s-networking.fr.md index f76f4c6..e829bc5 100644 --- a/cours/containers/kubernetes/k8s-networking.fr.md +++ b/cours/containers/kubernetes/k8s-networking.fr.md @@ -15,7 +15,13 @@ - Projet dans la CNCF - Standard pour la gestion du réseau en environnement conteneurisé - Les solutions précédentes s'appuient sur CNI +- Flexibilité: Il offre une grande flexibilité pour choisir le type de réseau à utiliser (bridge, VLAN, VXLAN, etc.) et les fonctionnalités associées (routage, NAT, etc.). +- Plugin: Un CNI est implémenté sous forme de plugin, ce qui permet de choisir le plugin adapté aux environnements et besoins. +- Rôle d'un CNI dans Kubernetes + - Création d'interfaces réseau: Lorsqu'un pod est créé, le CNI est appelé pour créer une ou plusieurs interfaces réseau pour les conteneurs du pod. + - Configuration IP: Le CNI attribue une adresse IP à chaque interface réseau et configure les routes nécessaires. + - Gestion des réseaux: Le CNI gère la configuration réseau au cours du cycle de vie du pod (création, modification, suppression). ### Kubernetes : POD Networking @@ -23,12 +29,15 @@ ### Kubernetes : Services -- Abstraction des pods sous forme d'une `IP virtuelle` de service et d'un `nom DNS` +- Une abstraction de niveau supérieur qui expose un ensemble de pods sous un nom et une adresse IP stables. +- Permet d'accéder à un groupe de pods de manière uniforme, même si les pods individuels sont créés, mis à jour ou supprimés. - Rendre un ensemble de pods accessibles depuis l'extérieur - Load Balancing entre les pods d'un même service ### Kubernetes : Services +Service de type Spécial `LoadBalancer` : + - Load Balancing : intégration avec des cloud provider : - AWS ELB - GCP @@ -201,6 +210,20 @@ kubectl expose deploy web --type LoadBalancer --protocol TCP --port 9000 --targe - La redirection se produit au niveau DNS, il n'y a aucune proxyfication ou forward +Exemples d'utilisation concrets : + +- Intégration avec des services tiers: + - Base de données externe: Vous avez une base de données hébergée sur un service cloud comme AWS RDS. Au lieu d'utiliser l'adresse IP ou l'URL complète, vous pouvez créer un service ExternalName qui pointera vers le nom DNS de cette base de données. Cela facilite la configuration de vos applications dans le cluster. + - API externe: Vous souhaitez consommer une API publique (comme une API météo ou une API de paiement). En créant un service ExternalName qui pointe vers l'URL de cette API, vous pouvez y accéder depuis vos pods comme si c'était un service interne. +- Migration progressive: + - Transition vers un nouveau service: Vous êtes en train de migrer vers un nouveau service et souhaitez maintenir l'ancien pendant un certain temps. Vous pouvez créer un service ExternalName qui pointera alternativement vers l'ancien ou le nouveau service, selon votre configuration. +- Abstraction de noms DNS complexes: + - Noms DNS longs ou difficiles à retenir: Si vous avez des noms DNS très longs ou complexes, un service ExternalName peut servir d'alias plus court et plus facile à mémoriser. +- Microservices: + - Simplifie les interactions entre différents microservices qui peuvent être déployés sur des infrastructures différentes. +- Tests: + - Permet de simuler des environnements de test en pointant vers des services de test. + ### Kubernetes : Services : ExternalName Il est aussi possible de mapper un service avec un nom de domaine en spécifiant le paramètre `spec.externalName`. @@ -244,11 +267,8 @@ kubectl get svc web ClusterIP 10.96.163.5 80/TCP 3m56s kubectl exec web-96d5df5c8-lfmhs -- env | sort -WEB_PORT=tcp://10.96.163.5:80 -WEB_PORT_80_TCP=tcp://10.96.163.5:80 -WEB_PORT_80_TCP_ADDR=10.96.163.5 -WEB_PORT_80_TCP_PORT=80 -WEB_PORT_80_TCP_PROTO=tcp +... + WEB_SERVICE_HOST=10.96.163.5 WEB_SERVICE_PORT=80 @@ -282,19 +302,40 @@ ex: my-app.default.svc.cluster.local ### Kubernetes : Ingress ```yaml -apiVersion: extensions/v1beta1 +apiVersion: networking.k8s.io/v1 kind: Ingress metadata: - name: blog + annotations: + cert-manager.io/cluster-issuer: le + meta.helm.sh/release-name: argocd + meta.helm.sh/release-namespace: argocd + labels: + app.kubernetes.io/component: server + app.kubernetes.io/instance: argocd + app.kubernetes.io/managed-by: Helm + app.kubernetes.io/name: argocd-server + app.kubernetes.io/part-of: argocd + app.kubernetes.io/version: v2.10.1 + helm.sh/chart: argo-cd-6.0.14 + name: argocd-server + namespace: argocd spec: + ingressClassName: nginx rules: - - host: blog.alterway.fr + - host: argocd.caas.fr http: paths: - - path: / - backend: - serviceName: blog-nodeport - servicePort: 80 + - backend: + service: + name: argocd-server + port: + number: 443 + path: / + pathType: Prefix + tls: + - hosts: + - argocd.caas.fr + secretName: argocd-server-tls ``` ### Kubernetes : Ingress Controller diff --git a/cours/containers/kubernetes/k8s-observability-monitoring.fr.md b/cours/containers/kubernetes/k8s-observability-monitoring.fr.md index fc7d257..248b0c6 100644 --- a/cours/containers/kubernetes/k8s-observability-monitoring.fr.md +++ b/cours/containers/kubernetes/k8s-observability-monitoring.fr.md @@ -34,38 +34,40 @@ ### Sondes : Exemples ```yaml -apiVersion: v1 +aapiVersion: v1 kind: Pod metadata: - name: goproxy - labels: - app: goproxy + name: my-app spec: containers: - - name: nginx - image: nginx + - name: my-app-container + image: my-image ports: - - containerPort: 80 + - containerPort: 8080 readinessProbe: - tcpSocket: - port: 80 - initialDelaySeconds: 5 - periodSeconds: 10 + httpGet: + path: /healthz + port: 8080 + httpHeaders: + - name: Authorization + value: Bearer my-token + initialDelaySeconds: 15 + periodSeconds: 5 + timeoutSeconds: 1 + failureThreshold: 3 livenessProbe: tcpSocket: - port: 80 - initialDelaySeconds: 15 - periodSeconds: 20 + port: 8080 + initialDelaySeconds: 30 + periodSeconds: 10 + timeoutSeconds: 2 + failureThreshold: 5 startupProbe: - initialDelaySeconds: 1 - periodSeconds: 2 - timeoutSeconds: 1 - successThreshold: 1 - failureThreshold: 1 exec: command: - - cat - - /etc/nginx/nginx.conf + - cat /etc/nginx/nginx.conf + initialDelaySeconds: 10 + timeoutSeconds: 5 ``` diff --git a/cours/containers/kubernetes/k8s-operations.fr.md b/cours/containers/kubernetes/k8s-operations.fr.md index a4ab2b9..dfbce81 100644 --- a/cours/containers/kubernetes/k8s-operations.fr.md +++ b/cours/containers/kubernetes/k8s-operations.fr.md @@ -256,8 +256,5 @@ kubectl example deploy ``` Liste des plugins : - - ----- - + diff --git a/cours/containers/kubernetes/k8s-resources-handling.fr.md b/cours/containers/kubernetes/k8s-resources-handling.fr.md index 2c31e00..0133553 100644 --- a/cours/containers/kubernetes/k8s-resources-handling.fr.md +++ b/cours/containers/kubernetes/k8s-resources-handling.fr.md @@ -8,6 +8,35 @@ - Limit: allocation maximum (limite) - Se base sur le CPU et la RAM +- Relation entre requests et limits + - Requests <= Limits: La valeur de la request doit toujours être inférieure ou égale à celle de la limit. + - Qualité de service (QoS): Les valeurs de requests et limits définissent le niveau de QoS d'un pod (BestEffort, Burstable, Guaranteed). + + + +### QoS + +- BestEffort : + - Pas de limites ni de requests définies: Le pod peut consommer autant de ressources que disponibles, mais il n'a aucune garantie. + - Conséquences: Le pod peut être évincé à tout moment si les ressources du nœud sont insuffisantes, ce qui peut entraîner des interruptions de service. +- Burstable : + - Requests définies: Le pod a une garantie minimale de ressources (requests). + - Pas de limites strictes: Le pod peut dépasser ses requests si les ressources sont disponibles, mais il peut être évincé si d'autres pods Guaranteed ont besoin de ressources. + - Conséquences: Le pod bénéficie d'une certaine priorité, mais il peut être impacté par les besoins des pods Guaranteed. +- Guaranteed : + - Requests et limites définies: Le pod a une garantie minimale de ressources (requests) et une limite maximale (limits). + - Priorité élevée: Le pod a la plus haute priorité et ne peut pas être évincé tant qu'il respecte ses limites. + - Conséquences: Le pod bénéficie d'une garantie de ressources stable, ce qui est idéal pour les applications critiques. + +Exemple concret : + +Un nœud Kubernetes avec 4 cœurs CPU. + + - Pod BestEffort: Il peut utiliser 0, 1, 2, 3 ou 4 cœurs, selon la disponibilité. + - Pod Burstable (requests: 2 cœurs, pas de limits): Il est garanti d'avoir au moins 2 cœurs, mais il peut en utiliser jusqu'à 4 s'ils sont disponibles. Si un pod Guaranteed a besoin de 2 cœurs, le pod Burstable peut en perdre 2. + - Pod Guaranteed (requests: 2 cœurs, limits: 2 cœurs): Il a toujours 2 cœurs garantis et ne peut pas en utiliser plus. + + ### Pods resources : CPU - 1 CPU est globalement équivalent à un cœur @@ -58,7 +87,7 @@ spec: ### LimitRanges -- l'objet `LimitRange` permet de définir les valeurs minimales et maximales des ressources utilisées par les containers et les pods +- l'objet `LimitRange` permet de définir les valeurs minimales et maximales des ressources utilisées par les containers et les pods pour les requests et limits de CPU, de mémoire et de stockage - l'objet `LimitRange` s'applique au niveau du `namespace` - les limites spécifiées s'appliquent à chaque pod/container créé dans le `namespace` - le `LimitRange` ne limite pas le nombre total de ressources disponibles dans le namespace @@ -83,7 +112,7 @@ spec: - un objet `ResourceQuota` limite le total des ressources de calcul consommées par les pods ainsi que le total de l'espace de stockage consommé par les `PersistentVolumeClaims` dans un namespace -- il permet aussi de limiter le nombre de `pods`, `PVC` et autres objets qui peuvent être créés dans un `namespace` +- il permet aussi de limiter le nombre de `pods`, `PVC`, réplicas, services et autres objets qui peuvent être créés dans un `namespace` ### ResourceQuotas diff --git a/cours/containers/kubernetes/k8s-security.fr.md b/cours/containers/kubernetes/k8s-security.fr.md index 7b0b5be..c672a5d 100644 --- a/cours/containers/kubernetes/k8s-security.fr.md +++ b/cours/containers/kubernetes/k8s-security.fr.md @@ -17,6 +17,41 @@ - Ressources représentées par les `Deployments`, `Pods`, `Services`, etc... - les différentes opérations possibles : `create, list, get, delete, watch, patch` +```mermaid +graph TD + A[API Server] --> B{RBAC} + B --> C[Subjects] + B --> D[Resources] + B --> E[Operations] + + C --> F[Users] + C --> G[Groups] + C --> H[Service Accounts] + + D --> I[Pods] + D --> J[Services] + D --> K[Nodes] + D --> L[...] + + E --> M[Get] + E --> N[List] + E --> O[Create] + E --> P[Update] + E --> Q[Delete] + E --> R[...] + + S[Roles] --> D + S --> E + + T[RoleBindings] --> C + T --> S + + U[ClusterRoles] --> D + U --> E + + V[ClusterRoleBindings] --> C + V --> U +``` ### Service Accounts diff --git a/cours/containers/kubernetes/k8s-usage.fr.md b/cours/containers/kubernetes/k8s-usage.fr.md index c4ba7e2..c642350 100644 --- a/cours/containers/kubernetes/k8s-usage.fr.md +++ b/cours/containers/kubernetes/k8s-usage.fr.md @@ -89,6 +89,13 @@ jobs batch ingresses ing extensions true Ingress ``` +- Pourquoi utiliser kubectl api-resources ? + - Découverte: Pour connaître les ressources disponibles dans votre cluster. + - Documentation: Pour obtenir des informations sur les différentes ressources et leurs propriétés. + - Développement: Pour créer des scripts et des outils d'automatisation. + - Dépannage: Pour identifier les problèmes liés à des ressources spécifiques. + + ### Kubernetes : `kubectl explain` @@ -309,11 +316,15 @@ curl -sk https:///api/v1/namespaces/kube-public/configmaps/cluster-info ### Kubernetes : namespace `kube-node-lease` +Qu'est-ce qu'un Lease dans Kubernetes ? +Un Lease est un objet qui expire après un certain temps s'il n'est pas renouvelé. Dans le contexte de kube-node-lease, chaque nœud du cluster a un Lease associé. La kubelet (l'agent Kubernetes s'exécutant sur chaque nœud) envoie régulièrement des mises à jour à ce Lease pour indiquer qu'il est toujours en fonctionnement. + - Ce namespace particulier existe depuis la 1.14 - Il contient un objet `lease`par noeud - Ces `leases` permettent d'implémenter une nouvelle méthode pour vérifier l'état de santé des noeuds - Voir (KEP-0009)[https://github.com/kubernetes/enhancements/blob/master/keps/sig-node/0009-node-heartbeat.md] pour plus d'information + ### Kubernetes : `kubectl describe` - `kubectl describe` a besoin d'un type de ressource et optionnelle-ment un nom de ressource @@ -326,6 +337,12 @@ curl -sk https:///api/v1/namespaces/kube-public/configmaps/cluster-info kubectl describe node worker-0 ``` +- Pourquoi utiliser kubectl describe ? + + - Dépannage: Pour comprendre pourquoi un objet ne fonctionne pas comme prévu. + - Audit: Pour vérifier la configuration d'un objet et s'assurer qu'elle correspond à vos attentes. + - Apprentissage: Pour mieux comprendre la structure et le fonctionnement des différents objets Kubernetes. + ### Kubernetes : Création d'objets Kubernetes @@ -341,12 +358,18 @@ curl -sk https:///api/v1/namespaces/kube-public/configmaps/cluster-info - Depuis elle démarre un simple `pod` ```console +# Création d'un pod en tâche de fond kubectl run pingu --image=alpine -- ping 127.1 ``` +```console +# Création d'un pod en intératif +kubectl run -i --tty my-pod --image=debian -- /bin/bash +``` + ⚠ : Notez le `--`entre le nom de l'image et la commande à lancer -### Kubernetes : Créer un déploiement en ligne de commande +### Kubernetes : Créer un déploiement (par exemple) en ligne de commande - `kubectl create deployment` ... - Depuis kubernetes 1.19, il est possible de préciser une commande au moment du `create` @@ -357,9 +380,11 @@ kubectl create deployment pingu --image=alpine -- ping 127.1 ⚠ : Notez le `--`entre le nom de l'image et la commande à lancer + + ### Kubernetes : Création d'objets Kubernetes -- Pour créer un object Kubernetes depuis votre fichier YAML, utilisez la commande `kubectl create` : +- Pour créer un object Kubernetes depuis votre fichier `YAML`, utilisez la commande `kubectl create` : ```console kubectl create -f object.yaml @@ -415,81 +440,88 @@ kubectl apply -f object.yaml ### Kubernetes : Kubernetes Dashboard -- Pour déployer le Dashboard, exécuter la commande suivante: +Étape 1: Déployer le Dashboard ```console -$ kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.2.0/aio/deploy/recommended.yaml +kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.7.0/aio/deploy/recommended.yaml ``` -- Pour accéder au Dashboard, il faut établir une communication entre votre poste et le cluster Kubernetes : - -```console - -# en local (minikube) -$ kubectl proxy - -# sur master (cloud / vm) +Étape 2: Créer un compte de service et un rôle d'administration -kubectl port-forward -n kubernetes-dashboard svc/kubernetes-dashboard 1234:443 --address 0.0.0.0 +1. Créer un fichier YAML pour le compte de service: +```yaml +# dashboard-adminuser.yaml +apiVersion: v1 +kind: ServiceAccount +metadata: + name: admin-user + namespace: kubernetes-dashboard ``` -- L'accès se fait désormais sur : +2. Appliquer le fichier YAML pour créer le compte de service: ```console +kubectl apply -f dashboard-adminuser.yaml +```` -# en local (minikube) - - - -# vm ou cloud +### Kubernetes : Kubernetes Dashboard -Utilisez l'adresse ip publique du master : et ouvir +3. Créer un fichier YAML pour le rôle d'administration: +```yaml +# admin-role-binding.yaml +apiVersion: rbac.authorization.k8s.io/v1 +kind: ClusterRoleBinding +metadata: + name: admin-user +roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: cluster-admin +subjects: +- kind: ServiceAccount + name: admin-user + namespace: kubernetes-dashboard ``` -### Kubernetes : Kubernetes Dashboard - - +4. Appliquer le fichier YAML pour créer le rôle d'administration: ```console -kubectl get secrets -n kubernetes-dashboard -kubectl describe -n kubernetes-dashboard secret kubernetes-dashboard-token-xxxx -kubectl describe -n kubernetes-dashboard secret kubernetes-dashboard-token-f68tf | grep "token:" | awk '{print $2}' -``` +kubectl apply -f admin-role-binding.yaml -![](images/kubernetes/dashboard-1.png){height="300px"} +``` ### Kubernetes : Kubernetes Dashboard - -- Authentification par token : +Étape 3: Récupérer le token d'accès ```console +kubectl -n kubernetes-dashboard create token admin-user +``` -# Création d'un compte de service admin -$ kubectl create serviceaccount -n kube-system cluster-admin-dashboard-sa +Étape 4: Accéder au Dashboard -# On donne les droits clusterAdmin a ce compte -$ kubectl create clusterrolebinding -n kube-system cluster-admin-dashboard-sa \ - --clusterrole=cluster-admin \ - --serviceaccount=kube-system:cluster-admin-dashboard-sa +Démarrer un proxy pour accéder au Dashboard: -# On récupère le token d'authentification pour ce compte -$ TOKEN=$(kubectl describe secret -n kube-system $(kubectl get secret -n kube-system | awk '/^cluster-admin-dashboard-sa-token-/{print $1}') | awk '$1=="token:"{print $2}') +```console +kubectl proxy +``` -$ echo ${TOKEN} +Cela démarre un proxy à l'adresse http://localhost:8001. -# Méthode alternative +Ouvrir le Dashboard dans votre navigateur: -$ kubectl get secret $(kubectl get serviceaccount cluster-admin-dashboard-sa -o jsonpath="{.secrets[0].name}" -n kube-system) -o jsonpath="{.data.token}" -n kube-system | base64 --decode +Accédez à l'URL suivante dans votre navigateur: -``` +http://localhost:8001/api/v1/namespaces/kubernetes-dashboard/services/https:kubernetes-dashboard:/proxy/ + +Se connecter avec le token: -Il est possible de créer des comptes de service (sa) avec droits différents ex : `view` +Lorsque vous êtes invité à vous connecter, choisissez l'option "Token" et entrez le token que vous avez récupéré à l'Étape 3. diff --git a/cours/containers/kubernetes/k8s-volumes.fr.md b/cours/containers/kubernetes/k8s-volumes.fr.md index a5cc729..195523a 100644 --- a/cours/containers/kubernetes/k8s-volumes.fr.md +++ b/cours/containers/kubernetes/k8s-volumes.fr.md @@ -10,14 +10,18 @@ - Le but de la séparation est de sortir du code du *core* de Kubernetes - GA depuis Kubernetes 1.13 + ### Kubernetes : CSI - La plupart des volumes supportés dans Kubernetes supportent maintenant CSI: - - [Amazon EBS](https://github.com/kubernetes-sigs/aws-ebs-csi-driver) - - [Google PD](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver) - - [Cinder](https://github.com/kubernetes/cloud-provider-openstack/tree/master/pkg/csi/cinder) - - [GlusterFS](https://github.com/gluster/gluster-csi-driver) - - La liste exhaustive est disponible [ici](https://kubernetes-csi.github.io/docs/drivers.html) + - [Amazon EBS](https://github.com/kubernetes-sigs/aws-ebs-csi-driver) + - [Google PD](https://github.com/kubernetes-sigs/gcp-compute-persistent-disk-csi-driver) + - [Cinder](https://github.com/kubernetes/cloud-provider-openstack/tree/master/pkg/csi/cinder) + - [GlusterFS](https://github.com/gluster/gluster-csi-driver) + - La liste exhaustive est disponible [ici](https://kubernetes-csi.github.io/docs/drivers.html) + - Drivers CSI: Chaque système de stockage nécessite un driver CSI spécifique pour s'intégrer à Kubernetes. + - Points de montage: Les drivers CSI créent des points de montage que Kubernetes peut ensuite attacher aux pods. + - Cycle de vie des volumes: Le CSI gère le cycle de vie complet des volumes (provisionnement, attachement, détachement, suppression). ### Kubernetes : Volumes @@ -224,7 +228,8 @@ spec: ### Kubernetes : PersistentVolumeClaims -- Le PVC est un binding entre un pod et un PV. Le pod demande le volume via le PVC. +- Le PVC est un binding entre un `pod` et un `PV`. Le pod demande le volume via le PVC. +- Le liage est géré automatiquement par Kubernetes. - Ressource utilisée et vue comme une requête utilisateur pour solliciter du stockage persistant en définissant : - une quantité de stockage - un type d'accès diff --git a/cours/containers/kubernetes/k8s-workloads-configuration.fr.md b/cours/containers/kubernetes/k8s-workloads-configuration.fr.md index dcc7e21..60b8ec3 100644 --- a/cours/containers/kubernetes/k8s-workloads-configuration.fr.md +++ b/cours/containers/kubernetes/k8s-workloads-configuration.fr.md @@ -6,6 +6,7 @@ - Il peut être créé d'un ensemble de valeurs ou d'un fichier ressource Kubernetes (YAML ou JSON) - Un `ConfigMap` peut être sollicité (utilisé) par plusieurs `pods` - Limité à **1MiB** de data +- Non sécurisé: Les données sont stockées en clair dans le cluster. ### Kubernetes : ConfigMaps diff --git a/templates/template.revealjs b/templates/template.revealjs index 8836b73..2907552 100644 --- a/templates/template.revealjs +++ b/templates/template.revealjs @@ -95,12 +95,17 @@ $body$ - + $for(include-after)$