lucasacchi/laboratori-cloud
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(lab-02): complete Phase 3 - Network & VPC lab

Browse Source 
Implement Lab 02 with Docker bridge networks simulating VPC/Subnets.

Test Infrastructure (RED phase):
- 6 bash test scripts for network creation, isolation, INF-02 compliance
- Fail-fast orchestration with run-all-tests.sh
- Quick validation script for development

Documentation (Diátaxis framework):
- 3 tutorials: VPC creation, container deployment, isolation verification
- 4 how-to guides: create network, inspect config, test isolation, cleanup
- 3 reference docs: Docker network commands, Compose syntax, VPC mapping
- 1 explanation: Docker ↔ VPC parallels (PARA-01/02/03/04)

Infrastructure (GREEN phase):
- docker-compose.yml with VPC networks (10.0.1.0/24, 10.0.2.0/24)
- 5 services: web, app, db, test-public, test-private
- INF-02 compliant: 127.0.0.1 bindings only, no 0.0.0.0
- Private network with --internal flag
- Multi-homed app container (public + private networks)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Luca Sacchi Ricciardi
2026-03-25 17:26:35 +01:00
parent d4c4f7d717
commit 5b2c8c37aa
22 changed files with 3988 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
labs/lab-02-network/tutorial/01-create-vpc-networks.md Normal file
View File

