Guia Completo de Kubernetes para Desenvolvedores .NET em 2024

---

O Problema Real: Sua App .NET Precisa Escalar, Mas Você Não Tem Infraestrutura

Imagine o seguinte cenário: sua empresa acabou de fechar uma parceria estratégica e o tráfego vai triplicar em 48 horas. Você tem uma API ASP.NET Core rodando em dois servidores Windows Server 2019 com IIS. O que você faz?

Se sua resposta envolve "subir mais VMs", "alterar manualmente o balanceador" ou "rezar para não cair", você tem um problema — e o Kubernetes resolve isso.

Estatísticas da CNCF mostram que 96% das empresas que adotaram Kubernetes relataram melhoria na confiabilidade de deploy. Outro dado relevante: organizações que usam containers + orquestração reduzem em 70% o tempo de deploy em produção, segundo o State of DevOps Report 2023.

Para desenvolvedores .NET, a transição para Kubernetes não é mais opcional — é sobrevivência competitiva.

---

Por Que .NET e Kubernetes São Combinação Perfeita

A Microsoft fez um trabalho excepcional modernizando o ecossistema .NET para containers. O .NET 6 e .NET 8 trouxeram melhorias massivas de performance: aplicações ASP.NET Core rodam 30-50% mais rápidas comparadas ao .NET Framework, e o footprint de memória reduziu drasticamente.

Mas o verdadeiro poder surge quando combinamos:

• ASP.NET Core (performance nativa e cross-platform)
• Docker (containerização padronizada)
• Kubernetes (orquestração enterprise-grade)
• Azure Kubernetes Service (infraestrutura gerenciada pela Microsoft)

O resultado? Deploy consistente do dev até produção, rollback atômico, auto-scaling baseado em métricas reais, e zero downtime deployments. Sem mágica — apenas engenharia sólida.

---

Primeiro Passo: Containerizando Sua Aplicação .NET

Antes de falar Kubernetes, você precisa dominar Docker. Uma aplicação .NET containerizada corretamente pesa entre 180-250MB com runtime completo, versus 4-8GB de uma VM Windows Server tradicional.

Criando o Dockerfile Otimizado para .NET

A Microsoft recomenda uma estratégia multi-stage para images de produção:

# Estágio 1: Build
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src

# Restaurar dependências (camada cacheable)
COPY ["MinhaApi.csproj", "./"]
RUN dotnet restore "MinhaApi.csproj"

# Copiar código e buildar
COPY . .
RUN dotnet publish "MinhaApi.csproj" -c Release -o /app/publish

# Estágio 2: Runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app

# Usuário não-root por segurança (best practice E-E-A-T)
RUN adduser --disabled-password --gecos "app" appuser
USER appuser

COPY --from=build /app/publish .

# Health check nativo do .NET
HEALTHCHECK --interval=30s --timeout=3s CMD curl -f http://localhost:8080/health || exit 1

ENTRYPOINT ["dotnet", "MinhaApi.dll"]

Por que este Dockerfile funciona?

1. Multi-stage reduz o image final em ~60%
2. Camada de restore separada permite caching eficiente
3. Usuário não-root segue princípio de menor privilégio
4. Health check integrado permite ao Kubernetes saber quando reiniciar pods problemáticos

Build e Teste Local

# Build da imagem
docker build -t minhaapi:1.0.0 .

# Teste rápido
docker run -d -p 8080:8080 --name teste-api minhaapi:1.0.0

# Verificar logs
docker logs teste-api

# Testar health endpoint
curl http://localhost:8080/health

---

Entendendo Kubernetes: Conceitos Essenciais para .NET

Se você vem do mundo .NET, pense em Kubernetes como um orchestrator que substitui o IIS/Windows Services — mas infinitamente mais poderoso.

Arquitetura Fundamental

