🎯 Helm no Kubernetes: Guia Prático para Iniciantes (com Kind no Windows 11)

Nível: Intermediário
Pré-requisitos: Docker Desktop, Kind, kubectl instalados no Windows 11
Objetivo: Entender o que é Helm, quando usá-lo, e implantar aplicações reais (NGINX, WordPress, sua API + frontend) com charts

Se você já criou Deployments e Services com kubectl apply -f, está na hora de conhecer o Helm — o "gerenciador de pacotes" do Kubernetes. Neste post, vamos:

Explicar o que é Helm e como ele se relaciona com Kubernetes
Mostrar quando usar Helm vs. YAML puro
Instalar o Helm localmente com Kind
Implantar apps reais: NGINX, WordPress e sua própria API + frontend em Go
Criar e usar seu próprio chart Helm

Vamos lá!

📘 O que é Helm?

O Helm é uma ferramenta de linha de comando que simplifica a implantação e o gerenciamento de aplicações no Kubernetes.

Pense nele como o apt do Kubernetes ou o npm para charts:

Empacota recursos complexos (Deployments, Services, ConfigMaps, Secrets, etc.) em um único pacote chamado chart
Permite parametrizar configurações (ex: número de réplicas, porta, imagem)
Oferece versionamento, rollbacks e reutilização

💡 Helm não substitui o Kubernetes — ele usa o Kubernetes.
Ele é um "açúcar sintático inteligente" por cima do kubectl.

🔁 Kubernetes vs. Helm: Qual a diferença?

Conceito	Kubernetes (`kubectl`)	Helm
Unidade básica	Pod, Deployment, Service	Chart (conjunto de templates)
Configuração	Arquivos YAML estáticos	YAML dinâmico com variáveis (`values.yaml`)
Atualização	Editar YAML e reaplicar	`helm upgrade`
Rollback	Manual (histórico externo)	`helm rollback` automático
Reutilização	Copiar/colar YAML	`helm install meu-chart` em qualquer cluster

✅ Kubernetes é a plataforma.
✅ Helm é uma ferramenta para gerenciar aplicações nessa plataforma.

❓ Quando usar Helm? E quando usar só `kubectl`?

Use `kubectl + YAML` se:

Estiver aprendendo Kubernetes
Quiser subir um único Pod ou Deployment para teste
Sua aplicação é simples e não muda entre ambientes

Use Helm se:

Sua aplicação tem múltiplos componentes (ex: frontend + API + banco)
Você precisa de diferentes configurações para dev/staging/prod
Quer reutilizar a implantação em outros projetos
Precisa de atualizações seguras e rollbacks

💡 Dica prática: comece com kubectl, mas migre para Helm assim que sua aplicação sair do "hello world".

📦 Chart, Pod, Cluster: Qual a diferença?

Termo	Definição
Cluster	Conjunto de máquinas (nós) que executam Kubernetes (ex: seu cluster Kind local)
Pod	Menor unidade do Kubernetes — contém um ou mais contêineres
Chart	Pacote Helm que descreve como criar Pods, Services, etc. em um cluster

🧩 Analogia:

Cluster = seu computador

Pod = um programa rodando

Chart = um instalador .exe que configura tudo automaticamente

⚙️ Instalando o Helm no Windows 11 (com Kind)

Você já tem Docker Desktop + Kind + kubectl? Ótimo! Agora instale o Helm:

Passo 1: Baixar e instalar

No PowerShell:

curl.exe -LO "https://get.helm.sh/helm-v3.16.0-windows-amd64.zip"
Expand-Archive -Path helm-v3.16.0-windows-amd64.zip -DestinationPath .
Move-Item .\\windows-amd64\\helm.exe C:\\Windows\\helm.exe

Passo 2: Verificar

helm version

Passo 3: Garantir que o Helm usa seu cluster Kind

kubectl config current-context  # deve mostrar seu cluster Kind

