# Développement d'une application web en microservices - Itération 1

## Compétences
| Nom | Description                              |
| --- | ---------------------------------------- |
| C01 | Communiquer en situation professionnelle |
| C02 | Organiser une intervention               |
| C04 | Analyser un système informatique         |
| C05 | Concevoir un système informatique        |
| C09 | Installer un réseau informatique         |

## Objectifs

- Analyse du cahier des charges
- Déploiement du SGBD PostgreSQL dans un conteneur docker à l'aide de docker-compose
- Développement du schéma de la base de données
- Paramétrage des droits d'accès à la base de données
- (Optionnel) Sauvegarde et restauration de la base

## Validation

### Livrables

- Le code final
  - Script de la base de données
  - Fichier `docker-compose.yml`
- Document de conception (partiel : on le complètera au fil des itérations)
  - MCD et MPD de la base de données
  - Justification des choix de conception
    - Persistance de données du conteneur
    - Sécurisation des accès à la base de données

Le tout dans un répertoire avec le nom suivant `YYYY-MM-DD_TPX_NOM1_Prenom1_NOM2_Prenom2`.
- Le compte rendu peut-être livré au format Markdown ou PDF. 
- Si vous choisissez le Markdown, attention à bien livrer les éventuelles images et à la validité des liens

Ou si Gitlab est prêt, sous forme de dépôt git.

### Résultats attendus

- [ ] Le docker compose est fonctionnel et permet de déployer une base de données PostgreSQL avec un volume persistant
- [ ] Le script de la base de données est fonctionnel et permet de créer les tables et les utilisateurs nécessaires
- [ ] Le document de conception est en cours d'élaboration et justifie les éléments techniques de l'itération
- [ ] Le dossier de projet est organisé clairement et sépare les éléments techniques dans des répertoires dédiés. 
- [ ] Aucune donnée non nécessaire n'est versionnée avec le projet (volume docker notamment)
- [ ] Le projet est versionné sous git, les commits sont correctement commentés et bien segmentés

## Ressources fournies

- Cahier des charges
- Machine virtuelle sous Ubuntu Server 24.04 avec Docker préinstallé
  - user : `vboxuser`
  - mot de passe : `password`
