Dimostrazione del lavoro con Docker

1.1 Definizione dell'obiettivo

Dai, creiamo una piccola applicazione multi-container e analizziamo passo dopo passo tutto il processo di sviluppo: dalla definizione dell'obiettivo alla dimostrazione del prodotto finito.

Obiettivo: creare un'app multi-container per la gestione delle attività che consente agli utenti di creare, modificare, eliminare attività e assegnarle ad altri utenti. L'app sarà composta da tre componenti principali: frontend in ReactJS, backend in Python (Flask) e database PostgreSQL.

Compiti principali:

1. Definire i requisiti funzionali per ogni componente dell'applicazione.
2. Scegliere le tecnologie e gli strumenti da utilizzare.
3. Preparare l'ambiente di sviluppo.

1.2 Definizione dei requisiti funzionali

Requisiti funzionali per un'applicazione di gestione delle attività:

1. Registrazione e autorizzazione degli utenti:
   • L'utente può registrarsi nel sistema.
   • L'utente può accedere al sistema.
2. Gestione delle attività:
   • L'utente può creare attività.
   • L'utente può modificare le attività.
   • L'utente può eliminare le attività.
   • L'utente può visualizzare l'elenco delle attività.
   • L'utente può assegnare attività ad altri utenti.
3. Visualizzazione e filtro delle attività:
   • L'utente può filtrare le attività per stato (completate/non completate).
   • L'utente può visualizzare le attività assegnate ad altri utenti.

1.3 Definizione delle tecnologie e degli strumenti utilizzati

Per creare questa applicazione useremo le seguenti tecnologie e strumenti:

1. Frontend:
   • ReactJS: libreria per la creazione di interfacce utente.
   • Axios: libreria per l'esecuzione di richieste HTTP.
2. Backend:
   • Python: linguaggio di programmazione per sviluppare la parte server.
   • Flask: web framework per creare REST API.
   • SQLAlchemy: ORM per interagire con il database.
3. Database:
   • PostgreSQL: database relazionale per memorizzare informazioni sugli utenti e sui compiti.
4. Containerizzazione e orchestrazione:
   • Docker: piattaforma per containerizzare le applicazioni.
   • Docker Compose: strumento per gestire applicazioni multi-container.

1.4 Preparazione dell'ambiente di sviluppo

Per completare con successo il progetto, è necessario configurare l'ambiente di sviluppo e assicurarsi che tutti gli strumenti necessari siano installati.

Passaggi per preparare l'ambiente:

1. Installazione di Docker:
   • Se non lo hai ancora fatto, torna alla lezione 4 del primo livello o segui le istruzioni sul sito ufficiale di Docker.
2. Installazione di Docker Compose:
   • Se Docker Compose non è ancora installato, fai riferimento alla lezione 2 del livello 4 o segui le istruzioni sul sito ufficiale di Docker Compose.
3. Creazione della struttura del progetto:
   • Crea una directory per il progetto e le directory principali per ogni servizio:

mkdir task_management_app
cd task_management_app
mkdir frontend backend database
        

1. Inizializzazione del progetto:
   • All'interno della directory frontend inizializza un nuovo progetto ReactJS:

cd frontend
npx create-react-app .
cd ..
        

• All'interno della directory backend crea una struttura per l'app Python/Flask:

cd backend
mkdir app
touch app/__init__.py
touch app/models.py
touch app/routes.py
touch run.py
touch requirements.txt
cd ..
        

• All'interno della directory database crea un Dockerfile per PostgreSQL (se necessario):

cd database
touch Dockerfile
cd ..
        

1.5 Esempio di contenuto dei file:

File backend/app/__init__.py:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://taskuser:taskpassword@database:5432/taskdb'
db = SQLAlchemy(app)

from app import routes
    

File backend/app/models.py:

from app import db

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    tasks = db.relationship('Task', backref='owner', lazy=True)

class Task(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(120), nullable=False)
    description = db.Column(db.Text, nullable=True)
    owner_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    

File backend/app/routes.py:

from app import app

@app.route('/')
def index():
    return "Ciao, App per la Gestione dei Task!"
    

File backend/run.py:

from app import app

if __name__ == '__main__':
    app.run(host='0.0.0.0')
    

File backend/requirements.txt:

Flask
Flask-SQLAlchemy
psycopg2-binary