Ungol/ciel-b1
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity Actions

B2 - Ajoute TP 2 activité web

Browse source
This commit is contained in:
Alexis Fourmaux 2025-11-26 23:44:17 +01:00
parent d0221e2056
commit 292da982f2
4 changed files with 171 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/cours/CIEL2/02-python-flask/python-flask.md
View file

@ -85,10 +85,10 @@ Séquence intervenant en fin de deuxième année, peu avant les projets et néce
### C01 - COMMUNIQUER EN SITUATION PROFESSIONNELLE FRANÇAIS/ANGLAIS
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | ------------------------------------------------------------------------------------------------ | ------------------ |
| C01 | Communication écrite : cahiers des charges, dossiers de présentation | 3 |
| C01 | Règles de présentation et typographie | 3 |
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | -------------------------------------------------------------------- | ------------------ |
| C01 | Communication écrite : cahiers des charges, dossiers de présentation | 3 |
| C01 | Règles de présentation et typographie | 3 |
### C02 - ORGANISER UNE INTERVENTION
@ -130,17 +130,17 @@ Séquence intervenant en fin de deuxième année, peu avant les projets et néce
### C08 - CODER
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| C08 | Langages de développement, description, création d’API et IDE associés | 4 |
| C08 | Spécificités des environnements de développement, test, production | 2 |
| C08 | Chaînes d’intégration et de déploiement | 2 |
| C08 | Bases de données et environnements de traitement de données | 4 |
| C08 | Programmation multitâche | 3 |
| C08 | Outils de documentation | 3 |
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | ---------------------------------------------------------------------- | ------------------ |
| C08 | Langages de développement, description, création d’API et IDE associés | 4 |
| C08 | Spécificités des environnements de développement, test, production | 2 |
| C08 | Chaînes d’intégration et de déploiement | 2 |
| C08 | Bases de données et environnements de traitement de données | 4 |
| C08 | Programmation multitâche | 3 |
| C08 | Outils de documentation | 3 |
### C09 - INSTALLER UN RÉSEAU INFORMATIQUE
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | ----------------------------------------------------------------------------- | ------------------ |
| C09 | Systèmes d’exploitation Windows, UNIX, virtualisation | 3 |
| Compétence | Connaissance | Niveau taxonomique |
| ---------- | ----------------------------------------------------- | ------------------ |
| C09 | Systèmes d’exploitation Windows, UNIX, virtualisation | 3 |

2
src/cours/CIEL2/02-python-flask/tp/1_base_de_donnees.md
View file

@ -123,7 +123,7 @@ Ou si Gitlab est prêt, sous forme de dépôt git.
```admonish travail
- A l'aide du cahier des charges, définir le format qu'aura votre base de données.
- A l'aide du cahier des charges, définir les utilisateurs et leurs droits. Utilisez la [documentation](https://www.postgresql.org/docs/current/index.html) si nécessaire.
- Écrire le script SQL permettant de créer votre base
- Écrire le **script SQL** (à versionner) permettant de créer votre base (schéma + droits)
- L'appliquer pour le tester et le valider
- Compléter le document et faire un nouveau commit. Vous pouvez en faire plusieurs si vous le jugez nécessaire.
```

155
src/cours/CIEL2/02-python-flask/tp/2_monitoring_app.md Normal file
View file

