Formation Plateforme Kubernetes avec OpenShift

Programme de notre formation Plateforme Kubernetes avec OpenShift

[Jour 1 - Matin]

Architecture Kubernetes et plateforme OpenShift

• Positionner Red Hat OpenShift dans l'écosystème Kubernetes et des plateformes Cloud Native
• Comprendre l'architecture d'un cluster Kubernetes et OpenShift : Control Plane, Worker Nodes et composants d'infrastructure
• Identifier les rôles de l'API Server, d'etcd, du Scheduler et des contrôleurs Kubernetes
• Distinguer les fonctionnalités natives de Kubernetes et les services complémentaires d'OpenShift : Routes, registre d'images intégré et Operators
• Comprendre le rôle des Operators et de l'Operator Lifecycle Manager dans la gestion des composants
• Prendre en main la console Web OpenShift et ses perspectives Administrator et Developer
• Atelier pratique : se connecter à un cluster OpenShift, explorer les composants Kubernetes et les Operators installés, puis identifier les ressources nécessaires à l'hébergement d'une application d'entreprise.

Administrer les ressources Kubernetes et les projets OpenShift

• Comprendre le fonctionnement des Namespaces Kubernetes et leur correspondance avec les Projects OpenShift
• Créer et administrer des projets avec la console Web et les interfaces en ligne de commande kubectl et oc
• Comparer les commandes kubectl et oc pour consulter, créer et modifier les ressources Kubernetes
• Comprendre la structure des manifestes YAML et les objets fondamentaux de l'API Kubernetes
• Organiser les ressources avec les Labels, Selectors et Annotations
• Découvrir les mécanismes de partage et d'isolation des ressources entre projets OpenShift
• Atelier pratique : créer un projet OpenShift dédié à l'application, explorer les ressources Kubernetes avec kubectl et oc, puis préparer et appliquer les premiers manifestes YAML.

[Jour 1 - Après-midi]

Déployer des applications Kubernetes avec OpenShift

• Comprendre le fonctionnement des Pods, ReplicaSets et Deployments Kubernetes
• Déployer une application conteneurisée à partir d'une image existante et d'un manifeste YAML
• Créer et administrer des Deployments avec kubectl, oc et la console OpenShift
• Configurer les Services Kubernetes pour permettre la communication entre les workloads
• Comprendre les mécanismes d'exposition des applications Kubernetes et les spécificités des Routes OpenShift
• Exposer une application HTTP/HTTPS avec une Route OpenShift et configurer la terminaison TLS
• Diagnostiquer les problèmes courants de déploiement et de connectivité entre Pods et Services
• Atelier pratique : déployer l'application à partir de manifestes Kubernetes, créer un Service, configurer une Route OpenShift et vérifier son accessibilité depuis l'extérieur du cluster.

Gérer la configuration et le stockage Kubernetes sur OpenShift

• Externaliser les paramètres applicatifs avec les ConfigMaps Kubernetes
• Gérer les informations sensibles avec les Secrets Kubernetes et comprendre leurs limites de sécurité
• Injecter des variables d'environnement et monter des fichiers de configuration dans les Pods
• Comprendre les mécanismes de stockage éphémère et persistant des conteneurs Kubernetes
• Utiliser les PersistentVolumes, PersistentVolumeClaims et StorageClasses
• Configurer le stockage persistant d'une application sur OpenShift à partir des ressources Kubernetes
• Atelier pratique : enrichir l'application avec des ConfigMaps et Secrets, créer une PersistentVolumeClaim et vérifier la conservation des données après recréation d'un Pod.

[Jour 2 - Matin]

Construire des images et gérer les builds OpenShift pour Kubernetes

• Comprendre le cycle de construction, de publication et de déploiement d'une application Kubernetes
• Distinguer les mécanismes de déploiement Kubernetes des fonctionnalités de construction d'images proposées par OpenShift
• Découvrir les stratégies de build OpenShift : Source-to-Image (S2I) et Dockerfile
• Configurer des BuildConfigs pour automatiser la construction des images
• Utiliser les ImageStreams et ImageStreamTags pour gérer les versions des images
• Exploiter le registre d'images intégré et comprendre les mécanismes d'authentification
• Comprendre comment les images construites alimentent les Deployments Kubernetes et leurs mises à jour
• Atelier pratique : construire une nouvelle version de l'application à partir de son code source, exécuter un build OpenShift, publier l'image dans le registre intégré et préparer son utilisation par un Deployment Kubernetes.

Industrialiser les déploiements Kubernetes avec OpenShift Pipelines

• Comprendre les principes de l'intégration continue et du déploiement continu des applications Kubernetes
• Découvrir Red Hat OpenShift Pipelines et son fonctionnement basé sur Tekton
• Comprendre l'intégration de Tekton à Kubernetes à travers les Custom Resource Definitions (CRD)
• Identifier les ressources Tekton : Tasks, Pipelines, TaskRuns et PipelineRuns
• Comprendre les étapes d'un pipeline : récupération du code, build, tests et déploiement Kubernetes
• Définir les paramètres, les Workspaces et les dépendances entre Tasks
• Exécuter et superviser un pipeline depuis la console OpenShift et les outils en ligne de commande
• Atelier pratique : créer un pipeline Tekton pour récupérer le code de l'application, exécuter des contrôles automatisés et préparer la mise à jour de ses ressources Kubernetes sur OpenShift.

[Jour 2 - Après-midi]

Automatiser les déploiements Kubernetes avec OpenShift Pipelines

