Le paysage numérique moderne est marqué par une croissance rapide des applications, des services et des solutions cloud, ce qui nécessite une utilisation efficace des ressources. Face à l'augmentation des besoins en calcul et à la nécessité d'optimisation, des outils permettant :
- Déploiement plusieurs applications sur le même matériel.
- Gérant Ressources (CPU, RAM, stockage) avec une surcharge minimale.
- Assurer isolement et sécurité des charges de travail.
La première étape pour relever ces défis a été hyperviseurs, qui permettait l'exécution de machines virtuelles isolées. Cependant, avec l'essor de la conteneurisation, le besoin de solutions plus flexibles et plus légères est apparu. C'est pourquoi Kubernetes a été créé.
Définition
Kubernetes (K8s) est une plateforme open source permettant d'orchestrer des applications conteneurisées. Ses principales fonctionnalités incluent :
- Automatiser déploiement, mise à l'échelle et gestion des applications.
- Optimisation
utilisation des ressources du cluster.
- Assurer tolérance aux pannes et auto-réparation.
Développé à l'origine par Google sur la base de son Borg , Kubernetes est devenu un Cloud Native Computing Foundation (CNCF) projet en 2014. Aujourd'hui, c'est la norme pour la gestion des systèmes distribués dans les environnements hybrides et multi-cloud.
Pourquoi Choisir Kubernetes Au lieu d’hyperviseurs ?
Contrairement aux hyperviseurs, qui fonctionnent avec des machines virtuelles, Kubernetes fonctionne avec conteneurs— des processus légers et rapides à démarrer, partageant un noyau de système d'exploitation. Cela offre :
- Densité de charge de travail plus élevée.
- Frais généraux minimes.
- Portabilité des applications entre environnements.
Objet
KubernetesSon objectif principal est d'automatiser le déploiement, la mise à l'échelle et la gestion des applications conteneurisées, notamment l'auto-réparation, l'équilibrage de charge, la gestion du stockage, la sécurité et la prise en charge des environnements hybrides. Il garantit la tolérance aux pannes, l'optimisation des ressources et la gestion unifiée des applications sur l'ensemble de l'infrastructure cloud ou sur site.
Kubernetes répond à plusieurs défis critiques :
1. Élimine la fragilité du conteneur en surveillant et en restaurant les conteneurs défaillants.
2. Automatise la mise à l'échelle manuelle, permettant l'allocation des ressources sans interruption de service.
3. Réduit et automatise la complexité de la configuration du réseau.
4. Améliore l'efficacité des ressources, minimisant la capacité inutilisée.
Concepts de base
1. Déploiement — Gère le cycle de vie des Pods : gère le déploiement, la mise à l'échelle et les mises à jour des applications.
2. Cosse — La plus petite unité dans Kubernetes, exécutant un ou plusieurs conteneurs avec des ressources réseau/stockage partagées.
3. Services — Une abstraction fournissant un accès stable aux Pods via l'équilibrage de charge et DNS.
4. ConfigMap et Secret — Stockez les configurations (ConfigMap) et les données sensibles (Secret) pour une utilisation sécurisée dans les applications.
5. Volume — Fournit un stockage persistant pour les pods, survivant aux redémarrages.
6. Espace de noms — Partitionne logiquement un cluster en environnements isolés (par exemple, dev/prod) pour le contrôle d'accès et la gestion des ressources.
Architecture
Kubernetes l'architecture est divisée en deux parties :
1. Avion de contrôle — Gère le cluster.
2.Nœuds de travail — Exécuter les charges de travail et les tâches.
Déploiement et gestion Kubernetes
Exigences pour Kubernetes Déploiement
Pour déployer une solution entièrement fonctionnelle Kubernetes cluster, vous avez besoin de :
1. Au moins un nœud de plan de contrôle (maître) et plusieurs nœuds de travail.
2. Unique adresses IP pour chaque nœud.
3. Configuration matérielle minimale2 vCPU cœurs et 2 Go de RAM par nœud.
4. Connectivité réseau entre tous les nœuds.
Pose Kubernetes (k8s) :
1. Mettre à jour le système et installer les dépendances
Pour atténuer les vulnérabilités et installer des packages (apt-transport-https, gnupg2) requis pour Kubernetes et les référentiels CRI-O :
apt-get install -yapt-transport-https gnupg22. Désactiver la mémoire d'échange
- Empêche les conflits de gestion de la mémoire dans Kubernetes. Swap peut déclencher des erreurs OOM Killer et réduire les performances.
swapoff -a # Temporarily disable swap rm /swap.img # Remove swap file sed -i '/swap/d' /etc/fstab # Comment out swap in /etc/fstab3. Activer les modules du noyau br_netfilter et revêtement
- br_netfilter active le filtrage réseau pour les plugins CNI.
- revêtement prend en charge les systèmes de fichiers superposés (requis pour le stockage des conteneurs).
modprobe br_netfilter overlayecho "br_netfilter" >> /etc/modulesecho "overlay" >> /etc/modules4. Configurer la redirection IP
Permet le routage du trafic réseau entre les pods et les nœuds.
echo 1 > /proc/sys/net/ipv4/ip_forward5. Installer Kubelet, Kubeadm, une parure de bijoux de mariage, des kubectl
Kubelet: Agent pour l'exécution de Pods sur des nœuds.
Kubeadm: Outil d'initialisation des clusters.
kubectl: CLI pour la gestion des clusters.
apt-get install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl # Bloquer les mises à jour automatiques
6. Installer CRI-O (Container Runtime)
Exécution légère compatible avec Kubernetes IRC.
echo "deb https://download.opensuse.org/.../ /" > /etc/apt/sources.list.d/cri-o.list
apt-get update
apt-get install -y cri-o cri-o-runc
systemctl active crio && systemctl démarre crio
7. Initialisez le cluster avec `Kubeadm`
Déploie le plan de contrôle (API Serveur, etcd, planificateur, gestionnaire de contrôleur).
kubeadm init --pod-network-cidr=10.100.0.0/16 # Assign Pod IP range8. Rejoindre un nœud Worker
Développez le cluster pour exécuter des applications. Utilisez le jeton de kubeadm init sortie:
kubeadm join :6443 --token --discovery-token-ca-cert-hash 9. Configurer kubectl Accéder
Gérez le cluster depuis votre machine locale :
mkdir -p $HOME/.kube
sudo cp /etc/kubernetes/admin.conf $HOME/.kube/configGérant Kubernetes
Core kubectl Commandes
Gestion des ressources
Affichage du statut:
kubectl get pods # List Pods
kubectl get nodes # List nodes
kubectl get deployments # List Deployments
kubectl describe pod # Show Pod details Création/Mise à jour:
kubectl apply -f deployment.yaml # Déployer à partir d'un manifeste
kubectl create deployment nginx --image=nginx:1.25 # Créer un déploiement
écaillage:
kubectl scale deployment/nginx --replicas=5 # Augmenter le nombre de répliques
Mises à jour et restaurations:
kubectl set image deployment/nginx nginx=nginx:1.26 # Update the container image
kubectl rollout undo deployment/nginx # Roll back changesSuppression:
kubectl delete pod kubectl delete -f deployment.yaml # Delete resources defined in a manifest Débogage
Journaux de conteneurs :
kubectl logs # Logs of the main container
kubectl logs -c # Logs of a specific container Accéder à un conteneur:
kubectl exec -it -- sh Surveillance des ressources:
kubectl top nodes # View CPU/RAM usage of nodes
kubectl top pods # View CPU/RAM usage of PodsGestion des configurations et des secrets
Carte de configuration
Utilisé pour stocker les configurations (variables d'environnement, fichiers).
Mise en situation :
apiVersion: v1
kind: ConfigMap
metadata:
name: app-config
data:
app.env: |
LOG_LEVEL=INFO
DB_HOST=postgressecret
Utilisé pour stocker des données sensibles (mots de passe, certificats TLS).
- Exemple:
apiVersion: v1
kind: Secret
metadata:
name: db-secret
type: Opaque
data:
password: dGVzdC1wYXNzd29yZA== # base64-encodedUtilisation dans les pods
env:
- name: LOG_LEVEL
valueFrom:
configMapKeyRef:
name: app-config
key: LOG_LEVEL
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-secret
key: passwordGestion du stockage
Volumes persistants (PV) et revendications de volume persistant (PVC)
- PV:Ressource de stockage physique (par exemple, disque cloud).
- PVC: Demande d'allocation de stockage à partir d'un PV.
- Exemple de PVC:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: data-pvc
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10GiUtilisation dans les pods
volumes:
- name: data-storage
persistentVolumeClaim:
claimName: data-pvc
containers:
- name: app
volumeMounts:
- mountPath: "/data"
name: data-storageSécurité
RBAC (Contrôle d'accès basé sur les rôles)
Gère les droits d'accès des utilisateurs et des services.
- Exemple de rôle :
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
namespace: default
name: pod-reader
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["get", "list", "watch"]Politiques de réseau
Restreint le trafic réseau entre les pods.
- Exemple: Bloquer tout le trafic entrant
yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-all-ingress
spec:
podSelector: {}
policyTypes:
- IngressSurveillance et journalisation
Outils
Prometheus + Grafana: Collecter des métriques (CPU, RAM, trafic réseau).
Pile EFK (Elasticsearch, Fluentd, Kibana):Agréger et analyser les journaux.
Kubernetes Tableau de bord:Interface Web pour la gestion des clusters.
Configuration de la surveillance
Installer Prometheus via Helm
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus prometheus-community/prometheusAutomatisation et CI/CD
GitOpérations avec Argo CD
Déployer automatiquement des applications à partir d'un Git dépôt.
Exemple:
argocd app create my-app --repo https://github.com/user/repo --path manifestsIntégration avec Jenkins/GitLab CI
# .gitlab-ci.yml
deploy:
stage: deploy
script:
- kubectl apply -f k8s/Dépannage
Vérifier les événements du cluster :
kubectl get events --sort-by=.metadata.creationTimestampVérifier l'état du nœud:
kubectl describe node # View node resources and issues Diagnostic réseau:
kubectl run -it --rm debug --image=nicolaka/netshoot -- sh # Run a network debug container
