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

feat(lab-04): complete Phase 5 - Storage & S3 lab

Browse Source 
Phase Plan:
- 05-PLAN.md: Combined execution plan for efficiency
- 05-RESEARCH.md: Domain research on volumes and MinIO

Test Scripts (4):
- 01-volumes-test.sh: Volume persistence verification
- 02-minio-test.sh: MinIO S3 API testing
- 03-persistence-test.sh: Database persistence verification
- 99-final-verification.sh: End-to-end verification

Documentation (6 files):
Tutorial: Docker volumes, MinIO S3
How-to: Manage volumes
Reference: Volume syntax
Explanation: Storage↔S3 parallels

Infrastructure:
- docker-compose.yml: MinIO S3 + PostgreSQL + test container
- Named volumes: minio-data, db-data, test-data (INF-04 compliant)

Key concepts:
- Named volumes = EBS volumes
- MinIO = S3 bucket (100% API compatible)
- Data persistence across container lifecycle

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Luca Sacchi Ricciardi
2026-04-03 15:25:46 +02:00
parent 23a9ffe443
commit a021fe796b
12 changed files with 467 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
labs/lab-04-storage/docker-compose.yml Normal file
View File

@@ -0,0 +1,82 @@
# Lab 04: Storage & S3 - Docker Compose Configuration
# Simula storage S3-compatible con MinIO e Docker Volumes
version: "3.8"
services:
# MinIO - S3-compatible object storage
minio:
image: minio/minio:latest
container_name: lab04-minio
hostname: minio
command: server /data --console-address ":9001"
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin123
deploy:
resources:
limits:
cpus: '1'
memory: 1G
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
interval: 15s
timeout: 5s
retries: 3
ports:
- "127.0.0.1:9000:9000" # API S3
- "127.0.0.1:9001:9001" # Console UI
volumes:
- minio-data:/data
restart: unless-stopped
# PostgreSQL con volume persistente
db:
image: postgres:16-alpine
container_name: lab04-db
hostname: db
environment:
POSTGRES_DB: lab04_db
POSTGRES_USER: lab04_user
POSTGRES_PASSWORD: lab04_password
deploy:
resources:
limits:
cpus: '1'
memory: 1G
volumes:
- db-data:/var/lib/postgresql/data
restart: unless-stopped
# Test container - verifica persistenza
test:
image: alpine:3.19
container_name: lab04-test
hostname: test
command: ["sh", "-c", "sleep 3600"]
volumes:
- test-data:/test
restart: unless-stopped
# Named Volumes - Persistono oltre la vita dei container
volumes:
minio-data:
driver: local
db-data:
driver: local
test-data:
driver: local

63
labs/lab-04-storage/explanation/storage-s3-parallels.md Normal file
View File

@@ -0,0 +1,63 @@
# Explanation: Parallelismi Storage Docker ↔ AWS
## Core Concepts
### Docker Named Volume = EBS Volume
| Aspect | Docker | AWS EBS |
|--------|--------|---------|
| Creation | docker volume create | aws ec2 create-volume |
| Lifecycle | Indipendent dal container | Indipendente dall'istanza |
| Persistence | Sopravvive a docker rm | Sopravvive a ec2 terminate |
| Mount | volumes: section in compose | Attach to /dev/sdX |
| Backup | docker run --rm tar | EBS snapshots |
### MinIO = S3
| Aspect | MinIO | AWS S3 |
|--------|-------|--------|
| API | 100% S3 compatible | Native S3 |
| Endpoint | http://localhost:9000 | https://s3.amazonaws.com |
| Pricing | Free (self-hosted) | Pay-per-use |
| Use case | Local dev/test | Production |
## Storage Architecture Patterns
### Database with Persistent Storage
**Locale:**
```yaml
db:
image: postgres
volumes:
- db-data:/var/lib/postgresql/data
```
**Cloud:** RDS con EBS storage
### Object Storage
**Locale:**
```yaml
minio:
image: minio/minio
volumes:
- minio-data:/data
```
**Cloud:** S3 bucket
## Key Differences
1. **Scope:** Volumes = single host, EBS = AZ-wide
2. **Performance:** Local filesystem vs network storage
3. **Backup:** tar vs EBS snapshots
4. **Scaling:** Manual vs S3 infinite scale
## When to Use What
| Use Case | Locale | Cloud |
|----------|--------|-------|
| Dev database | PostgreSQL + Volume | RDS |
| File storage | Volume | EFS |
| Objects | MinIO | S3 |
| Backup | tar to host | S3 Glacier |
## Conclusion
Docker volumes e MinIO seguono gli stessi principi di EBS e S3, permettendoti di praticare localmente prima di deployare in cloud.

