laboratori-cloud/labs/lab-05-database/tutorial/03-security-compliance.md

# Tutorial: Security e Compliance per Database RDS

In questo tutorial imparerai a configurare e verificare la sicurezza del database, simulando RDS security best practices.

## Obiettivo

Configurare PostgreSQL con sicurezza enterprise: non-root, private network, resource limits.

## Prerequisiti

- Tutorial 01-02 completati
- Database in esecuzione con dati persistenti

---

## Passo 1: Verifica INF-01 - Non-root Execution

PostgreSQL official image NON gira come root.

Esegui:
```bash
# Verifica utente nel container
docker exec lab05-db whoami

# Atteso: postgres
```

Verifica UID:
```bash
# Verifica UID != 0
docker exec lab05-db id -u

# Atteso: 999 (postgres user UID)
```

Se l'utente è `root` o UID `0`, c'è una violazione di sicurezza.

---

## Passo 2: Verifica INF-02 - Private Network Isolation

Il database NON deve essere accessibile dall'host.

Esegui:
```bash
# Verifica NESSUNA porta mappata
docker port lab05-db

# Atteso: (nessun output)
```

Verifica rete:
```bash
# Verifica container in rete privata
docker inspect lab05-db --format '{{range $net, $conf := .NetworkSettings.Networks}}{{$net}}{{end}}'

# Atteso: lab05-vpc-private (solo rete privata)
```

Test isolamento:
```bash
# Prova connessione dall'host (DEVE fallire)
psql -h localhost -U lab05_user -d lab05_db 2>&1 || echo "Corretto: non accessibile"

# Prova connessione da container app (DEVE successo)
docker exec lab05-app psql -h db -U lab05_user -d lab05_db -c "SELECT 1;"
```

---

## Passo 3: Verifica INF-03 - Resource Limits

Il database deve avere limiti CPU e memoria.

Esegui:
```bash
# Verifica limiti configurati
docker inspect lab05-db --format '{{.HostConfig.Memory}}'
docker inspect lab05-db --format '{{.HostConfig.NanoCpus}}'
```

Verifica con docker-compose:
```bash
# Verifica configurazione compose
grep -A 10 "deploy:" docker-compose.yml | grep -A 5 "resources:"
```

Atteso:
- Memory: 4294967296 (4 GB)
- NanoCpus: 2000000000 (2 vCPU)

Test enforcement:
```bash
# Verifica limiti applicati
docker stats lab05-db --no-stream
```

---

## Passo 4: Verifica INF-04 - Named Volume

I dati devono persistere in volume nominativo.

Esegui:
```bash
# Verifica volume esista
docker volume ls | grep lab05_db-data

# Verifica montaggio
docker inspect lab05-db --format '{{range .Mounts}}{{if eq .Destination "/var/lib/postgresql/data"}}{{.Name}}{{end}}{{end}}'
```

Atteso: `lab05_db-data`

---

## Passo 5: Test Security Complete

Esegui lo script di verifica sicurezza.

Esegui:
```bash
cd tests
./04-security-test.sh
```

Tutti i test devono PASSARE.

---

## Passo 6: Configura Credenziali Forti

Le credenziali nel docker-compose.yml sono solo per laboratorio.

Esegui:
```bash
# Verifica credenziali attuali
grep POSTGRES_PASSWORD docker-compose.yml
```

Per produzione (simulazione RDS):
```bash
# NON usare password in chiaro
# Usa Docker secrets o variabili ambiente

# Esempio (solo riferimento, non implementare nel lab):
environment:
  POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
  db_password:
    external: true
```

---

## Passo 7: Limita Accessi con Security Groups

Simula security groups controllando chi può connettersi.

Esegui:
```bash
# Container app PUÒ connettersi (stessa rete privata)
docker exec lab05-app ping -c 2 db

# Container test-public NON può connettersi (rete diversa)
docker exec lab05-test-public ping -c 2 db || echo "Isolamento corretto"
```

Questo simula:
- Security group permette accessi da stessa VPC
- Security group blocca accessi da internet

---

## Passo 8: Abilita Logging e Monitoring

RDS fornisce logs metriche. Simula con Docker logs.

Esegui:
```bash
# Segui log PostgreSQL
docker logs -f lab05-db

# Filtra per errori
docker logs lab05-db 2>&1 | grep -i error

# Filtra per connessioni
docker logs lab05-db 2>&1 | grep -i connection
```

Per produzione:
```bash
# Configura PostgreSQL logging
# Aggiungi a postgresql.conf:
log_statement = 'all'
log_duration = on
log_line_prefix = '%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '
```

---

## Verifica Finale

Esegui la verifica finale completa.

Esegui:
```bash
cd tests
./99-final-verification.sh
```

Tutti i test devono PASSARE, inclusi:
- INF-01: Non-root
- INF-02: Private network
- INF-03: Resource limits
- INF-04: Named volume

---

## Parallelismo con RDS Security

| Locale | AWS RDS |
|--------|---------|
| Non-root container | AWS IAM authentication |
| Private network | VPC security group |
| Resource limits | Instance class limits |
| Named volume | EBS encryption |
| Docker logs | CloudWatch logs |
| pg_isready | RDS health check |

---

## Security Checklist

Prima di passare al production (simulato):

- [ ] Database gira come non-root
- [ ] NESSUNA porta esposta su host
- [ ] Limiti CPU e memoria configurati
- [ ] Volume nominativo per dati
- [ ] Credenziali non in chiaro (production)
- [ ] Logging abilitato
- [ ] Healthcheck configurato
- [ ] Backup strategy (production)

---

## Troubleshooting

### Container gira come root
```bash
# Verifica image
docker inspect lab05-db --format '{{.Config.User}}'

# PostgreSQL official image deve usare 'postgres'
# Se root, controlla Dockerfile
```

### Database accessibile dall'host
```bash
# Verifica porte mappate
docker port lab05-db

# Se porta mappata, rimuovi 'ports:' da docker-compose.yml
```

### Limiti non applicati
```bash
# Verifica Docker versione (>= 20.10 per deploy.resources)
docker version --format '{{.Server.Version}}'

# Verifica che 'deploy' sia configurato
grep -A 20 "db:" docker-compose.yml | grep "deploy:"
```

---

## Completamento Lab 05

Congratulazioni! Hai completato Lab 05 - Database & RDS.

Competenze acquisite:
- Deploy PostgreSQL in private network
- Configurare persistenza dati con volumi
- Implementare security best practices
- Simulare RDS con Docker

Prossimi step:
- Lab 06: Integration & Testing
- Lab 07: Repository Structure
- Lab 08: Troubleshooting Docs