@@ -0,0 +1,306 @@
# Tutorial: Creare Reti VPC con Docker Bridge Networks
In questo tutorial imparerai a creare reti Docker bridge che simulano le VPC (Virtual Private Cloud) e le subnet dei provider cloud. Capirai come segmentare il traffico di rete tra container usando concetti direttamente trasferibili ad AWS, Azure o GCP.
## Obiettivo
Creare due reti isolate che simulano una subnet pubblica e una subnet privata in una VPC cloud:
- **VPC Public Subnet**: `lab02-vpc-public` (10.0.1.0/24) - per servizi accessibili
- **VPC Private Subnet**: `lab02-vpc-private` (10.0.2.0/24) - isolata, senza accesso esterno
## Prerequisiti
- Docker Engine >= 24.0 installato e in esecuzione
- Comandi base Docker (`docker run`, `docker ps`)
- Completato Lab 01: IAM & Sicurezza (raccomandato)
---
## Passo 1: Comprendere i Concetti VPC
Prima di creare reti, capiremo cosa stiamo simulando.
**Concetti Cloud:**
- **VPC (Virtual Private Cloud)**: Rete virtuale isolata nel cloud
- **Subnet**: Segmento di indirizzi IP all'interno di una VPC (es. 10.0.1.0/24)
- **Subnet Pubblica**: Subnet con route verso internet gateway
- **Subnet Privata**: Subnet senza accesso diretto a internet
**Parallelismo Docker ↔ Cloud:**
| Concetto Docker | Cloud AWS |
|-----------------|-----------|
| Bridge Network | VPC |
| Subnet (10.0.x.0/24) | Subnet CIDR |
| --internal flag | Private subnet (no IGW) |
| Container | EC2 Instance |
---
## Passo 2: Creare la Subnet Pubblica
Creiamo la prima rete che simula una subnet pubblica VPC.
Esegui:
```bash
# Crea rete public subnet con subnet custom
docker network create --driver bridge \
--subnet 10.0.1.0/24 \
--gateway 10.0.1.1 \
lab02-vpc-public
```
Spiegazione:
- `--driver bridge`: Usa bridge driver (isolamento host locale)
- `--subnet 10.0.1.0/24`: CIDR block per questa subnet
- `--gateway 10.0.1.1`: Gateway predefinito per la subnet
- `lab02-vpc-public`: Nome che segue nomenclatura cloud
Atteso:
```
a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2
```
---
## Passo 3: Verificare la Creazione della Rete Pubblica
Verifichiamo che la rete sia stata creata correttamente.
Esegui:
```bash
# Lista tutte le reti
docker network ls | grep lab02
```
Atteso:
```
lab02-vpc-public bridge local
```
Esegui:
```bash
# Ispeziona la configurazione rete
docker network inspect lab02-vpc-public
```
Atteso (output formattato):
```json
{
"Name": "lab02-vpc-public",
"Driver": "bridge",
"IPAM": {
"Config": [
{
"Subnet": "10.0.1.0/24",
"Gateway": "10.0.1.1"
}
]
},
"Internal": false
}
```
Verifica che:
- [ ] Subnet sia `10.0.1.0/24`
- [ ] Gateway sia `10.0.1.1`
- [ ] Internal sia `false` (pubblica)
---
## Passo 4: Creare la Subnet Privata
Ora creiamo una rete isolata che simula una subnet privata.
Esegui:
```bash
# Crea rete private subnet (isolata)
docker network create --driver bridge \
--subnet 10.0.2.0/24 \
--gateway 10.0.2.1 \
--internal \
lab02-vpc-private
```
Spiegazione:
- `--internal`: Flag critico! Isola la rete (nessun accesso esterno)
- Subnet diversa: `10.0.2.0/24` (nessuna sovrapposizione con pubblica)
- Stesso gateway pattern: `10.0.2.1`
Atteso:
```
f1e2d3c4b5a697886950a2b3c4d5e6f7g8h9i0j1k2l3
```
---
## Passo 5: Verificare la Subnet Privata
Verifichiamo che la rete privata sia configurata correttamente.
Esegui:
```bash
# Ispeziona la rete privata
docker network inspect lab02-vpc-private
```
Atteso:
```json
{
"Name": "lab02-vpc-private",
"Driver": "bridge",
"IPAM": {
"Config": [
{
"Subnet": "10.0.2.0/24",
"Gateway": "10.0.2.1"
}
]
},
"Internal": true
}
```
Verifica che:
- [ ] Subnet sia `10.0.2.0/24`
- [ ] Gateway sia `10.0.2.1`
- [ ] **Internal sia `true`** (critico per isolamento!)
---
## Passo 6: Verificare Entrambe le Reti
Vediamo un riepilogo di entrambe le reti create.
Esegui:
```bash
# Lista reti lab02
docker network ls --filter "name=lab02" --format "table {{.Name}}\t{{.Driver}}\t{{.Scope}}"
```
Atteso:
```
NAME DRIVER SCOPE
lab02-vpc-private bridge local
lab02-vpc-public bridge local
```
Esegui:
```bash
# Verifica subnet CIDR
docker network inspect lab02-vpc-public --format '{{.IPAM.Config}}'
docker network inspect lab02-vpc-private --format '{{.IPAM.Config}}'
```
---
## Passo 7: Testare con un Container (Opzionale)
Verifichiamo che le reti funzionino creando un container di test.
Esegui:
```bash
# Crea container nella rete pubblica
docker run -d --name test-web \
--network lab02-vpc-public \
nginx:alpine
```
Esegui:
```bash
# Verifica che il container abbia IP dalla subnet corretta
docker inspect test-web --format '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'
```
Atteso:
```
10.0.1.2
```
(Indirizzo nella subnet 10.0.1.0/24 - corretto!)
Pulisci il test:
```bash
docker stop test-web
docker rm test-web
```
---
## Parallelismo con AWS VPC
| Operazione Locale | AWS VPC Equivalente |
|-------------------|---------------------|
| `docker network create` | `aws ec2 create-vpc` |
| `--subnet 10.0.1.0/24` | `aws ec2 create-subnet --cidr-block` |
| `--internal` | No route to Internet Gateway |
| `lab02-vpc-public` | `vpc-12345678` |
| Container nella rete | EC2 instance in subnet |
---
## Verifica
Hai completato questo tutorial quando:
- [ ] Rete `lab02-vpc-public` creata con subnet 10.0.1.0/24
- [ ] Rete `lab02-vpc-private` creata con subnet 10.0.2.0/24
- [ ] Rete privata ha `Internal: true`
- [ ] Entrambe le reti appaiono in `docker network ls`
- [ ] Capisci il parallelismo tra Docker bridge networks e VPC
## Prossimo Passo
Nel [prossimo tutorial](./02-deploy-containers-networks.md) imparerai a distribuire container in queste reti usando docker-compose.yml, creando un'architettura multi-tier (web pubblica, database privato).
---
## Troubleshooting
**Problema: `Error: network already exists`**
Soluzione:
```bash
# Rimuovi rete esistente
docker network rm lab02-vpc-public lab02-vpc-private
# Oppure usa nomi diversi
docker network create ... lab02-vpc-public-v2
```
**Problema: `Error: subnet conflicts with existing network`**
Soluzione:
```bash
# Verifica subnet in uso
docker network ls -q | xargs docker network inspect --format '{{.IPAM.Config}}'
# Cambia subnet in conflitto
docker network create --subnet 10.0.10.0/24 ...
```
**Problema: Container non ottiene IP dalla subnet corretta**
Soluzione:
```bash
# Verifica configurazione IPAM
docker network inspect lab02-vpc-public --format '{{json .IPAM}}'
# Assicurati che il container sia nella rete corretta
docker inspect container --format '{{json .NetworkSettings.Networks}}'
```
**Problema: `--internal flag blocks all communication`**
Questo è il comportamento corretto! I container in reti private:
- NON possono raggiungere internet
- NON possono essere raggiunti dall'host
- POSONO comunicare con altri container nella stessa rete