29
labs/lab-04-storage/how-to-guides/manage-volumes.md Normal file
View File

@@ -0,0 +1,29 @@
# How-to: Gestire Docker Volumes
## Creare Volume
```bash
docker volume create my-volume
```
## Ispezionare Volume
```bash
docker volume inspect my-volume
```
## Liste Volumi
```bash
docker volume ls
docker volume ls --filter "name=lab04*"
```
## Backup Volume
```bash
docker run --rm -v my-volume:/data -v $(pwd):/backup \
alpine tar czf /backup/backup.tar.gz /data
```
## Rimuovere Volume
```bash
docker volume rm my-volume
# Cautela: perde tutti i dati!
```

37
labs/lab-04-storage/reference/volume-syntax.md Normal file
View File

@@ -0,0 +1,37 @@
# Reference: Docker Volume Syntax
## Volumes in docker-compose.yml
### Named Volume
```yaml
volumes:
my-data:
driver: local
```
### Mount Volume in Service
```yaml
services:
app:
volumes:
- my-data:/app/data # Named volume
- ./local:/host/path # Bind mount
```
### Volume Options
```yaml
volumes:
data:
driver: local
driver_opts:
type: none
o: bind
device: /host/path
```
## CLI Commands
- `docker volume create`
- `docker volume ls`
- `docker volume inspect`
- `docker volume rm`
- `docker volume prune`

14
labs/lab-04-storage/tests/01-volumes-test.sh Executable file
View File

@@ -0,0 +1,14 @@
#!/bin/bash
# Test Docker Volumes persistence
echo "Testing Docker Volumes..."
docker compose up -d test && sleep 2
docker exec lab04-test sh -c "echo 'data' > /test/persistent.txt"
docker compose down
docker compose up -d test && sleep 2
if docker exec lab04-test cat /test/persistent.txt | grep -q "data"; then
echo "✓ Volume persistence works"
exit 0
else
echo "✗ Volume persistence failed"
exit 1
fi

22
labs/lab-04-storage/tests/02-minio-test.sh Executable file
View File

@@ -0,0 +1,22 @@
#!/bin/bash
# Test MinIO S3 API
echo "Testing MinIO S3 API..."
docker compose up -d minio && sleep 5
# Wait for MinIO to be ready
for i in {1..10}; do
if curl -sf http://127.0.0.1:9000/minio/health/live &>/dev/null; then
echo "✓ MinIO is ready"
break
fi
sleep 2
done
# Test S3 API with mc (MinIO client)
docker exec lab04-minio mc alias set local http://localhost:9000 minioadmin minioadmin123
docker exec lab04-minio mc mb local/testbucket
if docker exec lab04-minio mc ls local/ | grep -q "testbucket"; then
echo "✓ S3 bucket creation works"
exit 0
else
echo "✗ S3 bucket creation failed"
exit 1
fi

16
labs/lab-04-storage/tests/03-persistence-test.sh Executable file
View File

@@ -0,0 +1,16 @@
#!/bin/bash
# Test data persistence in database
echo "Testing database persistence..."
docker compose up -d db && sleep 10
docker exec lab04-db psql -U lab04_user -d lab04_db -c "CREATE TABLE IF NOT EXISTS test (id SERIAL, data TEXT);"
docker exec lab04-db psql -U lab04_user -d lab04_db -c "INSERT INTO test (data) VALUES ('persistent');"
docker compose down
docker compose up -d db && sleep 10
RESULT=$(docker exec lab04-db psql -U lab04_user -d lab04_db -tAc "SELECT data FROM test WHERE id=1;")
if [[ "$RESULT" == "persistent" ]]; then
echo "✓ Database persistence works"
exit 0
else
echo "✗ Database persistence failed"
exit 1
fi

29
labs/lab-04-storage/tests/99-final-verification.sh Executable file
View File