✅ Pronto! Helm está integrado ao seu ambiente local.

🚀 Exemplos práticos com Helm

1. Instalar o NGINX (app de teste)

helm repo add bitnami https://charts.bitnami.com/bitnami
helm install meu-nginx bitnami/nginx

Acesse com kubectl port-forward:

kubectl port-forward svc/meu-nginx 8080:80
# Acesse http://localhost:8080

2. Instalar WordPress + MySQL

helm install meu-wp bitnami/wordpress

Veja a senha do admin:

kubectl get secret meu-wp-wordpress -o jsonpath="{.data.wordpress-password}" | certutil -decode

Encaminhe a porta:

kubectl port-forward svc/meu-wp-wordpress 8081:80
# Acesse http://localhost:8081

Obs: Se ocorrer um erro no trecho acima, é porque o comando certutil -decode precisa de dois argumentos: o arquivo de entrada (InFile) e o arquivo de saída (OutFile). Você está tentando passar o resultado do kubectl diretamente, mas certutil não aceita entrada via pipe.

Para decodificar o valor do segredo, digite:

kubectl get secret meu-wp-wordpress -o jsonpath="{.data.wordpress-password}" > temp.b64 && certutil -decode temp.b64 temp.txt && cat temp.txt

Depois, pode apagar os arquivos temporários:

rm temp.b64 temp.txt

execute o comando para acionar o wordpress:

kubectl port-forward svc/meu-wp-wordpress 8081:80
# Acesse http://localhost:8081

💡 Tudo em um único comando — sem criar 5 arquivos YAML!

3. Implantar sua API + Frontend em Go

Passo 1: Crie um chart personalizado

helm create lnt-app

Passo 2: Edite `lnt-app/values.yaml`

api:
  image: anselmolucas/lnt_sample_go_api_inmemory:latest
  port: 8091
  nodePort: 30091

frontend:
  image: anselmolucas/lnt_code_sample_go_webapp_displaymovies:latest
  port: 8113
  nodePort: 30113

Passo 3: Atualize os templates

Em lnt-app/templates/, crie api-deployment.yaml, api-service.yaml, frontend-deployment.yaml, etc., usando {{ .Values.api.port }} nos templates.

📌 Dica: use helm template lnt-app . para ver o YAML gerado antes de instalar.

Passo 4: Instale

helm install lnt-system ./lnt-app

Acesse:

API: http://localhost:30091/movies
Frontend: http://localhost:30113

✅ Tudo versionado, parametrizável e reutilizável!

📤 Como criar e publicar seu próprio chart?

1. Crie o chart

helm create meu-chart
# Edite templates e values.yaml

2. Empacote

helm package meu-chart
# Gera: meu-chart-0.1.0.tgz

3. Publicar (opcional)

Você pode:

Compartilhar o .tgz diretamente
Subir para um repositório Helm (ex: GitHub Pages, ChartMuseum, ou Artifact Hub)

🌐 Para publicar no Artifact Hub (comunidade), basta hospedar seu chart em um repositório público no GitHub com um arquivo artifacthub-repo.yaml.

▶️ Como usar um chart criado?

Localmente:

helm install meu-app ./meu-chart

De um arquivo `.tgz`:

helm install meu-app meu-chart-0.1.0.tgz

De um repositório remoto:

helm repo add meu-repo https://meu.github.io/helm-charts
helm install meu-app meu-repo/meu-chart

🧰 Guia de referência rápida