327
labs/lab-02-network/tutorial/02-deploy-containers-networks.md Normal file
View File

@@ -0,0 +1,327 @@
# Tutorial: Distribuire Container in Reti VPC
In questo tutorial imparerai a distribuire container multi-tier usando docker-compose.yml, posizionando i servizi nelle reti VPC appropriate seguendo il principio della sicurezza a livelli.
## Obiettivo
Creare un'architettura multi-tier con docker-compose:
- **Web Server**: nella rete pubblica (accessibile da localhost)
- **Database**: nella rete privata (isolato)
## Prerequisiti
- Completato [Tutorial 1: Creare Reti VPC](./01-create-vpc-networks.md)
- Docker Compose V2 installato
---
## Passo 1: Creare la Directory del Lab
Esegui:
```bash
cd ~/laboratori-cloud/labs/lab-02-network
```
---
## Passo 2: Creare docker-compose.yml
Crea il file `docker-compose.yml` con la configurazione multi-tier:
```yaml
services:
# Web server - rete pubblica
web:
image: nginx:alpine
container_name: lab02-web
networks:
vpc-public:
ipv4_address: 10.0.1.10
ports:
- "127.0.0.1:8080:80" # INF-02 compliant: solo localhost
restart: unless-stopped
# Database - rete privata
db:
image: postgres:16-alpine
container_name: lab02-db
environment:
POSTGRES_PASSWORD: lab02_password
POSTGRES_DB: lab02_db
networks:
vpc-private:
ipv4_address: 10.0.2.10
# Nessuna porta esposta - privato
volumes:
- db-data:/var/lib/postgresql/data
restart: unless-stopped
# Application - entrambe le reti
app:
image: nginx:alpine
container_name: lab02-app
networks:
vpc-public:
ipv4_address: 10.0.1.20
vpc-private:
ipv4_address: 10.0.2.20
ports:
- "127.0.0.1:8081:80"
restart: unless-stopped
networks:
vpc-public:
driver: bridge
name: lab02-vpc-public
ipam:
driver: default
config:
- subnet: 10.0.1.0/24
gateway: 10.0.1.1
vpc-private:
driver: bridge
name: lab02-vpc-private
internal: true
ipam:
driver: default
config:
- subnet: 10.0.2.0/24
gateway: 10.0.2.1
volumes:
db-data:
```
Salva il file.
---
## Passo 3: Verificare la Configurazione
Verifica che il file YAML sia valido.
Esegui:
```bash
docker compose config
```
Se valido, vedrai la configurazione completa. Se ci sono errori, verranno mostrati qui.
---
## Passo 4: Avviare i Servizi
Esegui:
```bash
docker compose up -d
```
Atteso:
```
[+] Running 4/4
✔ Network lab02-vpc-public Created
✔ Network lab02-vpc-private Created
✔ Container lab02-db Started
✔ Container lab02-web Started
✔ Container lab02-app Started
```
---
## Passo 5: Verificare lo Stato dei Servizi
Esegui:
```bash
docker compose ps
```
Atteso:
```
NAME IMAGE STATUS
lab02-app nginx:alpine Up
lab02-db postgres:16-alpine Up
lab02-web nginx:alpine Up
```
---
## Passo 6: Verificare il Posizionamento nelle Reti
Esegui:
```bash
# Verifica container web nella rete pubblica
docker inspect lab02-web --format '{{range .NetworkSettings.Networks}}{{.IPAddress}} in {{.NetworkID}}{{end}}'
```
Atteso (IP nella subnet pubblica):
```
10.0.1.10 in lab02-vpc-public
```
Esegui:
```bash
# Verifica database nella rete privata
docker inspect lab02-db --format '{{range .NetworkSettings.Networks}}{{.IPAddress}} in {{.NetworkID}}{{end}}'
```
Atteso (IP nella subnet privata):
```
10.0.2.10 in lab02-vpc-private
```
Esegui:
```bash
# Verifica app in entrambe le reti (multi-homed)
docker inspect lab02-app --format '{{range .NetworkSettings.Networks}}{{.IPAddress}} in {{.NetworkID}} | {{end}}'
```
Atteso:
```
10.0.1.20 in lab02-vpc-public | 10.0.2.20 in lab02-vpc-private
```
---
## Passo 7: Testare l'Accesso
Il web server e l'app sono accessibili da localhost (INF-02 compliant).
Esegui:
```bash
# Test web server
curl http://127.0.0.1:8080
```
Atteso: HTML response da nginx
Esegui:
```bash
# Test app
curl http://127.0.0.1:8081
```
Il database NON e accessibile dall'host (corretto - privato).
---
## Passo 8: Verificare l'Isolamento
Verifica che il database sia davvero isolato.
Esegui:
```bash
# Container web NON puo raggiungere database (reti diverse)
docker exec lab02-web ping -c 2 lab02-db
```
Atteso: FALLISCE (isolamento funzionante)
Esegui:
```bash
# Container app PUO raggiungere il database (connesso a entrambe)
docker exec lab02-app ping -c 2 lab02-db
```
Atteso: SUCCESSO (app fa da ponte)
---
## Architettura Multi-Tier
```
┌─────────────────┐
│ Host (127.0.0.1) │
└────────┬────────┘
│ 8080, 8081
┌────────▼────────┐
│ vpc-public │
│ 10.0.1.0/24 │
└────────┬────────┘
│
┌──────────────┼──────────────┐
│ │ │
┌─────▼─────┐ ┌────▼────┐ ┌──────▼──────┐
│ web │ │ app │ │ (isolated) │
│ 10.0.1.10 │ │10.0.1.20│ │ │
└───────────┘ └────┬────┘ └──────────────┘
│
┌──────▼────────┐
│ vpc-private │
│ 10.0.2.0/24 │
└──────┬────────┘
│
┌──────▼─────┐
│ db │
│ 10.0.2.10 │
└────────────┘
```
---
## Verifica
Hai completato questo tutorial quando:
- [ ] docker-compose.yml creato con 3 servizi
- [ ] Tutti i container sono in esecuzione
- [ ] Web e app sono accessibili da localhost
- [ ] Database e nella rete privata (non accessibile dall'host)
- [ ] App e connessa a entrambe le reti (multi-homed)
## Prossimo Passo
Nel [prossimo tutorial](./03-verify-network-isolation.md) imparerai a verificare e testare l'isolamento tra le reti.
---
## Troubleshooting
**Problema: Porta 8080 gia in uso**
Soluzione:
```bash
# Cambia porta nel compose
ports:
- "127.0.0.1:9090:80" # Usa 9090 invece di 8080
```
**Problema: Database non ottiene IP**
Soluzione:
```bash
# Verifica configurazione IPAM
docker compose down
docker compose up -d
docker inspect lab02-db --format '{{json .NetworkSettings.Networks}}'
```
**Problema: `ERROR: for lab02-db Cannot create container`**
Soluzione:
```bash
# Pulisci volumi e ricrea
docker compose down -v
docker compose up -d
```
**Problema: Container non comunicano**
Soluzione:
```bash
# Verifica che siano nella stessa rete
docker inspect lab02-web --format '{{json .NetworkSettings.Networks}}'
docker inspect lab02-db --format '{{json .NetworkSettings.Networks}}'
# Devono condividere almeno una rete
```

292
labs/lab-02-network/tutorial/03-verify-network-isolation.md Normal file
View File

@@ -0,0 +1,292 @@
# Tutorial: Verificare l'Isolamento delle Reti VPC
In questo tutorial imparerai a verificare e testare l'isolamento tra le reti Docker bridge, confermando che la tua architettura VPC multi-tier funziona correttamente.
## Obiettivo
Verificare che:
- I container nella stessa rete possono comunicare
- I container in reti diverse NON possono comunicare (isolamento)
- Il DNS funziona entro la stessa rete
- I container multi-homed possono raggiungere entrambe le reti
## Prerequisiti
- Completati [Tutorial 1](./01-create-vpc-networks.md) e [Tutorial 2](./02-deploy-containers-networks.md)
- Container in esecuzione: `docker compose ps` mostra 3 container attivi
---
## Passo 1: Verificare i Container in Esecuzione
Esegui:
```bash
cd ~/laboratori-cloud/labs/lab-02-network
docker compose ps
```
Assicurati che lab02-web, lab02-app, e lab02-db siano "Up".
Se non lo sono:
```bash
docker compose up -d
```
---
## Passo 2: Test Comunicazione Stessa Rete
I container nella stessa rete devono potersi comunicare.
Esegui:
```bash
# Verifica: app puo raggiungere web (stessa rete pubblica)
docker exec lab02-app ping -c 2 lab02-web
```
Atteso:
```
PING lab02-web (10.0.1.10): 56 data bytes
64 bytes from 10.0.1.10: seq=0 ttl=64 time=0.123 ms
64 bytes from 10.0.1.10: seq=1 ttl=64 time=0.045 ms
--- lab02-web ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
```
**SUCCESS** = Comunicazione funziona nella stessa rete.
---
## Passo 3: Test Comunicazione Cross-Rete (DEVE FALLIRE)
Verifica che l'isolamento funzioni.
Esegui:
```bash
# Verifica: web NON puo raggiungere db (reti diverse)
docker exec lab02-web ping -c 2 lab02-db
```
Atteso:
```
ping: bad address 'lab02-db'
```
Oppure:
```
PING lab02-db (10.0.2.10): 56 data bytes
--- lab02-db ping statistics ---
2 packets transmitted, 0 packets received, 100% packet loss
```
**FALLIMENTO ATTESO** = Isolamento funzionante!
Questo e corretto: `lab02-web` (10.0.1.10) non puo raggiungere `lab02-db` (10.0.2.10) perche sono in reti diverse.
---
## Passo 4: Test Container Multi-Homed
Il container `lab02-app` e connesso a entrambe le reti.
Esegui:
```bash
# Verifica: app puo raggiungere web (stessa rete pubblica)
docker exec lab02-app ping -c 2 lab02-web
```
Atteso: SUCCESSO
Esegui:
```bash
# Verifica: app puo raggiungere db (stessa rete privata)
docker exec lab02-app ping -c 2 lab02-db
```
Atteso: SUCCESSO
Questo dimostra che `lab02-app` puo fungere da ponte tra le reti.
---
## Passo 5: Test DNS Resolution
Verifica che il DNS funzioni entro la stessa rete.
Esegui:
```bash
# Test DNS nella stessa rete
docker exec lab02-app nslookup lab02-web
```
Atteso:
```
Name: lab02-web
Address 1: 10.0.1.10
```
Esegui:
```bash
# Test DNS cross-rete (dovrebbe fallire)
docker exec lab02-web nslookup lab02-db
```
Atteso: Fallisce o restituisce errore
---
## Passo 6: Test Accesso da Host
Verifica INF-02 compliance: servizi privati non accessibili dall'host.
Esegui:
```bash
# Test accesso web (pubblico, ma solo localhost)
curl http://127.0.0.1:8080
```
Atteso: SUCCESSO (HTML response)
Esegui:
```bash
# Test accesso app
curl http://127.0.0.1:8081
```
Atteso: SUCCESSO
Esegui:
```bash
# Test accesso database (privato - NON deve funzionare)
curl http://127.0.0.1:5432
```
Atteso:
```
curl: (7) Failed to connect to 127.0.0.1 port 5432 after X ms: Connection refused
```
Questo e corretto! Il database e nella rete privata senza porte esposte.
---
## Passo 7: Test Isolamento Internet (Rete Privata)
La rete privata con flag `--internal` non puo raggiungere internet.
Esegui:
```bash
# Test database non puo raggiungere internet
docker exec lab02-db ping -c 1 -W 1 8.8.8.8
```
Atteso: FALLISCE (nessuna route verso internet)
Questo e corretto per una subnet privata cloud.
---
## Passo 8: Test Container di Isolamento
Usa lo script di test del lab.
Esegui:
```bash
bash tests/02-isolation-verification-test.sh
```
Questo script verifica automaticamente tutti i casi di isolamento.
---
## Matrice di Connettività
| Source | Target | Stesso Network | Risultato |
|--------|--------|----------------|----------|
| web (10.0.1.10) | app (10.0.1.20) | Si (vpc-public) | SUCCESSO |
| app (10.0.1.20) | db (10.0.2.10) | Si (vpc-private) | SUCCESSO |
| web (10.0.1.10) | db (10.0.2.10) | No | FALLISCE |
| db (10.0.2.10) | web (10.0.1.10) | No | FALLISCE |
| Host (127.0.0.1) | web (8080) | Port mapping | SUCCESSO |
| Host (127.0.0.1) | db (5432) | Nessun mapping | FALLISCE |
| db | Internet (8.8.8.8) | --internal flag | FALLISCE |
---
## Verifica
Hai completato questo tutorial quando:
- [ ] Container nella stessa rete comunicano
- [ ] Container in reti diverse sono isolati (ping fallisce)
- [ ] Container multi-homed raggiungono entrambe le reti
- [ ] DNS risolve i nomi nella stessa rete
- [ ] Servizi privati non accessibili dall'host
- [ ] Rete privata non raggiunge internet
## Prossimi Passi
- Esegui la verifica finale: `bash tests/99-final-verification.sh`
- Leggi [Explanation: Parallelismi VPC](../explanation/docker-network-vpc-parallels.md)
- Procedi al Lab 03: Compute & EC2
---
## Troubleshooting
**Problema: Tutti i ping funzionano (nessun isolamento)**
Causa: Container potrebbero essere nella rete di default `bridge`
Soluzione:
```bash
# Verifica reti dei container
docker inspect lab02-web --format '{{json .NetworkSettings.Networks}}'
# Devono mostrare solo lab02-vpc-public, non "bridge"
```
**Problema: `lab02-app` non puo raggiungere nessuno**
Causa: IP statici potrebbero entrare in conflitto
Soluzione:
```bash
# Ricrea senza IP statici
docker compose down
# Rimuovi ipv4_address dal compose
docker compose up -d
```
**Problema: DNS non funziona**
Soluzione:
```bash
# Verifica configurazione DNS container
docker exec lab02-app cat /etc/resolv.conf
# Dovrebbe mostrare 127.0.0.11 (Docker embedded DNS)
```
**Problema: Container web non si avvia**
Soluzione:
```bash
# Verifica logs
docker compose logs web
# Verifica che la porta non sia in uso
ss -tlnp | grep 8080
```