# 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.

## 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)       GitLab               ArgoCD + Runner                  │
│  Multi-tenant        Registry + SSH       GitOps CI/CD                     │
└─────────────────────────────────────────────────────────────────────────────┘
```

## 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 | GitLab | Hetzner | Registry, SSH, Helm |
| 11 | ArgoCD | Hetzner | GitOps, Runner, CI/CD |

## Pré-requisitos

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

### Aulas 07-11 (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  # GitLab
cd aula-11 && ./setup.sh  # ArgoCD
```

## 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)
                                  │
                    ┌─────────────┼─────────────┐
                    │             │             │
                    ▼             ▼             ▼
              git.kube.quest  n8n.kube.quest  argocd.kube.quest
                    │             │             │
                    └─────────────┼─────────────┘
                                  │
                                  ▼
                    ┌─────────────────────────┐
                    │   Hetzner LoadBalancer  │
                    │   :80 :443 :22          │
                    └───────────┬─────────────┘
                                │
                                ▼
                    ┌─────────────────────────┐
                    │    NGINX Ingress        │
                    │    (TCP passthrough)    │
                    └───────────┬─────────────┘
                                │
        ┌───────────────────────┼───────────────────────┐
        │                       │                       │
        ▼                       ▼                       ▼
┌───────────────┐     ┌───────────────┐     ┌───────────────┐
│    GitLab     │     │     n8n       │     │    ArgoCD     │
│  (namespace)  │     │  (namespace)  │     │  (namespace)  │
│               │     │               │     │               │
│ - Webservice  │     │ - Main        │     │ - Server      │
│ - Sidekiq     │     │ - Workers     │     │ - Repo Server │
│ - Registry    │     │ - Webhooks    │     │ - Controller  │
│ - PostgreSQL  │     │ - PostgreSQL  │     │ - Redis       │
│ - Redis       │     │ - Redis       │     │               │
│ - MinIO       │     │               │     │ GitLab Runner │
└───────────────┘     └───────────────┘     └───────────────┘
        │                                           │
        └───────────────────────────────────────────┘
                    GitOps Pipeline
         git push → build → registry → sync → deploy
```

## 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/               # GitLab
└── aula-11/               # ArgoCD + GitLab Runner
```

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