# Workshop: Docker, Kubernetes e GitOps na Prática

Workshop progressivo que evolui de containers básicos até um cluster Kubernetes de produção com GitOps na Hetzner Cloud.

[👉 Grupo do WhatsApp da nossa comunidade](https://chat.whatsapp.com/KU7Ev2dR2zZAA2xDI04RnK)

[▶ Assistir a gravação Turma 3 - 24/01/2026](https://streamify.com.br/tNBDdPHEyfP)

[▶ Assistir a gravação Turma 2 - 10/01/2026](https://streamify.com.br/vzcqhscRwch)

[▶ Assistir a gravação Turma 1 - 27/12/2025](https://streamify.com.br/WFwzqhqoajo)

## Jornada de Aprendizado

```
┌─────────────────────────────────────────────────────────────────────────────┐
│                           FUNDAMENTOS (Local)                               │
├─────────────────────────────────────────────────────────────────────────────┤
│  Aula 01        Aula 02        Aula 03        Aula 04        Aula 05        │
│  Docker         Liveness       Replicas       Keep Request   KEDA           │
│  Compose        Probe          Readiness      (Lua)          Auto-scaling   │
│     │              │              │              │              │           │
│     └──────────────┴──────────────┴──────────────┴──────────────┘           │
│                                   │                                         │
│                          App "node-bugado"                                  │
│                    (trava após N requests)                                  │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                         APLICAÇÕES (Local)                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│  Aula 06                                                                    │
│  n8n via Helm (Queue Mode + HPA)                                            │
│  PostgreSQL + Redis                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                      INFRAESTRUTURA (Hetzner Cloud)                         │
├─────────────────────────────────────────────────────────────────────────────┤
│  Aula 07                    Aula 08                                         │
│  Talos Linux ──────────────► Cluster K8s HA                                 │
│  (imagem custom)             OpenTofu + CCM + CSI                           │
│                              Autoscaler (1-5 workers)                       │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                       PLATAFORMA (Hetzner Cloud)                            │
├─────────────────────────────────────────────────────────────────────────────┤
│  Aula 09             Aula 10              Aula 11                           │
│  n8n (Hetzner)       Gitea                ArgoCD                            │
│  Multi-tenant        Registry + SSH       GitOps CI/CD                      │
└─────────────────────────────────────────────────────────────────────────────┘
                                   │
                                   ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                     OBSERVABILIDADE (Hetzner Cloud)                         │
├─────────────────────────────────────────────────────────────────────────────┤
│  Aula 12                        Aula 14                                     │
│  Victoria Metrics               Istio Traffic Splitting                     │
│  Grafana + Alertas              Canary Deployments + Kiali                  │
└─────────────────────────────────────────────────────────────────────────────┘
```

## Aulas

| Aula | Tema | Ambiente | Conceitos |
|------|------|----------|-----------|
| 01 | Docker Compose | Local | Containers, restart policies |
| 02 | Liveness Probe | Local | Health checks, auto-restart |
| 03 | High Availability | Local | Replicas, readiness probe |
| 04 | Keep Request | Local | NGINX Lua, zero-downtime |
| 05 | KEDA | Local | Auto-scaling por métricas |
| 06 | n8n (Local) | Local | Helm, Queue Mode, HPA |
| 07 | Talos Linux | Hetzner | Imagem customizada, Factory |
| 08 | Cluster HA | Hetzner | OpenTofu, CCM, CSI, Autoscaler |
| 09 | n8n (Cloud) | Hetzner | Multi-tenant, CSI Driver |
| 10 | Gitea | Hetzner | Registry, SSH, Helm |
| 11 | ArgoCD | Hetzner | GitOps, Runner, CI/CD |
| 12 | Victoria Metrics | Hetzner | Observabilidade, Grafana, Alertas |
| 14 | Istio | Hetzner | Service Mesh, Traffic Splitting, Kiali |

## Pré-requisitos

### Aulas 01-06 (Local)
- Docker Desktop, OrbStack, ou similar
- kubectl
- Helm 3.x

### Aulas 07-14 (Hetzner Cloud)
- Conta na Hetzner Cloud
- hcloud CLI
- OpenTofu
- talosctl
- Domínio configurado (ex: kube.quest)

## Quick Start

### Local (Docker Desktop)
```bash
# Aula 01 - Docker básico
cd aula-01 && docker-compose up

# Aula 02-05 - Kubernetes local
cd aula-02 && kubectl apply -f .
```

### Hetzner Cloud
```bash
# 1. Criar imagem Talos (aula-07)
# Siga o README.md da aula-07

# 2. Provisionar cluster (aula-08)
cd aula-08 && ./setup.sh

# 3. Instalar aplicações
cd aula-09 && ./setup.sh  # n8n
cd aula-10 && ./setup.sh  # Gitea
cd aula-11 && ./setup.sh  # ArgoCD
cd aula-12 && ./setup.sh  # Victoria Metrics + Grafana
cd aula-14 && ./setup.sh  # Istio + Kiali
```

## Custos Estimados (Hetzner Cloud)

| Componente | Recurso | Custo/mês |
|------------|---------|-----------|
| Control Plane | 3x CAX11 | ~€13.77 |
| Workers | 1-5x CAX11 | €4.59-€22.95 |
| LoadBalancer | LB11 | ~€5.99 |
| Volumes | 40-80Gi | €1.94-€3.88 |
| **Total** | | **~€26-€47** |

## Arquitetura Final

```
                         CloudFlare (DNS + CDN)
                                  │
        ┌─────────────┬───────────┼───────────┬─────────────┐
        │             │           │           │             │
        ▼             ▼           ▼           ▼             ▼
  gitea.kube.quest n8n.kube.quest argocd   grafana.kube.quest kiali.kube.quest
        │             │           │           │             │
        └─────────────┴───────────┼───────────┴─────────────┘
                                  │
                                  ▼
                    ┌─────────────────────────┐
                    │   Hetzner LoadBalancer  │
                    │   :80 :443 :22          │
                    └───────────┬─────────────┘
                                │
                                ▼
                    ┌─────────────────────────┐
                    │    NGINX Ingress        │
                    │    (TCP passthrough)    │
                    └───────────┬─────────────┘
                                │
    ┌───────────┬───────────┬───┼───┬───────────┬───────────┐
    │           │           │       │           │           │
    ▼           ▼           ▼       ▼           ▼           ▼
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│ Gitea  │ │  n8n   │ │ ArgoCD │ │ Victor.│ │ Istio  │ │  Apps  │
│        │ │        │ │        │ │ Metrics│ │ System │ │  Mesh  │
│Registry│ │Workers │ │GitOps  │ │Grafana │ │ Kiali  │ │  v1/v2 │
│  SSH   │ │Webhooks│ │        │ │Alertas │ │ Jaeger │ │Canary  │
└────────┘ └────────┘ └────────┘ └────────┘ └────────┘ └────────┘

                    GitOps Pipeline
         git push → build → registry → sync → deploy
                              ↓
                    Traffic Splitting (Istio)
         v1 (90%) ←──────────────────────→ v2 (10%)
```

## App de Demonstração: node-bugado

Aplicação Node.js que **trava intencionalmente** após N requisições:

```javascript
// Aceita requests até MAX_REQUESTS
// Depois para de responder (simula crash)
// /health também para de responder
```

Usada para demonstrar:
- Por que `restart: always` não é suficiente
- Como liveness probes detectam apps travadas
- Como readiness probes evitam tráfego para pods não-prontos
- Como KEDA escala baseado em métricas de saúde

## Estrutura do Repositório

```
workshop/
├── README.md              # Este arquivo
├── CLAUDE.md              # Instruções para Claude Code
├── aula-01/               # Docker Compose
├── aula-02/               # Liveness Probe
├── aula-03/               # Replicas + Readiness
├── aula-04/               # NGINX Keep Request
├── aula-05/               # KEDA + Victoria Metrics
├── aula-06/               # n8n Local
├── aula-07/               # Talos Linux Image
├── aula-08/               # Cluster Hetzner (OpenTofu)
├── aula-09/               # n8n Hetzner
├── aula-10/               # Gitea
├── aula-11/               # ArgoCD (GitOps)
├── aula-12/               # Victoria Metrics + Grafana
└── aula-14/               # Istio Traffic Splitting
```

Cada aula contém:
- `README.md` - Documentação completa
- `setup.sh` - Script de instalação (quando aplicável)
- `cleanup.sh` - Script de remoção
- Manifests YAML ou Helm values

## Licença

MIT