Démonstration du travail avec Docker

1.1 Définition de la tâche

Allons créer une petite application multiconteneur et analyser étape par étape tout le processus de développement : de la définition de la tâche jusqu'à la démonstration du produit final.

Objectif : créer une application multiconteneur pour gérer des tâches, permettant aux utilisateurs de créer, modifier, supprimer des tâches et de les assigner à d'autres utilisateurs. L'application sera composée de trois composants principaux : un frontend sur ReactJS, un backend sur Python (Flask) et une base de données PostgreSQL.

Tâches principales :

1. Définir les exigences fonctionnelles pour chaque composant de l'application.
2. Choisir les technologies et outils à utiliser.
3. Préparer l'environnement de développement.

1.2 Définition des exigences fonctionnelles

Exigences fonctionnelles pour l'application de gestion des tâches :

1. Enregistrement et authentification des utilisateurs :
   • L'utilisateur peut s'enregistrer dans le système.
   • L'utilisateur peut se connecter au système.
2. Gestion des tâches :
   • L'utilisateur peut créer des tâches.
   • L'utilisateur peut modifier des tâches.
   • L'utilisateur peut supprimer des tâches.
   • L'utilisateur peut voir la liste des tâches.
   • L'utilisateur peut attribuer des tâches à d'autres utilisateurs.
3. Vue et filtrage des tâches :
   • L'utilisateur peut filtrer les tâches par statut (terminées/non terminées).
   • L'utilisateur peut voir les tâches attribuées à d'autres utilisateurs.

1.3 Définition des technologies et outils utilisés

Pour la mise en œuvre de cette application, les technologies et outils suivants seront utilisés :

1. Frontend :
   • ReactJS : bibliothèque pour créer des interfaces utilisateur.
   • Axios : bibliothèque pour effectuer des requêtes HTTP.
2. Backend :
   • Python : langage de programmation pour développer la partie serveur.
   • Flask : framework web pour créer des REST API.
   • SQLAlchemy : ORM pour interagir avec la base de données.
3. Base de données :
   • PostgreSQL : base de données relationnelle pour stocker les informations sur les utilisateurs et les tâches.
4. Containerisation et orchestration :
   • Docker : plateforme pour containeriser les applications.
   • Docker Compose : outil pour gérer les applications multi-conteneurs.

1.4 Préparation de l'environnement de développement

Pour réussir le projet, il est nécessaire de configurer l'environnement de développement et de s'assurer que tous les outils nécessaires sont installés.

Étapes pour préparer l'environnement :

1. Installation de Docker :
   • Si ce n'est pas encore fait, retournez à la leçon 4 du premier niveau ou suivez les instructions sur le site officiel de Docker.
2. Installation de Docker Compose :
   • Si Docker Compose n'est pas encore installé, consultez la leçon 2 du niveau 4 ou suivez les instructions sur le site officiel de Docker Compose.
3. Création de la structure du projet :
   • Créez un répertoire pour le projet et des sous-répertoires principaux pour chaque service :

mkdir task_management_app
cd task_management_app
mkdir frontend backend database
        

1. Initialisation du projet :
   • Dans le répertoire frontend, initialisez un nouveau projet ReactJS :

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

• Dans le répertoire backend, créez une structure pour une application 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 ..
        

• Dans le répertoire database, créez un Dockerfile pour PostgreSQL (si nécessaire) :

cd database
touch Dockerfile
cd ..
        

1.5 Exemple de contenu des fichiers :

Fichier 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
    

Fichier 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)
    

Fichier backend/app/routes.py :

from app import app

@app.route('/')
def index():
    return "Salut, Application de gestion des tâches!"
    

Fichier backend/run.py :

from app import app

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

Fichier backend/requirements.txt :

Flask
Flask-SQLAlchemy
psycopg2-binary