Contactez-nous

Les fondations de Kubernetes : cours accéléré

Formation Kubernetes accélérée pour débutants. Maîtrisez les bases, déployez des apps et devenez opérationnel rapidement. Compétences essentielles.

Table des matières

  1. Introduction et mise en place
    1. Pourquoi Kubernetes ?
      1. Les défis de la gestion des applications modernes (avant K8s)
      2. Philosophie et principes clés : orchestration, déclaratif, auto-réparation
      3. Importance de Kubernetes dans l'écosystème Cloud Native
    2. Vocabulaire essentiel pour débuter
      1. Conteneurs (rappel rapide sur Docker/OCI)
      2. Cluster, Noeud (Node), Pod, Service, Déploiement (Deployment), Namespace
      3. API Kubernetes et `kubectl` : l'interface de commande
    3. Préparer votre environnement de travail local
      1. Installation de `kubectl` (l'outil de ligne de commande)
      2. Mise en place d'un cluster Kubernetes local simple (Minikube ou Kind)
      3. Vérification de l'installation et première connexion au cluster
  2. Les briques essentielles de Kubernetes
    1. Le Pod : l'unité de base
      1. Qu'est-ce qu'un Pod ? (un ou plusieurs conteneurs)
      2. Cycle de vie simplifié d'un Pod
      3. Exemple concret : créer un Pod simple (ex: Nginx) via `kubectl run` (approche impérative simple)
    2. Le Déploiement (Deployment) : gérer vos applications
      1. Rôle du Déploiement : maintenir l'état désiré (nombre de réplicas)
      2. Concept de ReplicaSet (géré par le Déploiement)
      3. Exemple concret : créer un Déploiement pour plusieurs Pods Nginx
    3. Le Service : exposer vos applications
      1. Pourquoi a-t-on besoin des Services ? (IP de Pod volatile)
      2. Types de Services essentiels : ClusterIP, NodePort, LoadBalancer (focus sur NodePort pour le local)
      3. Exemple concret : exposer le Déploiement Nginx via un Service NodePort
  3. Le processus clé : déployer une application avec YAML
    1. L'approche déclarative avec les manifestes YAML
      1. Qu'est-ce qu'un manifeste Kubernetes ?
      2. Structure de base d'un fichier YAML (apiVersion, kind, metadata, spec)
      3. Avantages de l'approche déclarative (répétabilité, versionnement)
    2. Séquence de déploiement typique
      1. Ecrire un manifeste simple pour un Déploiement
      2. Appliquer le manifeste avec `kubectl apply -f `
      3. Vérifier l'état des ressources (`kubectl get pods,deploy,svc`)
      4. Accéder à l'application via le Service
      5. Supprimer les ressources avec `kubectl delete -f `
  4. Outils essentiels et dépannage courant
    1. Maîtriser `kubectl` pour l'opérationnel
      1. Commandes indispensables : `get`, `describe`, `logs`, `apply`, `delete`, `exec`
      2. Utiliser `describe` pour investiguer un problème (Pod, Service...)
      3. Consulter les logs d'un conteneur avec `logs`
      4. Se connecter à un conteneur avec `exec` (pour du debug avancé)
    2. Identifier et résoudre les erreurs fréquentes
      1. Pod en état `Pending` : causes courantes (ressources, noeud indisponible)
      2. Pod en état `CrashLoopBackOff` / `Error` : vérifier les logs applicatifs
      3. Erreur `ImagePullBackOff` : nom d'image incorrect, registre inaccessible
      4. Service inaccessible : vérifier les sélecteurs et les ports
      5. Erreurs de syntaxe YAML
  5. Bonnes pratiques fondamentales
    1. Organisation et configuration
      1. Toujours utiliser des manifestes YAML (approche déclarative)
      2. Versionner vos manifestes (avec Git)
      3. Utiliser les Labels et Selectors pour lier les ressources
      4. Introduction aux Namespaces pour l'isolation logique (utiliser autre chose que `default`)
    2. Fiabilité et performance (introduction)
      1. Importance des Liveness & Readiness Probes (assurer la santé applicative)
      2. Définir les requêtes et limites de ressources (CPU/Mémoire) - pourquoi c'est important
  6. Atelier pratique guidé
    1. Exercice 1 : Déployer une application web simple
      1. Ecriture du manifeste YAML pour un Déploiement (ex: image `httpd` ou `nginx` customisée)
      2. Ecriture du manifeste YAML pour un Service (type NodePort)
      3. Déploiement avec `kubectl apply`
      4. Vérification du statut et accès à l'application via le navigateur
      5. Consultation des logs du Pod
    2. Exercice 2 : Mise à jour et mise à l'échelle
      1. Modifier le manifeste du Déploiement (ex: changer la version de l'image)
      2. Appliquer la mise à jour (`kubectl apply`) et observer le déploiement progressif
      3. Mettre à l'échelle le Déploiement (`kubectl scale deployment ... --replicas=X` ou via le manifeste)
      4. Observer le nombre de Pods
      5. Nettoyage des ressources (`kubectl delete`)
    3. Prochaines étapes
      1. Pistes pour approfondir (Volumes, ConfigMaps, Secrets, Helm...)
      2. Ressources utiles (documentation officielle, tutoriels)