Kubernetes

Kubernetes, souvent appelé K8s, est une plateforme open source conçue pour automatiser le déploiement, la mise à l'échelle et la gestion d'applications conteneurisées. Développé à l'origine par Google désormais maintenu par la Cloud Native Computing Foundation (CNCF), Kubernetes est devenu la norme pour l' orchestration de logiciels dans le cloud. Dans le contexte de l' intelligence artificielle (IA) et de l' apprentissage automatique (ML), il sert de couche d'infrastructure critique qui permet aux équipes d'ingénieurs de gérer des flux de travail complexes, de la formation distribuée à l'inférence de production à haute disponibilité . En abstraisant le matériel sous-jacent, Kubernetes garantit que les applications fonctionnent de manière fiable et efficace, qu'elles soient hébergées sur site ou via des fournisseurs de cloud public.

Architecture et concepts fondamentaux

Au cœur de Kubernetes se trouve une architecture en cluster, qui consiste en un ensemble de machines de travail appelées nœuds. Ces nœuds exécutent des charges de travail de conteneurisation, tandis qu' un plan de contrôle gère l'état global du cluster. La plus petite unité déployable dans Kubernetes est un « pod », qui encapsule un ou plusieurs conteneurs partageant des ressources de stockage et de réseau. Cette abstraction est essentielle pour les applications de vision par ordinateur, car elle permet aux développeurs de regrouper les dépendances, telles que CUDA spécifiques pour les processeurs graphiques (GPU)— dans un environnement cohérent. Les principaux services cloud tels que Amazon Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS) et Google Engine (GKE) fournissent des versions gérées de cette architecture, simplifiant ainsi la charge de maintenance pour les équipes de science des données.

Pourquoi Kubernetes est important pour l'IA

La principale valeur ajoutée de Kubernetes dans le domaine des opérations d'apprentissage automatique (MLOps) réside dans sa capacité à gérer des charges de travail dynamiques. Les modèles d'IA nécessitent souvent une puissance de calcul considérable pendant la phase d'entraînement et une faible latence d'inférence pendant le déploiement.

• Évolutivité : Kubernetes utilise l'autoscaling pour ajuster automatiquement les ressources. En cas de pic soudain de trafic, l'Horizontal Pod Autoscaler peut augmenter le nombre de pods d'inférence afin de maintenir l' évolutivité sans intervention manuelle.
• Optimisation des ressources : il est essentiel d'allouer efficacement le matériel coûteux. Kubernetes permet GPU fractionné GPU et l'affinité des nœuds, garantissant ainsi que les modèles d'apprentissage profond ne consomment des ressources que lorsque les tâches actives les requièrent.
• Déploiement résilient : il est essentiel de garantir une haute disponibilité pendant le déploiement du modèle. En cas de défaillance d'un nœud, Kubernetes redémarre automatiquement les pods concernés sur des nœuds sains, évitant ainsi toute interruption des services API critiques.

Applications concrètes

Kubernetes est la colonne vertébrale de nombreuses implémentations d'IA à grande échelle dans divers secteurs :

1. Gestion du trafic dans les villes intelligentes : une municipalité peut déployer les modèles Ultralytics pour analyser les flux vidéo provenant de milliers d'intersections. Grâce à Kubernetes, le système peut augmenter dynamiquement les ressources pendant les heures de pointe afin de gérer la charge accrue de détection d'objets, puis les réduire la nuit afin de réduire les coûts. Cette approche est fondamentale pour les systèmes modernes de gestion du trafic.
2. Personnalisation du commerce électronique : les détaillants en ligne utilisent des systèmes de recommandation complexes basés sur des microservices. Un service peut gérer la génération de candidats tandis qu'un autre gère le reclassement. Kubernetes orchestre ces différents services, permettant aux équipes de mettre à jour le classement du réseau neuronal de manière indépendante sans perturber l' expérience d'achat dans son ensemble, facilitant ainsi l'intégration continue.

Différencier Kubernetes et Docker

Un point de confusion courant est la relation entre Kubernetes et Docker. Il ne s'agit pas de technologies concurrentes, mais plutôt de technologies complémentaires. Docker est un outil permettant de créer et d'exécuter des conteneurs individuels (en encapsulant l'application), tandis que Kubernetes est un outil permettant de gérer un parc de ces conteneurs sur plusieurs machines. Vous utilisez Docker pour intégrer les pondérations et le code de votre modèle dans une image, puis vous utilisez Kubernetes pour déterminer où, quand et combien de copies de cette image sont exécutées en production.

Exemple : Script d'inférence pour la conteneurisation

Pour déployer un modèle sur Kubernetes, les développeurs commencent généralement par un Python qui sert de point d'entrée pour le conteneur. Le code suivant illustre une tâche d'inférence simple utilisant le modèle Ultralytics . Ce script s'exécuterait dans un pod, traitant les requêtes entrantes.

from ultralytics import YOLO

# Load the lightweight YOLO26 model
model = YOLO("yolo26n.pt")

# Perform inference on an image source
# In a K8s pod, this would likely process API payloads
results = model("https://ultralytics.com/images/bus.jpg")

# Output the detection count for logging
print(f"Detected {len(results[0].boxes)} objects in the frame.")

Outils et écosystème

L'écosystème Kubernetes comprend une vaste gamme d'outils adaptés à la science des données. Kubeflow est une boîte à outils populaire dédiée à rendre les déploiements de workflows ML sur Kubernetes simples, portables et évolutifs. Pour surveiller la santé des clusters et les métriques des applications, les ingénieurs s'appuient souvent sur Prometheus. Afin de simplifier davantage la complexité de la formation et du déploiement des modèles dans ces environnements, la Ultralytics offre une interface unifiée qui automatise la gestion des ensembles de données et la formation des modèles, permettant aux utilisateurs d'exporter des modèles prêts à l'emploi pour les clusters de cloud computing. De plus, des gestionnaires de paquets tels que Helm aident à gérer les applications Kubernetes complexes grâce à des graphiques réutilisables.