Comando	Descrição
`helm version`	Mostra a versão instalada do Helm
`helm repo add <nome> <url>`	Adiciona um repositório de charts (ex: `bitnami https://charts.bitnami.com/bitnami`)
`helm repo update`	Atualiza a lista de charts dos repositórios configurados
`helm repo list`	Lista todos os repositórios adicionados
`helm search repo <palavra>`	Busca charts nos repositórios locais (ex: `helm search repo nginx`)
`helm create <nome-do-chart>`	Cria um novo chart Helm com estrutura padrão
`helm install <nome-release> <chart>`	Instala um chart no cluster (ex: `helm install meu-app ./meu-chart`)
`helm list`	Lista todos os releases instalados no namespace atual
`helm upgrade <nome-release> <chart>`	Atualiza um release existente com novos valores ou versão
`helm rollback <nome-release> <revisão>`	Reverte um release para uma versão anterior
`helm uninstall <nome-release>`	Remove completamente um release do cluster
`helm template <chart>`	Renderiza os templates do chart sem instalar (útil para debug)
`helm package <diretório-do-chart>`	Empacota um chart local em um arquivo `.tgz`
`helm show values <chart>`	Mostra os valores padrão (`values.yaml`) de um chart
`helm status <nome-release>`	Exibe o status atual de um release instalado

💡 Dicas rápidas:

Use --namespace para trabalhar em namespaces específicos.
Use --set chave=valor para sobrescrever valores na linha de comando:
```
helm install meu-app bitnami/nginx --set service.type=NodePort
```
Use --dry-run --debug com install ou template para testar sem aplicar mudanças.

✅ Conclusão

O Helm transforma o Kubernetes de uma ferramenta poderosa, mas verbosa, em uma plataforma ágil e reutilizável.

Com ele, você:

Implanta WordPress em 10 segundos
Gerencia sua API + frontend com segurança
Prepara sua aplicação para ambientes reais

E o melhor: tudo isso funciona no seu Windows 11, com Kind, sem WSL.

📌 Próximos passos:

Converta seus YAMLs atuais em charts Helm

Adicione values-dev.yaml, values-prod.yaml

Explore charts da comunidade: https://artifacthub.io

Adendos

📊 Monitorando seu Cluster Kubernetes Local com Interface Gráfica

Depois de implantar suas aplicações com Helm, é natural querer acompanhar o que está acontecendo:

Meus Pods estão saudáveis?
Quantos recursos (CPU/memória) estão sendo usados?
Qual o log da minha API Go?
Meu Service está exposto corretamente?

Felizmente, existem ferramentas gráficas e leves para monitorar seu cluster local — sem precisar de Prometheus, Grafana ou configurações complexas.

🔧 Ferramentas populares para monitoramento local

Ferramenta	Tipo	Ideal para
Lens Desktop	IDE gráfica para Kubernetes	Iniciantes e devs que querem visão completa com 1 clique
K9s	Terminal UI (TUI)	Quem prefere terminal, mas com interface visual
Kubernetes Dashboard	Web UI oficial	Ambientes com Ingress ou `kubectl proxy`
Prometheus + Grafana	Monitoramento avançado	Métricas detalhadas, alertas, produção

✅ Para aprendizado local, Lens Desktop é a escolha mais simples e poderosa.

🖥️ Passo a passo: Instalar e usar o Lens Desktop no Windows 11

Passo 1: Baixe e instale o Lens

Acesse: https://k8slens.dev/
Clique em "Download for Windows"
Execute o instalador (.exe) e siga as instruções

💡 O Lens não requer configuração adicional — ele lê automaticamente seu arquivo ~/.kube/config (o mesmo usado pelo kubectl).

Passo 2: Conecte ao seu cluster Kind

Abra o Lens
Ele detecta automaticamente seu cluster Kind (ex: kind-go-api-cluster)
Clique no cluster para se conectar

✅ Pronto! Você verá:

Lista de Namespaces
Pods, Deployments, Services
Uso de CPU e memória
Logs em tempo real
Botão para abrir terminal dentro do Pod

Passo 3: Explore sua API e frontend

Clique em Workloads > Pods
Selecione o Pod da sua API Go (lnt-sample-go-api...)
Aba Logs: veja requisições em tempo real
Aba Terminal: execute comandos dentro do contêiner (ex: ls, cat .env)

