0Pricing
Learn AI with Python · Aula

Escalonamento e escalonamento automático de endpoints de modelos

HPA do Kubernetes para pods de modelos, escalonamento baseado no tráfego, implantação A/B e versões canário.

Escalonamento e escalonamento automático de endpoints de modelos é uma aula grátis de Learn AI with Python no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn AI with Python, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn AI with Python inclui 4 aulas no total.

Por que usar o dimensionamento automático

O tráfego de inferência raramente é constante. Provisionar recursos para a carga de pico desperdiça dinheiro à noite; provisionar recursos para a carga média causa falhas no pico. O dimensionamento automático ajusta automaticamente a quantidade de réplicas com base na demanda, para que você pague pelo que usa e mantenha a capacidade de resposta.

Pods e réplicas

No Kubernetes, um servidor de modelos é executado como uma implantação de pods idênticos (réplicas). Dimensionar significa alterar a quantidade de réplicas. Um serviço distribui as solicitações entre as réplicas existentes.

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

HorizontalPodAutoscaler

O Horizontal Pod Autoscaler (HPA) observa uma métrica e adiciona ou remove pods para mantê-la próxima de um alvo. A métrica clássica é a utilização da CPU.

HPA na utilização da CPU

targetCPUUtilizationPercentage instrui o HPA a manter a CPU média próxima de um alvo. Se os pods tiverem, em média, 80% de utilização da CPU e o alvo for 50%, o HPA aumentará a escala até que a utilização volte a se aproximar de 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

Limitações do dimensionamento baseado em CPU

A CPU é um indicador indireto ruim para algumas cargas de trabalho. Um modelo de GPU pode ficar limitado pela GPU enquanto a CPU permanece pouco utilizada, ou um trabalhador assíncrono pode ter uma fila crescente enquanto a CPU está ociosa. Nesses casos, dimensione com base em um sinal específico da carga de trabalho.

KEDA para dimensionamento orientado por eventos

O KEDA (dimensionamento automático orientado por eventos do Kubernetes) dimensiona com base em métricas externas, como o comprimento da fila, o atraso do Kafka ou consultas do Prometheus. Ele pode até reduzir a escala para zero quando não há trabalho, algo que o HPA não consegue fazer por conta própria.

ScaledObject do KEDA baseado em fila

Este ScaledObject do KEDA adiciona trabalhadores quando uma fila de mensagens cresce. Cada unidade do acúmulo indicado por queueLength aciona outra réplica, para que o consumidor acompanhe os picos.

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"

Balanceamento de carga com entrada

O tráfego externo chega aos seus pods por meio de uma entrada. Um controlador de entrada do nginx encerra o TLS e distribui as solicitações entre o serviço que atende às suas réplicas, para que o aumento da escala distribua a carga imediatamente.

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

Lançamentos seguros: canário

Implantar uma nova versão do modelo para todo o tráfego de uma só vez é arriscado. Um lançamento canário envia uma pequena parcela do tráfego para a nova versão, monitora suas métricas e então transfere gradualmente uma parcela maior.

Canário com pesos de tráfego

As anotações de canário da entrada do nginx direcionam uma porcentagem das solicitações para uma segunda implantação. Comece com 10%, verifique a taxa de erros e a latência e, em seguida, aumente o peso para 100%.

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

Reunindo o dimensionamento

Uma configuração robusta combina todos estes elementos:

  • HPA ou KEDA define a quantidade de réplicas com base na demanda
  • A entrada distribui a carga entre as réplicas
  • Os pesos de canário lançam novas versões com segurança

Juntos, eles proporcionam um serviço de modelos elástico, resiliente e de baixo risco.

Verificação rápida

Teste seus conhecimentos sobre dimensionamento.

Recapitulação

Você aprendeu a dimensionar endpoints de modelos:

  • O HPA com targetCPUUtilizationPercentage dimensiona com base na CPU
  • O KEDA dimensiona com base no comprimento da fila e oferece redução da escala para zero
  • A entrada do nginx distribui a carga entre as réplicas
  • Os pesos de canário transferem o tráfego gradualmente para lançamentos seguros

Perguntas Frequentes

A aula “Escalonamento e escalonamento automático de endpoints de modelos” é grátis?

Sim — o texto completo de “Escalonamento e escalonamento automático de endpoints de modelos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn AI with Python, atualize para CoddyKit PRO. O curso de Learn AI with Python inclui 4 aulas no total.

O que vou aprender em “Escalonamento e escalonamento automático de endpoints de modelos”?

HPA do Kubernetes para pods de modelos, escalonamento baseado no tráfego, implantação A/B e versões canário. Você pratica Learn AI with Python com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn AI with Python?

Nenhuma experiência prévia é necessária. Learn AI with Python no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Escalonamento e escalonamento automático de endpoints de modelos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn AI with Python?

Sim. Cada aula de Learn AI with Python inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Containerizando modelos de aprendizado de máquina com Docker
  2. Implantação na nuvem: AWS SageMaker
  3. Disponibilização de alto desempenho com o Triton Inference Server
  4. Escalonamento e escalonamento automático de endpoints de modelos
← Voltar para Learn AI with Python