@ -0,0 +1,155 @@
---
puppeteer:
format: A4
margin:
top: "0.5cm"
left: "0.5cm"
right: "0.5cm"
bottom: "0.5cm"
---
# Application Web - Activité 2 - Service d'observation des données d'utilisation de la machine
## Objectifs
- Développement d'une application Python qui collecte les métriques système
- Communication entre une application Python et une base PostgreSQL
- Développement d'une image Docker pour intégrer votre application dans le système
## Évaluation
- L'évaluation aura lieu
- au cours de l'activité sous forme orale
- à la fin de l'activité grâce aux livrables rendus
### Compétences évaluées
## Validation
### Livrables
Livrer le code et le dossier de conception à l'issue des 3 activités.
### Résultats attendus
- [ ] Un programme python qui observe les données du système et les enregistre en base de données
- [ ] Une image docker contenant le programme : le service de monitoring
- [ ] Une mise à jour du fichier docker-compose pour intégrer le service avec la base de données dans les bonnes pratiques de sécurité
## Étapes
### Étape 0 – Démarrage et configuration de l’environnement
**Objectif :** Créer un environnement pour le développement de l'application de monitoring, et installation des dépendances.
!!! example À faire
Nous repartons de l'environnement créé lors de l'activité précédente
- Créez un nouveau répertoire `monitoring` dans votre dépôt.
- Ajoutez-y un fichier [`requirements.txt`](https://pip.pypa.io/en/stable/reference/requirements-file-format/) listant les dépendances : `psutil==7.1.3` et `psycopg[binary]==3.2.12`.
- Créez un environnement virtuel Python (`venv`) et installez ces dépendances. (voir aide)
- Installer dépendances d'un `requirements.txt` : (dans un environnement virtuel activé) `pip install -r requirements.txt`
- À l’intérieur de `monitoring`, créez un sous-dossier `src` pour les sources Python, et dedans un fichier `app.py`
!!! question Aide
- Un environnement virtuel Python (venv) est un espace isolé qui contient une installation indépendante de Python ainsi que ses propres bibliothèques, ce qui évite les conflits entre projets.
- Pour créer un venv, on utilise la commande : `python -m venv .venv`.
- Ensuite, on active cet environnement avec la commande `source .venv/bin/activate`
- Enfin, on peut installer des dépendances spécifiques au projet sans impacter l’installation globale de Python ni d’autres projets
### Étape 1 – Script de collecte des données
**Objectif :** Écrire la fonction qui collectera les données de fonctionnement du système
!!! example À faire
- Écrivez une fonction `collect_metrics()` qui récupère les données de monitoring système.
- Cette fonction doit retourner un dictionnaire Python contenant les métriques nécessaires
- Utilisez la bibliothèque `psutil` et sa [documentation](https://psutil.readthedocs.io/en/latest/#) pour récupérer ces données
- Les données dont vous avez besoin sont celles demandées par le cahier des charges et pour lesquelles vous avez conçu votre base lors de l'activité précédente
- Écrivez une fonction main et appelez-la dans votre script. Elle devra appeler votre fonction `collect_metrics()`.
- Testez et validez votre code (en affichant, par exemple, le résultat obtenu)
- Complétez votre document de conception et faites un nouveau commit
!!! note Dans le document de conception
Expliquez ce que vous avez réalisé dans cette partie
### Étape 2 - Écriture en base de données
**Objectif:** Écrire la fonction pour insérer les données récoltées en base de données
!!! example À faire
- Récupérez les informations de connexion (hôte, base, utilisateur, mot de passe, port) [depuis les variables d’environnement](https://docs.python.org/3/library/os.html#os.environ) Python suivantes : `DB_HOST`, `DB_NAME`, `DB_USER`, `DB_PASSWORD`, `DB_PORT`.
- Utilisez `psycopg3.connect()` pour établir la connexion.
```python
conn = psycopg3.connect(
host=DB_HOST,
dbname=DB_NAME,
user=DB_USER,
password=DB_PASSWORD,
port=DB_PORT
)
```
- Écrire la fonction qui permettra d'insérer les données en base (voir aide). Cette fonction prendra en paramètre le dictionnaire créé dans l'étape précédente.
- Ajouter la nouvelle fonction à la fonction `main`.
- Pour tester votre programme localement (avec la base de données dans le conteneur)
- Lier le port 5432 du conteneur au port 5432 de la machine hôte dans le docker compose (et le relancer)
- Ajouter les variables d'environnement dans la commande permettant de lancer votre script, comme ci-dessous :
```bash
DB_HOST=localhost DB_NAME=sysmon DB_USER=metricwriter DB_PASSWORD=metricwriter DB_PORT=5432 python app.py
```
- Tester votre code et le valider
- Pour finir, il faut utiliser `time.sleep` et une boucle `while` infinie dans `main` pour recommencer l'opération chaque seconde.
- La période de mesure doit être configurable par variable d'environnement également. 1 seconde sera la valeur par défaut.
- Mettre à jour le document de conception et faire un nouveau commit
!!! question Aide
Pour insérer des données dans une base Postgres en Python :
```py
cur = conn.cursor() # Création d'un curseur à partir de la connexion : c'est l'objet qui va permettre d'exécuter les commandes SQL.
sql = "remplacer par requête" # Définition de la requête SQL d'insertion sous forme de chaîne de caractères. Ici, il faut remplacer cette chaîne par la requête INSERT adaptée.
cur.execute(sql, metrics) # Exécution de la requête SQL en passant les valeurs à insérer via le dictionnaire 'metrics'. Cela évite les injections SQL en utilisant des paramètres.
conn.commit() # Validation de la transaction : sans cet appel, les changements effectués ne seraient pas enregistrés définitivement dans la base.
cur.close() # Fermeture du curseur pour libérer les ressources utilisées par cet objet.
conn.close() # Fermeture de la connexion à la base, elle doit être fermée proprement pour éviter les fuites de connexions et libérer les ressources.
```
!!! warning Attention
Vous avez lié le port 5432 du conteneur postgres à celui de l'hôte. C'est utile en debug mais à proscrire en production, sauf si vous savez ce que vous faites. N'oubliez pas de retirer cette directive lorsque votre code est validé.
!!! note Dans le document de conception
- Expliquez les différentes étapes pour se connecter et écrire dans une base de données PostgresSQL depuis un programme Python
- Le port 5432 est le port standard de postgreSQL. Quel est le risque si on le laisse mappé sur le port 5432 de la machine hôte ?
- Expliquer le fonctionnement actuel de votre programme
### Étape 3 – Conteneurisation avec Docker
!!! example À faire
- Créer un nouveau fichier appelé `Dockerfile` dans votre répertoire `monitoring`. Il servira à créer votre image docker pour le service de monitoring.
- Ce fichier sera basé sur l'image `python:3.13-slim-bookworm`
- Écrire le Dockerfile à l'aide des informations suivantes :
- S'inspirer de la [documentation de l'image Python](https://hub.docker.com/_/python/)
- Il faudra installer les dépendances du fichier `requirements.txt`
- Il faut ajouter les fichiers du répertoire `src`
- Votre commande sera `python app.py`
- Construire l'image pour valider sa compilation : `docker build -t monitoring-service monitoring`
!!! note Dans le document de conception
- Expliquez l'intérêt d'utiliser `python:3.13-slim-bookworm` par rapport aux autres tags de l'image python (pourquoi `slim`, pourquoi `bookworm` ?)
- Pourquoi est-il inutile de créer un environnement virtuel dans notre image ?
- Expliquez les différentes étapes de votre Dockerfile et vos choix
### Étape 4 – Intégration dans un environnement multi-conteneurs
!!! example À faire
- Compléter le fichier `docker-compose.yml` pour y ajouter le service de monitoring. Compléter les informations :
- image : monitoring-service
- réseau : voir cahier des charges (architecture). Attention à le déclarer et à l'ajouter aussi au service postgres
- environment : variables de connexion à la base de données
- Démarrer votre stack et vérifier que tout fonctionne
!!! note Dans le document de conception
- Pourquoi a-t-on choisi d'avoir un réseau distinct pour accéder à la base de données ?
- Expliquez ce que vous avez réalisé dans cette partie, et dans cette activité.
- Donnez les difficultés rencontrées et la manière dont vous les avez résolues.

BIN
src/cours/CIEL2/02-python-flask/tp/2_monitoring_app.pdf Normal file
View file

Binary file not shown.