0Pricing
Learn AI with Python · Leçon

Mise à l’échelle et autoscaling des points de terminaison de modèles

HPA Kubernetes pour les pods de modèles, mise à l’échelle selon le trafic, déploiement A/B, mises en production canari.

Mise à l’échelle et autoscaling des points de terminaison de modèles est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.

Pourquoi la mise à l'échelle automatique

Le trafic d'inférence est rarement stable. Prévoir la capacité pour la charge maximale gaspille de l'argent la nuit ; la prévoir pour la charge moyenne entraîne des défaillances aux heures de pointe. La mise à l'échelle automatique ajuste automatiquement le nombre de répliques en fonction de la demande : vous payez ainsi ce que vous utilisez tout en conservant une bonne réactivité.

Pods et répliques

Sur Kubernetes, un serveur de modèles s'exécute sous la forme d'un déploiement composé de pods identiques (répliques). Mettre à l'échelle consiste à modifier le nombre de répliques. Un service répartit les requêtes entre toutes les répliques disponibles.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: model-server
spec:
  replicas: 2
  template:
    spec:
      containers:
        - name: server
          image: my-model:latest

Horizontal Pod Autoscaler

Le Horizontal Pod Autoscaler (HPA) surveille une métrique et ajoute ou retire des pods pour la maintenir près d'une valeur cible. La métrique classique est l'utilisation du CPU.

HPA selon l'utilisation du CPU

targetCPUUtilizationPercentage indique au HPA de maintenir la moyenne d'utilisation du CPU près d'une valeur cible. Si les pods utilisent en moyenne 80 % du CPU et que la cible est de 50 %, le HPA augmente le nombre de répliques jusqu'à ce que l'utilisation revienne vers 50 %.

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: model-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: model-server
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

Limites de la mise à l'échelle fondée sur le CPU

Le CPU est un indicateur indirect peu fiable pour certaines charges de travail. Un modèle GPU peut être limité par le GPU alors que l'utilisation du CPU reste faible, ou un processus asynchrone peut avoir une file d'attente qui s'allonge alors que le CPU est inactif. Dans ces cas, mettez plutôt à l'échelle selon un signal propre à la charge de travail.

KEDA pour la mise à l'échelle pilotée par les événements

KEDA (mise à l'échelle automatique de Kubernetes pilotée par les événements) s'appuie sur des métriques externes telles que la longueur d'une file d'attente, le retard Kafka ou des requêtes Prometheus. Il peut même réduire le nombre de répliques à zéro lorsqu'il n'y a aucun travail, ce que le HPA ne peut pas faire seul.

ScaledObject KEDA fondé sur une file d'attente

Ce ScaledObject KEDA ajoute des processus lorsque la file de messages s'allonge. Chaque unité de retard dans queueLength déclenche l'ajout d'une réplique, afin que le consommateur puisse absorber les pics.

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: inference-worker
spec:
  scaleTargetRef:
    name: inference-worker
  minReplicaCount: 0
  maxReplicaCount: 20
  triggers:
    - type: rabbitmq
      metadata:
        queueName: inference
        queueLength: "10"

Répartition de charge avec une entrée

Le trafic externe atteint vos pods par l'intermédiaire d'une entrée. Un contrôleur d'entrée nginx termine TLS et répartit les requêtes entre les répliques prises en charge par le service ; toute augmentation du nombre de répliques permet donc de répartir immédiatement la charge.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: model-ingress
spec:
  ingressClassName: nginx
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /predict
            pathType: Prefix
            backend:
              service:
                name: model-server
                port:
                  number: 8000

Déploiements sûrs : canari

Déployer une nouvelle version du modèle sur l'ensemble du trafic en une seule fois est risqué. Un déploiement canari envoie une petite partie du trafic vers la nouvelle version, en surveille les métriques, puis augmente progressivement cette part.

Canari avec pondération du trafic

Les annotations canari de l'entrée nginx acheminent un pourcentage des requêtes vers un second déploiement. Commencez à 10 %, vérifiez le taux d'erreur et la latence, puis augmentez progressivement le poids jusqu'à 100 %.

metadata:
  annotations:
    nginx.ingress.kubernetes.io/canary: "true"
    nginx.ingress.kubernetes.io/canary-weight: "10"

Assembler la mise à l'échelle

Une configuration robuste combine tous ces éléments :

  • HPA ou KEDA définit le nombre de répliques en fonction de la demande
  • Entrée répartit la charge entre les répliques
  • Les pondérations canari déploient les nouvelles versions en toute sécurité

Ensemble, ils fournissent un service de modèles élastique, résilient et peu risqué.

Vérification rapide

Vérifiez vos connaissances sur la mise à l'échelle.

Récapitulatif

Vous avez appris à mettre à l'échelle les points de terminaison de modèles :

  • Le HPA avec targetCPUUtilizationPercentage effectue la mise à l'échelle selon le CPU
  • KEDA effectue la mise à l'échelle selon la longueur de la file et prend en charge la réduction à zéro
  • L'entrée nginx répartit la charge entre les répliques
  • Les pondérations canari déplacent progressivement le trafic pour des déploiements sûrs

Questions Fréquemment Posées

La leçon « Mise à l’échelle et autoscaling des points de terminaison de modèles » est-elle gratuite ?

Oui — le texte complet de « Mise à l’échelle et autoscaling des points de terminaison de modèles » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mise à l’échelle et autoscaling des points de terminaison de modèles » ?

HPA Kubernetes pour les pods de modèles, mise à l’échelle selon le trafic, déploiement A/B, mises en production canari. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn AI with Python ?

Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Mise à l’échelle et autoscaling des points de terminaison de modèles » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?

Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Conteneuriser des modèles d’apprentissage automatique avec Docker
  2. Déploiement cloud : AWS SageMaker
  3. Service haute performance avec Triton Inference Server
  4. Mise à l’échelle et autoscaling des points de terminaison de modèles
← Retour à Learn AI with Python