🎯 Dica: clique no ícone de "Port Forward" ao lado do Service para abrir URLs como http://localhost:30091 direto do Lens!

Vantagens do Lens:

Zero configuração
Funciona com Kind, Minikube, Docker Desktop, EKS, GKE, etc.
Gratuito e open-source
Perfeito para debugar, inspecionar e entender seu cluster

🧪 Alternativa leve: K9s (para quem ama terminal)

Se preferir uma interface no terminal:

Baixe o K9s: https://k9scli.io/
Extraia e adicione ao PATH
Execute:
```
k9s
```
Navegue com teclado: veja Pods, Services, logs, tudo em tempo real

Monitorar seu cluster não precisa ser complicado. Com Lens Desktop, você ganha uma janela visual poderosa sobre tudo o que acontece no Kubernetes — ideal para aprender, depurar e demonstrar suas aplicações.

E se erros ocorerem?

Listei algumas situações de erro e possíveis resoluções.

Acesso via NodePort (porta 80 ocupada)

Se a porta 80 do seu ambiente está ocupada por outra aplicação, utilize a porta NodePort exposta pelo serviço do WordPress:

Porta HTTP: 31363
Porta HTTPS: 31691 (se configurado)

Para acessar o WordPress, use o IP do nó Kubernetes e a porta 31363:

http://<IP_DO_NO>:31363/

Para acessar o painel admin:

http://<IP_DO_NO>:31363/admin

Substitua <IP_DO_NO> pelo IP do seu nó ou máquina onde o cluster está rodando.

Acesso ao WordPress após instalação

Após instalar o WordPress via Helm, utilize as informações abaixo para acessar o site e o painel administrativo:

Usuário e senha padrão

Usuário: user

Senha:

kubectl get secret --namespace default meu-wp-wordpress -o jsonpath="{.data.wordpress-password}" | base64 -d

Descobrir o endereço externo (LoadBalancer)

kubectl get svc --namespace default -w meu-wp-wordpress

Quando o IP estiver disponível:

export SERVICE_IP=$(kubectl get svc --namespace default meu-wp-wordpress --template "{{ range (index .status.loadBalancer.ingress 0) }}{{ . }}{{ end }}")
echo "WordPress URL: http://$SERVICE_IP/"
echo "WordPress Admin URL: http://$SERVICE_IP/admin"

Abra o navegador e acesse o endereço informado para utilizar o WordPress.

Perfeito! Esse erro é comum quando você já instalou um release do Helm com o mesmo nome (meu-nginx) e não o removeu.

Vamos limpar tudo do seu ambiente local para você recomeçar do zero, sem conflitos.

🧹 Passo a passo para apagar tudo relacionado ao Helm e Kubernetes local

1. Liste todos os releases do Helm

helm list --all-namespaces

Você verá algo como:

NAME       	NAMESPACE	REVISION	UPDATED                 	STATUS  	CHART
meu-nginx  	default  	1       	2025-10-30 10:00:00     	deployed	nginx-...

2. Desinstale cada release

helm uninstall meu-nginx

Se tiver outros (ex: meu-wp, lnt-system, etc.), remova todos:

helm uninstall meu-wp
helm uninstall lnt-system
# ... etc

✅ Isso remove todos os recursos do Kubernetes associados ao release (Pods, Services, Deployments, etc.).

3. (Opcional) Remova o repositório Bitnami

Se quiser começar do zero com os repositórios:

helm repo remove bitnami

Depois, se precisar, adicione de novo:

helm repo add bitnami https://charts.bitnami.com/bitnami

4. Verifique se sobrou algo no cluster

kubectl get all

Se ainda houver recursos (ex: pods órfãos), remova manualmente:

kubectl delete pod <nome-do-pod>
# ou, para limpar tudo no namespace default:
kubectl delete all --all

⚠️ Cuidado: kubectl delete all --all apaga tudo no namespace atual (mas não afeta outros namespaces nem o cluster em si).

5. (Recomendado) Recrie o cluster Kind

Isso garante um ambiente 100% limpo:

kind delete cluster --name go-api-cluster
# ou o nome do seu cluster atual

Confirme com:

kind get clusters

Se quiser, crie um novo com seu kind-config.yaml:

kind create cluster --name helm-test --config kind-config.yaml

Script de limpeza automática para PowerShell

(cleanup.ps1) projetado especialmente para o seu ambiente de testes com Kind + Helm + Windows 11 (sem WSL).

Esse script:

Remove todos os releases do Helm
Apaga todos os recursos do Kubernetes no namespace default
Deleta o cluster Kind (opcional, com confirmação)
É seguro, idempotente e fácil de usar

📜 `cleanup.ps1`

# cleanup.ps1
# Script para limpar completamente o ambiente local de testes com Kind + Helm

Write-Host "🧹 Iniciando limpeza do ambiente Kubernetes local..." -ForegroundColor Cyan

# 1. Listar e remover todos os releases do Helm no namespace default
Write-Host ""n📦 Removendo releases do Helm..." -ForegroundColor Yellow
$releases = helm list --short 2>$null
if ($releases) {
    foreach ($release in $releases) {
        Write-Host "  Removendo release: $release"
        helm uninstall $release --wait 2>$null
    }
} else {
    Write-Host "  Nenhum release do Helm encontrado." -ForegroundColor Green
}

# 2. Remover todos os recursos do Kubernetes (Pods, Deployments, Services, etc.)
Write-Host ""n🗑️  Limpando recursos do Kubernetes no namespace 'default'..." -ForegroundColor Yellow
kubectl delete all --all --namespace default 2>$null
kubectl delete pvc --all --namespace default 2>$null
Write-Host "  Recursos removidos." -ForegroundColor Green

# 3. (Opcional) Remover o cluster Kind
Write-Host ""n❓ Deseja também apagar o cluster Kind? (s/N)" -ForegroundColor Magenta -NoNewline
$choice = Read-Host

if ($choice -eq "s" -or $choice -eq "S") {
    $clusters = kind get clusters 2>$null
    if ($clusters) {
        foreach ($cluster in $clusters) {
            Write-Host "  Apagando cluster: $cluster" -ForegroundColor Red
            kind delete cluster --name $cluster
        }
    } else {
        Write-Host "  Nenhum cluster Kind encontrado." -ForegroundColor Green
    }
} else {
    Write-Host "  Cluster Kind mantido." -ForegroundColor Green
}

Write-Host ""n✅ Limpeza concluída!" -ForegroundColor Cyan

▶️ Como usar

Salve o código acima como cleanup.ps1 na sua pasta de projetos
Abra o PowerShell na mesma pasta
Execute:

.\\cleanup.ps1

⚠️ Primeira execução: o PowerShell pode bloquear scripts por política de segurança.
Se isso acontecer, execute uma vez:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

✅ O que o script faz (passo a passo)

Etapa	Ação
1	Lista todos os releases do Helm (`helm list --short`) e os desinstala
2	Remove todos os recursos do Kubernetes no namespace `default` (Pods, Services, Deployments, PVCs, etc.)
3	Pergunta se você quer apagar o cluster Kind inteiro (útil para recomeçar do zero)

💡 O script é seguro para rodar múltiplas vezes — se não houver recursos, ele simplesmente avisa e continua.

🛠️ Personalização (opcional)

Para limpar outros namespaces, adicione:

kubectl delete all --all --namespace meu-namespace

Para não perguntar e sempre apagar o cluster, remova o bloco if ($choice...) e deixe só:
```
kind delete cluster --name seu-nome-de-cluster
```

Pronto! Agora você tem um botão de "reset" para seus testes com Helm e Kind.
Use sempre que quiser começar do zero — perfeito para acompanhar tutoriais ou testar charts novos! 😊