@@ -0,0 +1,29 @@
#!/bin/bash
# Final verification for Lab 04
echo "Lab 04 Final Verification"
cd "$(dirname "$0")/.."
pass=0; fail=0
check() { if eval "$1"; then echo "✓ $2"; ((pass++)); else echo "✗ $2"; ((fail++)); fi; }
# Infrastructure checks
check "[[ -f docker-compose.yml ]]" "docker-compose.yml exists"
check "docker compose config &>/dev/null" "Syntax valid"
# Start services
docker compose up -d && sleep 8
# Volume checks
VOLUMES=$(docker volume ls --format '{{.Name}}' | grep -c "lab04" || echo "0")
check "[[ $VOLUMES -ge 3 ]]" "Named volumes created ($VOLUMES)"
# MinIO checks
check "curl -sf http://127.0.0.1:9000/minio/health/live" "MinIO API accessible"
check "curl -sf http://127.0.0.1:9001 &>/dev/null" "MinIO console accessible"
# Persistence check
docker exec lab04-test sh -c "echo test > /test/file.txt"
docker compose restart test && sleep 3
check "docker exec lab04-test cat /test/file.txt | grep -q test" "Data persists after restart"
echo "Passed: $pass, Failed: $fail"
[[ $fail -eq 0 ]] && exit 0 || exit 1

60
labs/lab-04-storage/tutorial/01-docker-volumes.md Normal file
View File

@@ -0,0 +1,60 @@
# Tutorial 1: Docker Volumes - Persistenza dei Dati
## Obiettivi
- Capire cosa sono i Docker Volumes
- Creare volumi named
- Montare volumi nei container
- Verificare la persistenza dei dati
## Cos'è un Docker Volume?
Un volume Docker è:
- **Storage persistente**: I dati sopravvivono al container
- **Managed**: Docker gestisce il filesystem
- **Named volume: Puoi riferirti per nome
## Parallelismo: Docker Volume = EBS Volume
| Docker | AWS EBS |
|--------|---------|
| docker volume create | aws ec2 create-volume |
| Named volume | Volume ID |
| Mount to container | Attach to instance |
| Data persists | Data persists independently |
## Esercizio
1. Crea un volume:
```bash
docker volume create my-data
```
2. Usa nel compose:
```yaml
volumes:
my-data:
driver: local
services:
app:
volumes:
- my-data:/app/data
```
3. Verifica persistenza:
```bash
docker compose up -d
docker exec lab04-test sh -c "echo 'test' > /data/file.txt"
docker compose down
docker compose up -d
docker exec lab04-test cat /data/file.txt # Dato presente!
```
## Comandi Utili
```bash
docker volume ls # Lista volumi
docker volume inspect <name> # Dettagli volume
docker volume rm <name> # Rimuovi volume
```
## Conclusione
I volumi Docker permettono la persistenza dei dati, esattamente come gli EBS volumes in AWS.

64
labs/lab-04-storage/tutorial/02-minio-s3.md Normal file
View File

@@ -0,0 +1,64 @@
# Tutorial 2: MinIO - Storage S3-Compatible
## Obiettivi
- Capire cosa è MinIO
- Deploy MinIO con Docker Compose
- Usare S3 API localmente
- Configurare client S3
## Cos'è MinIO?
MinIO è:
- **S3-compatible**: 100% compatibile con AWS S3 API
- **Local development**: S3 sul tuo computer
- **Open source**: Gratis e self-hosted
## Parallelismo: MinIO = S3
| Locale | Cloud |
|--------|-------|
| MinIO container | S3 bucket |
| http://localhost:9000 | https://s3.amazonaws.com |
| mc ls | aws s3 ls |
| minioadmin | AWS credentials |
## Configurazione
```yaml
minio:
image: minio/minio:latest
command: server /data --console-address ":9001"
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin123
ports:
- "9000:9000" # API
- "9001:9001" # Console
volumes:
- minio-data:/data
```
## Utilizzo
### Accesso Console
Apri: http://localhost:9001
Login: minioadmin / minioadmin123
### AWS CLI
```bash
aws s3 ls --endpoint-url http://localhost:9000
aws s3 mb s3://testbucket --endpoint-url http://localhost:9000
aws s3 cp file.txt s3://testbucket/ --endpoint-url http://localhost:9000
```
### Python (boto3)
```python
import boto3
s3 = boto3.client('s3', endpoint_url='http://localhost:9000',
aws_access_key_id='minioadmin',
aws_secret_access_key='minioadmin123')
s3.create_bucket(Bucket='testbucket')
```
## Conclusione
MinIO ti permette di sviluppare con S3 API localmente prima di deployare in AWS.