- Documentations
  - [PostgreSQL](https://www.postgresql.org/docs/current/index.html)
  - [Docker Compose CLI](https://docs.docker.com/reference/cli/docker/compose/)
  - [Docker Compose File Reference](https://docs.docker.com/reference/compose-file/)
  - [Image Docker Officielle de PostgreSQL](https://hub.docker.com/_/postgres/)


## Étapes

### 0 - Mise en place

**Objectif :** Récupérer la machine virtuelle et la démarrer puis s'y connecter via VSCode

```admonish travail
- Récupérer la machine virtuelle sur le réseau et l'ajouter à virtualbox
- La configurer en mode bridge (Configuration > Réseau > Attached to > Accès par pont)
- La démarrer en tâche de fond avec interface détachable (cliquer sur la petite flèche à côté du bouton démarrer puis `Start with detachable GUI`)
- Vous connecter, noter l'adresse IP, puis fermer la GUI (mais ne pas éteindre la VM ! Sélectionner `Continuer en tâche de fond`)
- Démarrer VSCode et installer l'extension de Microsoft `Remote - SSH`
- Cliquer dans l'extension `Remote SSH` à gauche et cliquer sur le bouton `+`. Taper `ssh vboxuser@remplacer-par-adresse-ip`
- Vous connecter à la VM avec le mode Remote SSH. VSCode devrait ouvrir une nouvelle fenêtre et vous demander le mot de passe
  - Une fois connecté, vous avez un VSCode ouvert dans la machine distante. Nous parlerons de la VM (sauf mention contraire) à partir de maintenant.
  - Installez les extensions dont vous pensez avoir besoin (Markdown par exemple)
- Ouvrez un terminal (dans VSCode, pour qu'il soit dans la machine virtuelle) puis 
  - Vérifiez que docker soit installé et fonctionne avec `docker run hello-world`
- Créez un répertoire de travail `/home/vboxuser/sysmon` à l'aide du terminal puis ouvrez-le dans VSCode grâce à l'explorateur > Open Folder
- Créez un fichier `README.md` qui vous servira de document de conception
- Initialisez un dépôt git avec `git init` et faites un commit initial avec le compte rendu vide
- Vous êtes prêt.e à démarrer
```

### 1 - Démarrer un conteneur postgreSQL

**Objectif :** Utiliser docker-compose pour démarrer un conteneur avec PostgreSQL

```admonish travail
- Créer un fichier `docker-compose.yml`
- Vous servir de la [documentation](https://hub.docker.com/_/postgres/) pour créer une stack :
  - Postgres 
    - Version 18
    - nom de la base : sysmon
    - utilisateur admin : sysmon
    - mot de passe (pour l'instant) : sysmon
    - un volume persistant : postgres monté sur `/var/lib/postgresql` en read-write
    - Un seul réseau (pour le moment) : 
      - `adminer`
  - Adminer (pour faciliter le dev)
    - port 8080 mappé sur le port 8080 de l'hôte
    - Réseau `adminer`
  - Déclarez les [volumes](https://docs.docker.com/reference/compose-file/volumes/) et les [réseaux](https://docs.docker.com/reference/compose-file/networks/) en bas du fichier compose.
- Démarrez votre stack
- Vérfiez que vous arrivez à vous connecter à adminer avec `http://<ip-de-votre-vm>:8080`
  - Tapez les identifiants de la base de données pour vous y connecter
  - Attention au nom du serveur : utilisez bien le nom donné à votre service dans le docker-compose
- Complétez votre README.md et faites un commit
```

```admonish note title="Dans le document de conception"
- Expliquez ce que vous avez mis en place pour cette première étape. En particulier :
  - à quoi sert le volume `postgres` et pourquoi est-il monté sur `/var/lib/postgresql` ?
  - pourquoi avoir créé un réseau `adminer` ? 
- A votre avis, y a-t-il un risque à laisser adminer sur un système en production, mappée sur le port 8080 de l'hôte ?
- Lister ce qu'il faudra changer pour sécuriser la configuration actuelle.
```

### 2 - Création de la base de données

**Objectif :** Créer un script SQL qui permet de créer les tables et les utilisateurs, ainsi que configurer les droits

```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** (à 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.
```

```admonish help title="Aide"
Pour taper des commandes SQL dans votre base vous pouvez au choix :
- utiliser l'interface web de adminer
- vous connecter dans une console postgres via `docker compose exec -ti db /bin/psql -U sysmon` (remplacer db par le nom du service postgres dans votre stack) puis vous connecter à la base avec `\c sysmon`
- Si vous avez besoin de réinitialiser la base vous pouvez faire :
  - `docker compose down` pour arrêter la stack et supprimer les conteneurs
  - `docker volume rm sysmon_postgres` pour supprimer le volume
  - `docker compose up` pour relancer
```

```admonish warning title="Attention"
Il faut réfléchir dès cette étape à la sécurisation de la base. Nous garderons cependant un utilisateur admin facile d'accès pour faciliter le développement, mais gardez en tête que sur le système en production, il faudra changer le mot de passe du superutilisateur de postgres
```

```admonish note title="Dans le document de conception"
- Décrire votre base de données (MPD +  commentaires) qui devrait être très simple
- Détailler les utilisateurs et les droits créés. Justifier vos choix.
- Imaginez que vous allez écrire toutes le ssecondes une ligne avec des données. Quel problème risque de se poser à moyen/long terme ?
  - Proposez une stratégie qui agit sur trois leviers différents pour pallier ce problème
```

### 3 - Mise en place des sauvegardes

**Objectif :** Vérifier que vous êtes en mesure d'effectuer une sauvegarde et une restauration de votre base de données

```admonish travail
- A l'aide de la [documentation](https://www.postgresql.org/docs/current/backup-dump.html) effectuez un dump de la base `sysmon` au format **custom** postgres.
- Récupérez ce dump sur la machine hôte.
- Effacez votre base (en supprimant le volume, voir Aide de l'étape 2) et restaurez votre dump
- Créez deux scripts shell permettant de 
  - récupérer un dump de la base sur la machine hôte
  - restaurer un dump dans la base
- Faites un nouveau commit
```

```admonish help title="Aide"
- Pour exécuter une commande dans un conteneur docker compose, vous pouvez utiliser `docker compose exec -ti <service> <programme>`
- Pour copier des fichiers entre un conteneur et la machine hôte, vous pouvez utiliser `docker compose cp` (utilisez l'aide pour en savoir plus)
```

```admonish note title="Dans le document de conception"
- Quels sont les avantages et inconvénients du dump au format custom de postgres ?
- En production, que faudrait-il faire avec les sauvegardes pour pouvoir assurer une reprise d'activité avec le minimum de pertes en cas d'incident sur l'hôte ?
  - Proposer une solution technique simple pour appliquer ces idées lors d'un éventuel passage en production
```


