ULC Lab · implementação reproduzível

Laboratório: Deploy e Escala de um Modelo IA Aberto com KServe em Kubernetes

Você irá implantar um modelo de IA aberto usando KServe em um cluster Kubernetes local, expondo a inferência via Istio e monitorando com Prometheus. O laboratório leva cerca de 2 horas.

Ligado ao treinamento KServe avançado: deploy, automação e escala de modelos IA abertos

ULC-LAB-IA-0003 · Status de validaçãoNão validado pela Upnetix: roteiro derivado da documentação oficial, para você executar e validar

Duração estimada: 120 min
Passos: 11
Validações: 4
Versões da documentação consultada: Kubernetes (minikube) a versão estável atual · KServe a versão estável atual · Istio a versão estável atual · Prometheus a versão estável atual · kubectl a versão estável atual · curl a versão estável atual

Objetivo

Demonstrar, em ambiente controlado, o ciclo completo de deploy, exposição e monitoramento de um modelo de IA aberto (Scikit-learn) usando KServe sobre Kubernetes, com Istio para roteamento e Prometheus para métricas. O laboratório cobre automação básica, integração de componentes e validação operacional, simulando um cenário real de produção.

Topologia

Um cluster Kubernetes local (minikube) com três pods principais: KServe, Istio ingress gateway e um modelo scikit-learn. O usuário acessa o serviço de inferência via Istio em 10.0.0.2:31380. Prometheus coleta métricas dos componentes. Todos os serviços rodam em 10.0.0.0/24.


+-------------------+
|    Usuário        |
| (curl, browser)   |
+--------+----------+
         |
         v
+--------+----------+
| Istio Ingress GW  |
| 10.0.0.2:31380    |
+--------+----------+
         |
         v
+-------------------+
|    KServe         |
+--------+----------+
         |
         v
+-------------------+
| Modelo scikit-learn|
+-------------------+
         |
         v
+-------------------+
|   Prometheus      |
+-------------------+

Equipamentos e software

Item	Requisito, licença ou versão
Máquina virtual ou notebook	2 vCPU, 4GB RAM, 20GB disco, acesso à internet, portas 31380 e 9090 liberadas
Kubernetes (minikube)	Apache 2.0 · a versão estável atual
KServe	Apache 2.0 · a versão estável atual
Istio	Apache 2.0 · a versão estável atual
Prometheus	Apache 2.0 · a versão estável atual
kubectl	Apache 2.0 · a versão estável atual
curl	MIT · a versão estável atual

Roteiro

Preparar o ambiente Kubernetes com Minikube
Você precisa de um cluster Kubernetes funcional para orquestrar os pods. Minikube é a forma mais rápida para laboratório local.
```
minikube start --cpus=2 --memory=4096
```
O que você deve ver: Cluster iniciado, status 'Running'.
Instalar Istio para roteamento de tráfego
KServe depende de Istio para expor serviços de inferência. Instale o Istio minimal profile.
```
istioctl install --set profile=demo -y
```
O que você deve ver: Istio control plane e ingress gateway rodando em 'istio-system'.
Habilitar injection automático de sidecar Istio
Namespaces usados pelo KServe precisam do sidecar do Istio para roteamento.
```
kubectl label namespace default istio-injection=enabled
```
O que você deve ver: Namespace 'default' rotulado para injection.
Instalar KServe no cluster
KServe é o operador que gerencia o ciclo de vida dos modelos. Use o manifest oficial.
```
kubectl apply -f https://github.com/kserve/kserve/releases/latest/download/kserve.yaml
```
O que você deve ver: Pods do KServe rodando em 'kserve' e CRDs criadas.
Aguardar todos os pods ficarem prontos
Antes de prosseguir, garanta que todos os pods essenciais estejam prontos.
```
kubectl get pods -A
```
O que você deve ver: Todos os pods com STATUS 'Running' ou 'Completed'.
Deploy do modelo scikit-learn de exemplo
Vamos usar o exemplo oficial do KServe para scikit-learn, que já inclui um modelo treinado.
```
kubectl apply -f https://raw.githubusercontent.com/kserve/kserve/release-0.11/docs/samples/v1beta1/sklearn/sklearn.yaml
```
O que você deve ver: Um InferenceService chamado 'sklearn-iris' criado.
Expor o serviço de inferência via Istio ingress
Mapeie a porta do Istio ingress gateway para acesso externo.
```
kubectl get svc istio-ingressgateway -n istio-system
```
O que você deve ver: IP e porta (geralmente 31380) disponíveis para acesso externo.

Testar a inferência do modelo via curl

Valide se o modelo responde a requisições HTTP.

curl -v -H "Host: sklearn-iris.example.com" -H "Content-Type: application/json" -d '{"instances": [[6.8,  2.8,  4.8,  1.4]]}' http://$(minikube ip):31380/v1/models/sklearn-iris:predict

O que você deve ver: Resposta JSON com previsões do modelo.

Instalar Prometheus para monitoramento
Prometheus coleta métricas dos pods, inclusive do KServe.
```
kubectl create namespace monitoring
kubectl apply -f https://github.com/prometheus-operator/prometheus-operator/releases/latest/download/bundle.yaml
```
O que você deve ver: Pods do Prometheus rodando em 'monitoring'.
Configurar Prometheus para coletar métricas do KServe
Prometheus precisa de um ServiceMonitor para capturar métricas do KServe.
```
# Consulte a documentação do Prometheus Operator para criar um ServiceMonitor para o namespace 'kserve'.
```
O que você deve ver: Prometheus coleta métricas dos pods do KServe.
Acessar o dashboard do Prometheus
Verifique se as métricas estão sendo coletadas.
```
kubectl port-forward svc/prometheus-operated -n monitoring 9090:9090
```
O que você deve ver: Interface web do Prometheus acessível em http://localhost:9090.

Como saber que funcionou

Teste	Comando	Critério
Verificar se o modelo responde à inferência	`curl -H "Host: sklearn-iris.example.com" -H "Content-Type: application/json" -d '{"instances": [[6.8, 2.8, 4.8, 1.4]]}' http://$(minikube ip):31380/v1/models/sklearn-iris:predict`	Resposta JSON com campo 'predictions'.
Checar se o InferenceService está pronto	`kubectl get inferenceservices`	STATUS 'Ready' para 'sklearn-iris'.
Verificar métricas do KServe no Prometheus	`Acesse http://localhost:9090 e busque por 'kserve' nas métricas.`	Métricas do KServe visíveis no dashboard.
Validar pods do Istio e KServe	`kubectl get pods -A \| grep -E 'istio\|kserve'`	Todos os pods essenciais em 'Running' ou 'Completed'.

Troubleshooting

Sintoma	Causa provável	Correção
O comando curl retorna erro de conexão	Porta do Istio ingress não exposta ou IP incorreto	Use 'minikube ip' e confirme a porta com 'kubectl get svc istio-ingressgateway -n istio-system'
InferenceService não fica com STATUS 'Ready'	Pods do modelo não inicializam ou falta de recursos	Verifique logs com 'kubectl logs' e recursos disponíveis com 'kubectl describe pod'
Prometheus não coleta métricas do KServe	ServiceMonitor não configurado corretamente	Consulte a documentação do Prometheus Operator para ajustar o ServiceMonitor
Pods do Istio ou KServe em CrashLoopBackOff	Recursos insuficientes ou configuração inválida	Aumente recursos do Minikube e revise configurações YAML

Segurança e hardening

Não exponha o Istio ingress gateway publicamente sem autenticação
Restrinja RBAC dos namespaces 'kserve' e 'monitoring'
Remova recursos do laboratório após uso para evitar exposição acidental
Consulte as recomendações de hardening do Kubernetes e Istio

Checklist final

Cluster Kubernetes iniciado e acessível
Istio instalado e ingress gateway rodando
KServe instalado e CRDs disponíveis
InferenceService 'sklearn-iris' com STATUS 'Ready'
Inferência HTTP retorna previsões
Prometheus coleta e exibe métricas do KServe

Referências

KServe Official Documentation · Kserve.github (kserve.github.io)
Kubernetes Documentation · Kubernetes (CNCF) (kubernetes.io)
Istio Documentation · Istio (istio.io)
Prometheus Documentation · Prometheus (CNCF) (prometheus.io)

Verificação editorial

Publicado: 09/09/2026
Última revisão: 09/09/2026
Versão do conteúdo: 1.0
Referências: 4 oficiais
Revisão técnica: redação e revisão por IA, URLs conferidas na publicação
Status: Atual

Encontrou um erro? Escreva para comercial@upnetix.com.br com o endereço da página. A revisão semestral por IA nunca altera comandos ou configurações sem passar pela fila de revisão.