Conceito Kubernetes	Equivalent .NET/IIS	Função
Pod	App Pool	Menor unidade deployável; contém 1+ containers
Deployment	App Publishing Profile	Define replicas, strategy, rollbacks
Service	Load Balancer	Exposição de pods internamente ou externamente
Ingress	ARR (Application Request Routing)	Roteamento HTTP/HTTPS com regras
ConfigMap	appsettings.json	Configurações não-sensíveis
Secret	Azure Key Vault reference	Dados sensíveis (connection strings, API keys)
StatefulSet	Windows Service com estado	Apps que precisam persistência (banco de dados)
HorizontalPodAutoscaler	Nada equivalente em IIS	Auto-scaling baseado em CPU/memória

---

Deployando no Azure Kubernetes Service (AKS): Passo a Passo

O AKS é a escolha natural para empresas no ecossistema Microsoft. Integra-se nativamente com Azure AD, Azure Monitor, Azure Policy e Azure DevOps — reduzindo fricção operacional significativamente.

Pré-requisitos

• Assinatura Azure (custo free tier disponível)
• Azure CLI instalado (az --version para verificar)
• kubectl instalado (az aks install-cli)
• Docker Desktop ou Azure Container Registry (ACR) para storage de imagens

Passo 1: Criar o Cluster AKS

# Login no Azure
az login

# Selecionar subscription
az account set --subscription " minha-subscription-id"

# Criar Resource Group
az group create --name rg-dotnet-k8s --location brazilsouth

# Criar AKS com auto-scaling habilitado
az aks create \
  --resource-group rg-dotnet-k8s \
  --name aks-dotnet-cluster \
  --node-count 3 \
  --enable-horizontal-pod-autoscaler \
  --min-count 1 \
  --max-count 10 \
  --vm-set-type VirtualMachineScaleSets \
  --load-balancer-sku standard \
  --enable-cluster-autoscaler \
  --generate-ssh-keys

Custos AKS a considerar: O AKS em si não tem custo (pay-as-you-go), mas você paga pelos nós (VMs). Para dev/test, recomendo VMs da série B (burstable) — B2s por $35/mês é excelente custo-benefício. Para produção, considere D2s_v4 ou E2s_v3 ($120-180/mês por nó).

Passo 2: Conectar kubectl ao Cluster

# Obter credenciais (configura ~/.kube/config automaticamente)
az aks get-credentials \
  --resource-group rg-dotnet-k8s \
  --name aks-dotnet-cluster

# Verificar conexão
kubectl get nodes

Passo 3: Criar Azure Container Registry (ACR)

# Criar ACR
az acr create \
  --resource-group rg-dotnet-k8s \
  --name cirowebsitecr \
  --sku Basic

# Login no ACR
az acr login --name cirowebsitecr

# Taguear imagem local
docker tag minhaapi:1.0.0 cirowebsitecr.azurecr.io/minhaapi:1.0.0

# Push para ACR
docker push cirowebsitecr.azurecr.io/minhaapi:1.0.0

Passo 4: Configurar AKS para Autenticar no ACR

# Obter ID do ACR
ACR_ID=$(az acr show --name cirowebsitecr --query id --output tsv)

# Criar Service Principal com acesso Reader ao ACR
az ad sp create-for-rbac --name "aks-to-acr" --role Reader --scopes $ACR_ID

# OU usar managed identity (recomendado para produção)
az aks update \
  --resource-group rg-dotnet-k8s \
  --name aks-dotnet-cluster \
  --enable-azure-rbac

Passo 5: Deploy da Aplicação — O Manifesto Kubernetes

Crie o arquivo deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: minhaapi-deployment
  labels:
    app: minhaapi
    version: v1
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: minhaapi
  template:
    metadata:
      labels:
        app: minhaapi
        version: v1
    spec:
      containers:
      - name: minhaapi
        image: cirowebsitecr.azurecr.io/minhaapi:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: ASPNETCORE_ENVIRONMENT
          value: "Production"
        - name: ConnectionStrings__DefaultConnection
          valueFrom:
            secretKeyRef:
              name: app-secrets
              key: db-connection-string
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 15
        readinessProbe:
          httpGet:
            path: /health/ready
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: minhaapi-service
spec:
  type: LoadBalancer
  selector:
    app: minhaapi
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080
---
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  db-connection-string: "Server=tcp:mydb.database.azure.com;Database=appdb;User Id=admin;Password=SENHA_SEGURA;"
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: minhaapi-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: minhaapi-deployment
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Passo 6: Aplicar o Manifesto

# Aplicar todos os recursos
kubectl apply -f deployment.yaml

# Verificar status dos pods
kubectl get pods -w

# Verificar services
kubectl get services

# Acompanhar logs em tempo real
kubectl logs -f deployment/minhaapi-deployment

---

ConfigMaps vs Secrets: Gerenciando Configuração no Kubernetes

Uma dúvida comum: quando usar cada um?

Use ConfigMap para:

• URLs de APIs externas
• Nomes de ambientes
• Caminhos de arquivos
• Configurações de logging (nível, formato)
• Timeout settings

Use Secrets para:

• Connection strings (SEMPRE)
• API keys e tokens
• Certificados SSL
• Senhas de serviços externos

Boa prática: Nunca cometa a falha de colocar secrets em ConfigMaps. O Kubernetes Secrets não é criptografado por padrão — apenas base64 encoded. Para produção, habilite encryption at-rest:

# Criar encryption key
kubectl create secret generic encryption-key --from-literal=key=$(openssl rand -base64 32)

# Configurar encryption no kube-apiserver (requer restart do cluster)

Alternativa mais robusta: usar Azure Key Vault com o Azure Key Vault Provider for Secrets Store CSI Driver. Isso integra secrets diretamente nos pods sem exponhar dados no cluster.

---

Ingress Controller: Roteamento Avançado para .NET APIs

O Service LoadBalancer funciona, mas para cenários reais você precisa de um Ingress Controller. No AKS, instale o NGINX Ingress Controller:

# Instalar via Helm (gerenciador de pacotes Kubernetes)
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx \
  --namespace ingress-basic \
  --create-namespace \
  --set controller.replicaCount=2 \
  --set controller.nodeSelector.agentpool=system \
  --set defaultBackend.nodeSelector.agentpool=system

Depois, configure rotas:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "50m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - api.minhaempresa.com
    secretName: api-tls-secret
  rules:
  - host: api.minhaempresa.com
    http:
      paths:
      - path: /v1
        pathType: Prefix
        backend:
          service:
            name: minhaapi-service
            port:
              number: 80

---

CI/CD com Azure DevOps: Automatizando Deploy

Para empresas que já usam Azure DevOps, a integração é direta. Crie um pipeline YAML:

# azure-pipelines.yml
trigger:
  branches:
    include:
    - main

pool:
  vmImage: 'ubuntu-latest'

stages:
- stage: Build
  jobs:
  - job: BuildAndPush
    steps:
    - task: UseDotNet@2
      inputs:
        packageType: 'sdk'
        version: '8.0.x'
    
    - task: Docker@2
      inputs:
        containerRegistry: 'cirowebsitecr'
        repository: 'minhaapi'
        command: 'buildAndPush'
        Dockerfile: '**/Dockerfile'
        tags: '$(Build.BuildId)'

- stage: Deploy_Dev
  dependsOn: Build
  jobs:
  - deployment: DeployToAKS_Dev
    environment: 'dev'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@0
            inputs:
              action: 'deploy'
              namespace: 'default'
              manifests: '**/deployment.yaml'
              containers: |
                cirowebsitecr.azurecr.io/minhaapi:$(Build.BuildId)
              imagePullSecrets: 'acr-secret'

- stage: Deploy_Prod
  dependsOn: Deploy_Dev
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  jobs:
  - deployment: DeployToAKS_Prod
    environment: 'prod'
    strategy:
      runOnce:
        deploy:
          steps:
          - task: KubernetesManifest@0
            inputs:
              action: 'deploy'
              namespace: 'production'
              manifests: '**/deployment-prod.yaml'
              containers: |
                cirowebsitecr.azurecr.io/minhaapi:$(Build.BuildId)
              imagePullSecrets: 'acr-secret-prod'

---

Monitoramento e Observabilidade no AKS

Deployar é metade da batalha. Você precisa de observabilidade completa. O Azure Monitor + Application Insights é a pilha nativa:

# Habilitar Azure Monitor para o cluster
az aks enable-addons \
  --resource-group rg-dotnet-k8s \
  --name aks-dotnet-cluster \
  --addons monitoring

Para .NET, o Application Insights SDK captura automaticamente:

• Requests HTTP com latência
• Exceções com stack traces completos
• Dependências (SQL Server, Redis, HTTP calls)
• Métricas customizadas

Na prática: Em uma migração recente para um cliente do setor financeiro, reduzimos MTTR (Mean Time to Recovery) de 45 minutos para 8 minutos usando Application Insights + Kubernetes health probes juntos.

---

Helm Charts: Gerenciando Releases Complexas

Quando você tem múltiplos ambientes (dev, staging, prod) com configurações distintas, Helm é essencial. Crie um chart estruturado:

# Scaffold de um chart
helm create minhaapi-chart

# Estrutura criada:
# minhaapi-chart/
#   Chart.yaml
#   values.yaml
#   templates/
#     deployment.yaml
#     service.yaml
#     ingress.yaml
#     tests/
#       test-connection.yaml

No values.yaml, separe configurações por ambiente:

# values.yaml (base)
replicaCount: 3

image:
  repository: cirowebsitecr.azurecr.io/minhaapi
  pullPolicy: IfNotPresent

service:
  type: LoadBalancer
  port: 80

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 100m
    memory: 128Mi

# values.prod.yaml (override)
replicaCount: 10

resources:
  limits:
    cpu: 1000m
    memory: 1Gi
  requests:
    cpu: 250m
    memory: 256Mi

Deploy com overrides:

helm upgrade --install minhaapi minhaapi-chart \
  --namespace production \
  --values minhaapi-chart/values.yaml \
  --values minhaapi-chart/values.prod.yaml \
  --set image.tag=$(Build.BuildId)

---

Troubleshooting: Problemas Comuns e Soluções

Problema: Pods em CrashLoopBackOff

# Ver logs do pod específico
kubectl logs minhaapi-deployment-7b8f9d-xk2zp --previous

# Causas comuns: app crashando, health check falhando, secrets incorretos

Problema: ImagePullBackOff

# Verificar se secret existe
kubectl get secret acr-secret -o yaml

# Re-criar secret se necessário
kubectl create secret docker-registry acr-secret \
  --docker-server=cirowebsitecr.azurecr.io \
  --docker-username=CLIENT_ID \
  --docker-password=CLIENT_SECRET

Problema: Pending Pods (recursos insuficientes)

# Verificar nós e capacidades
kubectl describe nodes | grep -A 5 "Allocated resources"

# Aumentar quota ou otimizar resource requests

---

Conclusão e Próximos Passos

Kubernetes não é apenas uma tecnologia — é uma mudança de mentalidade operacional. Para desenvolvedores .NET, a curva de aprendizado vale o investimento. Em 6-12 meses de adoção consistente, sua equipe将达到:

• Zero downtime deployments (Rolling updates com estratégia Canary)
• Auto-scaling automático baseado em demanda real
• Rollback atômico em caso de falhas (< 30 segundos)
• Multi-environment consistency (dev = staging = prod)
• Infrastructure as Code com GitOps (Flux ou ArgoCD)

O Azure Kubernetes Service simplifica drasticamente a operação, especialmente se você já usa Azure DevOps, Azure Monitor e Azure AD. A integração nativa com Identity e RBAC significa que suas políticas de segurança enterprise funcionam automaticamente.

Próximos passos recomendados:

1. Containerize uma aplicação .NET simples esta semana
2. Deploy local com Docker Desktop + Kubernetes habilitado
3. Migre para AKS usando este guia como referência
4. Implemente CI/CD com Azure DevOps nas próximas duas semanas
5. Configure monitoring completo antes de ir para produção

---

Quer ajuda personalizada para migrar suas aplicações .NET para Kubernetes na Azure? A Ciro Cloud oferece Assessments de Arquitetura e projetos de Migração Assistida. Entre em contato para uma conversa técnica sem compromisso.