• Automatiser les étapes de construction, de validation et de déploiement des applications Kubernetes
• Configurer les Tasks et PipelineRuns pour orchestrer les différentes étapes de livraison
• Déployer et mettre à jour des ressources Kubernetes à partir de manifestes YAML exécutés par un pipeline
• Découvrir Tekton Triggers et les mécanismes de déclenchement sur événements Git
• Comprendre les principes de Pipelines as Code pour versionner les définitions des pipelines avec le code source
• Gérer les paramètres, Secrets et ServiceAccounts Kubernetes nécessaires à l'exécution des pipelines
• Consulter les résultats d'exécution et diagnostiquer les échecs d'un pipeline
• Atelier pratique : compléter le pipeline de l'application pour automatiser son build, ses tests et la mise à jour de son Deployment Kubernetes, puis déclencher une nouvelle livraison à partir d'une modification du dépôt Git.

Gérer les mises à jour et la disponibilité des applications Kubernetes

• Comprendre les mécanismes de mise à jour des Deployments Kubernetes et les stratégies RollingUpdate et Recreate
• Mettre à jour une application à partir d'une nouvelle image de conteneur
• Suivre les opérations de rollout et effectuer un rollback en cas d'incident avec kubectl et oc
• Configurer les sondes de santé Kubernetes : Liveness, Readiness et Startup Probes
• Définir les ressources CPU et mémoire des conteneurs avec Requests et Limits
• Comprendre les principes de réplication, de disponibilité et de remplacement automatique des Pods
• Vérifier la disponibilité de l'application et le comportement des Services pendant les mises à jour
• Atelier pratique : déployer une nouvelle version de l'application à l'aide du pipeline CI/CD, configurer ses sondes de santé, observer une RollingUpdate et simuler une anomalie nécessitant un rollback Kubernetes.

[Jour 3 - Matin]

Sécuriser les applications Kubernetes avec OpenShift

• Comprendre les mécanismes de sécurité natifs de Kubernetes et les protections complémentaires d'OpenShift
• Identifier les mécanismes d'authentification et d'autorisation des utilisateurs
• Gérer les utilisateurs, groupes et ServiceAccounts
• Configurer les permissions Kubernetes avec RBAC : Roles, ClusterRoles et RoleBindings
• Distinguer les SecurityContexts Kubernetes des Security Context Constraints (SCC) spécifiques à OpenShift
• Appliquer le principe du moindre privilège et limiter les permissions des conteneurs
• Comprendre les restrictions d'exécution des Pods et les contraintes liées aux identifiants utilisateurs
• Atelier pratique : sécuriser l'application en configurant ses ServiceAccounts, attribuer des permissions RBAC adaptées, puis vérifier la conformité des Pods aux contraintes de sécurité OpenShift.

Gérer l'isolation des projets Kubernetes et les quotas de ressources

• Comprendre les principes de multitenancy et de séparation des environnements avec les Namespaces Kubernetes et les Projects OpenShift
• Définir des ResourceQuotas Kubernetes pour limiter la consommation des ressources par projet
• Configurer les LimitRanges pour encadrer les ressources CPU et mémoire des workloads
• Comprendre les mécanismes de communication réseau entre Pods, Services et Namespaces Kubernetes
• Configurer des NetworkPolicies Kubernetes pour isoler les applications et limiter les flux autorisés
• Identifier les problèmes de déploiement liés aux quotas, aux permissions et aux politiques réseau
• Atelier pratique : créer un second projet OpenShift, appliquer des quotas Kubernetes et des NetworkPolicies, puis vérifier que l'application respecte les limites de ressources et les restrictions de communication entre projets.

[Jour 3 - Après-midi]

Superviser et dimensionner les workloads Kubernetes sur OpenShift

• Comprendre les mécanismes de mise à l'échelle des Pods et Deployments Kubernetes
• Adapter manuellement le nombre de réplicas d'une application avec kubectl et oc
• Configurer le Horizontal Pod Autoscaler (HPA) Kubernetes selon les métriques CPU et mémoire disponibles
• Découvrir les fonctionnalités de supervision intégrées à OpenShift et le monitoring des applications utilisateur
• Consulter les métriques, événements et journaux Kubernetes depuis la console Web, kubectl et oc
• Comprendre les principes de collecte des métriques avec Prometheus et de visualisation des performances
• Diagnostiquer les erreurs courantes : CrashLoopBackOff, ImagePullBackOff, Pods Pending et dépassement des ressources
• Atelier pratique : configurer l'autoscaling Kubernetes de l'application, simuler une montée en charge, observer les métriques depuis OpenShift et analyser les événements et journaux pour corriger un dysfonctionnement.

Exploiter et industrialiser une plateforme Kubernetes avec OpenShift

• Organiser les Namespaces, Projects, ressources Kubernetes et accès pour plusieurs environnements
• Comprendre le rôle des Operators Kubernetes et OpenShift dans l'installation et la gestion des services complémentaires
• Appliquer les bonnes pratiques de gestion des images, des manifestes YAML, des ConfigMaps et des Secrets
• Contrôler l'état des Pods, Deployments, Services, Routes et pipelines avec kubectl, oc et la console OpenShift
• Identifier les points de vigilance en production : disponibilité, sécurité, quotas, stockage et supervision
• Structurer le cycle de vie d'une application Kubernetes, du code source à son exploitation sur OpenShift
• Atelier pratique : réaliser un scénario complet d'exploitation de l'application. Vérifier ses Deployments, Services, Routes, configurations, permissions RBAC, stockage persistant, pipeline CI/CD et mécanismes d'autoscaling.