Update quelques apps

chapters/application.qmd

@@ -952,7 +952,7 @@ git checkout appli15
 :::
 
 
-{{< include "./applications/_appli17.qmd" >}}
+{{< include "./applications/_appli16.qmd" >}}
 
 
 ## Étape 2: déployer l'API de manière manuelle
@@ -961,7 +961,7 @@ git checkout appli15
 ## Si vous prenez ce projet fil rouge en cours de route
 
 ```{.bash filename="terminal"}
-git checkout appli18
+git checkout appli16
 ```
 
 ![](/checkpoint.jpg){width=80% fig-align="center"}
@@ -978,7 +978,7 @@ et d'avoir un serveur, en arrière plan, qui effectuera les opérations pour ré
 requête. Pour se faire, on va utiliser les possibilités offertes par `Kubernetes`, sur lequel est basé le [SSP Cloud](https://datalab.sspcloud.fr).
 
 
-{{< include "./applications/_appli18a.qmd" >}}
+{{< include "./applications/_appli17.qmd" >}}
 
 
 Nous avons préparé la mise à disposition de notre API mais à l'heure
@@ -987,7 +987,20 @@ de lancer manuellement une image `Docker` pour pouvoir y accéder.
 Ce type de travail est la spécialité de `Kubernetes` que nous allons
 utiliser pour gérer la mise à disposition de notre API. 
 
-{{< include "./applications/_appli18b.qmd" >}}
+{{< include "./applications/_appli18.qmd" >}}
+
+::: {.callout-note title="Gérer le CORS"}
+Notre API est accessible sans problème depuis `Python` ou notre navigateur.
+
+En revanche, si on désire utiliser `JavaScript` pour créer une application
+interactive il est indispensable de mettre
+les lignes un peu obscure sur le CORS dans le fichier `ingress.yaml`. 
+
+Comme c'est un point technique qui ne concerne pas les compétences
+liées à ce cours, nous donnons directement les mises à jour nécessaires
+du projet.
+:::
+
 
 On peut remarquer quelques voies d'amélioration de notre approche qui
 seront ultérieurement traitées:
@@ -1071,19 +1084,6 @@ Il y a donc un élément qui fait la liaison entre ces deux pipelines et qui nou
 
 
 
-::: {.callout-note title="Gérer le CORS"}
-Notre API est accessible sans problème depuis `Python` ou notre navigateur
-mais si on désire utiliser `JavaScript` pour créer une application
-interactive, on va essuyer un refus à cause du [CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS).
-
-Permettre à n'importe quel client de se connecter à 
-notre API permettra de faire un site web exploitant notre API. 
-Comme c'est un point technique qui ne concerne pas les compétences
-liées à ce cours, nous donnons directement les mises à jour nécessaires
-du projet:
-:::
-
-{{< include "./applications/_cors.qmd" >}}
 
 ## Etape 4: construire un site web
 

chapters/applications/_appli17.qmd

@@ -1,74 +1,31 @@
 ::: {.callout-tip}
+## Application 17: Dockeriser l'API (intégration continue)
 
-## Application 16: Mise à disposition sous forme d'API locale
+- Pour rendre la structure du projet plus lisible, déplacer `api.py` -> `api/main.py`
 
-- Installer `fastAPI` et `uvicorn` puis les ajouter au `requirements.txt`
-- Renommer le fichier `main.py` en `train.py`. Dans ce script, ajouter une
-sauvegarde du modèle après l'avoir entraîné, sous le
-format [`joblib`](https://scikit-learn.org/stable/model_persistence.html#python-specific-serialization). 
-- Faire tourner
-
-```{.bash filename="terminal"}
-python train.py
-```
-
-pour enregistrer en local votre modèle de production. 
-
-- Modifier les appels à `main.py` dans votre `Dockerfile` et vos actions `Github`
-sous peine d'essuyer des échecs lors de vos actions `Github` après le prochain _push_. 
-
-- Ajouter `model.joblib` au `.gitignore` car `Git` n'est pas fait pour 
-ce type de fichiers. 
-
-Nous allons maintenant passer au développement de l'API.
-Comme découvrir `FastAPI` n'est pas l'objet de cet enseignement, nous
-donnons directement le modèle pour créer l'API. Si vous
-désirez tester de vous-mêmes, vous pouvez créer votre 
-fichier sans vous référer à l'exemple
-
-- Créer le fichier `api.py` permettant d'initialiser l'API:
+- Créer un script `api/run.sh` à la racine du projet qui lance le script `train.py` puis déploie localement l'API 
 
 <details>
-<summary>
-Fichier `api.py`
-</summary>
+<summary>Fichier `run.sh`</summary>
 
-```{.python include="./applications/code/appli17_api_main.py" filename="src/models/train_evaluation.py"}
-```
-</details>
-
-- Déployer en local l'API avec la commande
+```{.bash filename="api/run.sh" no-prefix=true}
+#/bin/bash
 
-```{.bash filename="terminal"}
-uvicorn api:app --reload --host "0.0.0.0" --port 5000
-```
-
-- A partir du `README` du service, se rendre sur l'URL de déploiement, 
-ajouter `/docs/` à celui-ci et observer la documentation de l'API 
-- Se servir de la documentation pour tester les requêtes `/predict`
-- Récupérer l'URL d'une des requêtes proposées. La tester dans le navigateur
-et depuis `Python` avec `requests` :
-
-```{.python}
-import request
-requests.get(url).json()
+python3 train.py
+uvicorn api.main:app --reload --host "0.0.0.0" --port 5000
 ```
+</details>
 
-- Une fois que vous avez testé, vous pouvez tuer l'application en faisant <kbd>CTRL</kbd>+<kbd>C</kbd>. Retester
-votre bout de code `Python` et comprendre l'origine du problème.
+- Donner au script `api/run.sh` des permissions d'exécution : `chmod +x api/run.sh`
 
-:::
+- Ajouter `COPY api ./api` pour avoir les fichiers nécessaires au lancement dans l'API dans l'image
 
-::: {.callout-caution collapse="true"}
-## Checkpoint
+- Changer l'instruction `CMD` du `Dockerfile` pour exécuter le script `api/run.sh` au lancement du conteneur (`CMD ["bash", "-c", "./api/run.sh"]`)
 
-```{.bash filename="terminal"}
-git stash #<1>
-git checkout appli17
-```
-1. Pour annuler les modifications depuis le dernier _commit_
+- Mettre à jour votre `requirements.txt` pour tenir compte des nouveaux _packages_ utilisés
 
+- *Commit* et *push* les changements
 
-![](/checkpoint.jpg){width=80% fig-align="center"}
+- Une fois le CI terminé, récupérer la nouvelle image dans votre environnement de test de `Docker` et vérifier que l'API se déploie correctement
 
 :::

chapters/applications/_appli19b.qmd

@@ -21,6 +21,7 @@ on:
       - main
       - dev
     tags:
+      - 'v*.*.*'
 
 jobs:
   docker: