Aller au contenu
English

Mettre la démo en production

  • Leçon 18
  • 90 min
  • Module 6 : Déployer et exploiter

Où nous en sommes

Dans la leçon précédente, nous avons construit une image testée. Maintenant, nous la démarrons comme démo privée. Mais les secrets doivent rester hors de l'image, les parties doivent démarrer dans le bon ordre, et nous devons savoir quand elle est vraiment prête. Dans cette leçon, nous mettons la démo en production et nous prouvons le parcours principal avec un test de fumée, comme une boulangère qui ouvre sa boutique le matin.

Ce que vous saurez faire

Démarrez l’image testée comme démo privée sur votre ordinateur. Ses secrets restent hors de l’image. Elle démarre dans le bon ordre et indique quand elle est prête. Ses journaux sont utiles sans montrer les questions des gens. Un test de fumée vérifie le parcours principal en quelques secondes.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 90 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • La copie propre ~/projects/doc-assistant-ci de Pipeline de construction : exercice guidé, avec son environnement virtuel, .env, .idp/ et l’image doc-assistant:1.0.0. Si vous ne l’avez pas, faites d’abord les étapes 1, 2 et 9 de cet exercice.
  • Docker Desktop en marche, avec au moins 2 Go de mémoire libre pour les conteneurs.
  • Les ports 8000, 8400 et 5432 libres sur votre ordinateur, ou d’autres ports dans .env (API_PORT, IDP_PORT, DB_PORT).

Testé sur macOS (Apple silicon) avec Docker Engine 29.6.1. L’équipe du cours a rédigé les commandes Windows et Linux, sans les tester. Elle a aussi rédigé les étapes dans le nuage à la fin, sans les exécuter.

Imaginez une boulangère qui ouvre sa boutique à sept heures. Elle déverrouille la porte avec la clé dans sa poche. Elle ne colle jamais la clé sur la porte. Elle allume le four et la caisse, puis attend que le four soit chaud. Elle se vend le premier pain pour vérifier que la caisse imprime un reçu. Ensuite seulement, elle passe l’affiche sur la porte de « Fermé » à « Ouvert ».

Des lumières allumées ne signifient pas que la boutique peut vendre. Si la caisse est brisée, l’affiche reste sur « Fermé ». Les clients attendent dehors au lieu de faire la file à l’intérieur pour rien.

Le problème : démarré ne veut pas dire fonctionnel

Section intitulée « Le problème : démarré ne veut pas dire fonctionnel »

L’image de Sam a réussi toutes les vérifications. Elle doit maintenant fonctionner comme démo, avec sa base de données et son fournisseur d’identité. Trois problèmes peuvent survenir, dont deux sans signal évident.

D’abord, les secrets. L’API a besoin du mot de passe de la base de données, du secret de session et du secret client. S’ils manquent, Compose refuse de démarrer quoi que ce soit, avant même le lancement d’un seul conteneur :

Terminal
docker compose --profile app config -q
error while interpolating services.api.environment.SESSION_SECRET: required variable SESSION_SECRET is missing a value: Run python -m idp init first

Cet échec est visible et survient tôt, ce qui est bien. Le message indique aussi quoi faire.

Ensuite, l’ordre. L’API ne doit pas démarrer avant que la base de données accepte les connexions et que les migrations soient exécutées. Sinon, elle échoue à sa première requête ou utilise un ancien schéma.

Enfin, un problème silencieux : un processus qui tourne, mais ne peut pas fonctionner. Pendant l’exécution de Sam, on a arrêté volontairement le conteneur de base de données, tandis que l’API continuait de tourner. Le processus de l’API était encore actif :

Terminal
curl http://127.0.0.1:8000/health
{"status":"ok","version":"1.0.0"}

Le processus dit « ok », et c’est vrai : il tourne. Mais il ne peut répondre à aucune question. Une vérification qui demande seulement « le processus tourne-t-il? » enverrait Grace vers un assistant qui échoue à chaque clic.

L’idée : une mise en production qui attend d’être prête

Section intitulée « L’idée : une mise en production qui attend d’être prête »

D’abord, deux termes. Un déploiement place une version du produit là où ses utilisateurs peuvent y accéder, puis la démarre. Une mise en production est le déploiement d’une nouvelle version munie d’une étiquette. Dans ce cours, le déploiement est une démo privée sur votre propre ordinateur.

Les habitudes de la boulangère deviennent cinq règles de mise en production :

  • Les secrets viennent de l’extérieur. Un secret est une valeur qui donne accès : mot de passe, clé de signature ou secret de session. Il reste dans .env ou dans le magasin de secrets de la plateforme, jamais dans l’image ni dans Git.
  • Démarrez dans l’ordre, les migrations d’abord. La base de données doit être en santé avant l’exécution des migrations. Les migrations doivent se terminer avant le démarrage de l’API.
  • Deux questions de santé. La vitalité demande « le processus tourne-t-il? » (/health). L’état de préparation demande « peut-il faire son travail maintenant? » (/ready : la base de données répond et toutes les migrations sont appliquées). Une plateforme redémarre un processus qui n’est plus actif. Elle n’envoie aucun utilisateur vers un processus qui n’est pas prêt.
  • Un test de fumée après chaque démarrage. Un test de fumée vérifie brièvement le parcours principal depuis l’extérieur, en quelques secondes. Le nom vient de l’électronique : allumez le nouvel appareil et regardez s’il dégage de la fumée. C’est le premier pain de la boulangère.
  • Privée par défaut. Une démo s’adresse aux personnes à qui vous la montrez, sur votre écran.

Le fichier compose.yaml de Sam contient quatre services. db est PostgreSQL avec pgvector. idp est le fournisseur d’identité de pratique. migrate exécute les migrations, puis s’arrête. api est l’assistant. Les trois derniers utilisent la même image. Les conditions depends_on et les vérifications de santé les placent dans l’ordre :

compose.yaml (parts)
migrate:
profiles: ["app"]
image: doc-assistant:${APP_VERSION:-1.0.0}
command: ["python", "-m", "doc_assistant.migrate"]
depends_on:
db:
condition: service_healthy
api:
profiles: ["app"]
image: doc-assistant:${APP_VERSION:-1.0.0}
environment:
SESSION_SECRET: ${SESSION_SECRET:?Run python -m idp init first}
# ... the other settings
ports:
- "127.0.0.1:${API_PORT:-8000}:8000"
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/ready')"]
interval: 5s
start_period: 20s
depends_on:
migrate:
condition: service_completed_successfully
idp:
condition: service_started

Le profil app exclut les trois services de docker compose up -d db, que vous utilisiez pendant le développement. ${SESSION_SECRET:?…} transforme le secret manquant en erreur accompagnée d’un message, comme vous l’avez vu plus haut. La vérification de santé de api appelle /ready, pas /health. Ainsi, « en santé » signifie « prêt à servir ».

Un flux de gauche à droite. La commande docker compose --profile app up -d --wait démarre db, PostgreSQL avec pgvector, et idp, le fournisseur d'identité de pratique. Quand db est en santé (pg_isready), migrate applique les migrations 001 à 005, puis s'arrête. Quand migrate se termine avec succès et que idp a démarré, api démarre : il charge les modèles et ouvre le pool de connexions à la base de données. Quand api est en santé, ce qui signifie que GET /ready renvoie 200, l'option --wait rend la main : la démo peut servir.
L'ordre de démarrage imposé par Compose : la base de données, puis les migrations, puis l'API. --wait rend la main seulement quand /ready dit oui.
Description textuelle du diagramme

La commande démarre d’abord la base de données et le fournisseur de pratique. Les migrations s’exécutent seulement quand la base de données est en santé, c’est-à-dire quand pg_isready réussit. L’API démarre seulement quand les migrations se terminent avec le code de sortie 0 et que le fournisseur a démarré. L’API charge le modèle de plongement (embedding) et ouvre son pool de connexions (pool) à la base de données. Sa vérification de santé appelle /ready toutes les 5 secondes. Avec --wait, la commande rend la main seulement quand cette vérification réussit. Un script exécuté ensuite peut donc compter sur la pile de services.

Sans --wait, docker compose up -d rend la main dès que les conteneurs existent, avant le chargement des modèles. Un test de fumée exécuté juste après peut échouer sans véritable raison. Avec --wait, il échoue seulement si la pile de services n’est jamais prête.

python -m idp init crée la clé de signature du fournisseur de pratique dans .idp/. Il écrit aussi deux nouveaux secrets dans .env : OIDC_CLIENT_SECRET et SESSION_SECRET. Compose lit .env et donne à chaque conteneur seulement les valeurs nommées dans son environment. L’image n’en contient aucune. Sam le vérifie directement dans l’image, sans démarrer la pile de services :

Terminal
docker run --rm --entrypoint sh doc-assistant:1.0.0 -c 'whoami; ls -a /app'
app
.
..
data
doc_assistant
evaluation
idp
migrations
recordings
requirements-run.txt
requirements.txt
scripts
traces

L’utilisateur est app, et /app ne contient ni .env ni .idp, car .dockerignore les a exclus de la construction. Le fournisseur de pratique reçoit son dossier de clés par un montage en lecture seule. La clé reste donc aussi hors de l’image.

Trois groupes et les flèches entre eux. Ce qui entre dans les conteneurs au démarrage : l'image doc-assistant:1.0.0 avec le code, les deux modèles et l'ensemble de données, sans .env ni .idp; .env avec POSTGRES_PASSWORD, SESSION_SECRET et OIDC_CLIENT_SECRET; .idp/ avec la clé de signature du fournisseur. Le réseau Compose sur votre ordinateur : api, db et idp. L'image va vers api et idp. .env va vers db et api comme environnement. .idp/ va vers idp comme montage en lecture seule. Qui peut se connecter : le navigateur de cet ordinateur accède à api sur 127.0.0.1:8000; un autre ordinateur du réseau a une ligne pointillée vers api qui se termine par une croix, signe de refus, car les ports écoutent seulement sur 127.0.0.1.
Où se trouvent les secrets et qui peut se connecter : l'image ne contient aucun secret. .env et .idp/ entrent au démarrage, et seul cet ordinateur peut accéder aux ports.
Description textuelle du diagramme

L’image contient le code, les deux modèles et l’ensemble de données. Elle ne contient ni .env ni .idp/. Sur votre ordinateur, .env contient les trois secrets. Compose les transmet comme variables d’environnement à l’API et à la base de données lors de leur démarrage. Le dossier .idp/ contient la clé de signature du fournisseur. Il est monté en lecture seule dans le conteneur du fournisseur. Le navigateur de votre ordinateur accède à l’API à l’adresse 127.0.0.1:8000. Un autre ordinateur du même réseau ne peut pas se connecter, car chaque port écoute seulement sur 127.0.0.1. L’équipe du cours n’a pas testé cela depuis un deuxième ordinateur. Ce comportement découle de la façon dont Docker publie un port, comme dans le cours sur Docker.

La clé d’un modèle en service, LLM_API_KEY, suivrait le même chemin : dans .env, puis dans l’environnement de l’API. La classe de paramètres l’exclut de tous les journaux et de toutes les erreurs (repr=False).

L’API écrit une ligne JSON par requête. Voici quatre lignes du test de fumée exécuté par Sam :

{"request_id": "fe1d2399e78449ce", "method": "GET", "path": "/v1/tenants/larkfield/documents", "status": 401, "ms": 0.8, "tenant": null, "user": null}
{"request_id": "2cf6f95f2e004f76", "method": "GET", "path": "/v1/tenants/larkfield/documents", "status": 200, "ms": 73.7, "tenant": "larkfield", "user": "usr-sam"}
{"request_id": "0b296ceba2b04e6b", "method": "POST", "path": "/v1/tenants/larkfield/answers", "status": 200, "ms": 76.5, "tenant": "larkfield", "user": "usr-sam"}
{"request_id": "78cfd1d6542341c5", "method": "GET", "path": "/v1/tenants/bramble/documents", "status": 404, "ms": 0.9, "tenant": null, "user": null}

Chaque ligne contient l’identifiant de requête, la méthode, le chemin, le statut, la durée en millisecondes, la boutique et l’utilisateur. Elle ne contient jamais la question, la réponse ni un jeton. Les questions peuvent contenir le nom ou la commande d’un client. Les journaux sont lus par plus de personnes que le personnel de la boutique. Un test, test_the_request_log_has_ids_but_no_content, envoie la question « A secret question? » (une question secrète?). Il échoue si le mot « secret » ou un jeton porteur se retrouve dans le journal.

Chaque corps d’erreur contient le même request_id. Quand Grace envoie une capture d’écran d’une erreur, Sam cherche donc cet identifiant dans les journaux. La ligne indique la requête, sa boutique, son utilisateur et sa durée. La question elle-même reste dans la base de données, protégée par les règles d’accès de la boutique, pas dans le journal.

Pendant l’exécution de la démo, Sam a mesuré la mémoire de chaque conteneur avec docker stats --no-stream :

La mémoire de chaque conteneur après le chargement des données et l'exécution du test de fumée. L'API contient le modèle de plongement et torch, et utilise la plus grande part de la mémoire.
Description textuelle du graphique

Un graphique à colonnes avec trois colonnes. Le conteneur api utilise 858 Mio, le conteneur idp 42 Mio et le conteneur db 36 Mio. La colonne api est environ vingt fois plus haute que chacune des autres.

L’API est la partie lourde, car elle garde torch et le modèle de plongement en mémoire. Dans les modes de reclassement, l’encodeur croisé en ajoute encore. Toute la démo nécessite environ 1 Go. Un ordinateur de 8 Go peut donc l’exécuter avec un navigateur et un appel vidéo. Un forfait infonuagique nécessite au moins 2 Gio pour l’API, la valeur indiquée dans docs/deployment.md.

Exercice guidé : démarrer la démo et exécuter le test de fumée

Section intitulée « Exercice guidé : démarrer la démo et exécuter le test de fumée »
  1. Dans ~/projects/doc-assistant-ci, avec l’environnement virtuel actif, arrêtez la base de données de la dernière leçon. Toute la pile de services repartira ainsi à neuf : docker compose down.

  2. Vérifiez les paramètres. docker compose --profile app config -q n’affiche rien quand tous les secrets requis sont définis. Si la commande affiche required variable … is missing a value (une variable requise n’a pas de valeur), exécutez python -m idp init.

  3. Démarrez toute la démo et attendez qu’elle soit prête :

    Fenêtre de terminal
    APP_VERSION=1.0.0 docker compose --profile app up -d --wait

    Les dernières lignes indiquent que db et api sont Healthy (en santé). Si l’image n’existe pas encore, ajoutez --build.

  4. Consultez l’état des services : docker compose --profile app ps. Vous voyez :

    SERVICE STATUS PORTS
    api Up 5 seconds (healthy) 127.0.0.1:8000->8000/tcp
    db Up 8 seconds (healthy) 127.0.0.1:5432->5432/tcp
    idp Up 8 seconds 127.0.0.1:8400->8400/tcp

    migrate n’est pas dans la liste : il s’est exécuté, s’est terminé avec le code 0, puis s’est arrêté. Les ports commencent par 127.0.0.1.

  5. Chargez l’ensemble de données dans un conteneur ponctuel de la même image :

    Fenêtre de terminal
    docker compose --profile app run --rm api python -m scripts.load_pack

    La fin de la sortie :

    Indexed 31 documents in 8.5 s (failed 0).
    bramble: 15 documents, 60 passages, 0 failed
    larkfield: 36 documents, 185 passages, 0 failed

    « 31 documents » n’est pas une erreur. Le fil d’exécution de l’API en cours a indexé les 20 autres en même temps. Les deux dernières lignes comptent tous les documents de chaque boutique : 51 au total et 0 échec.

  6. Posez les deux questions de santé :

    Fenêtre de terminal
    curl http://127.0.0.1:8000/health
    curl http://127.0.0.1:8000/ready
    {"status":"ok","version":"1.0.0"}
    {"status":"ready","version":"1.0.0","answer_provider":"recorded","retrieval_mode":"hybrid","auth_mode":"oidc"}

    Sur Windows, utilisez curl.exe au lieu de curl.

  7. Exécutez le test de fumée avec un jeton de pratique pour Sam :

    Fenêtre de terminal
    SMOKE_TOKEN=$(python -m idp token usr-sam) python scripts/smoke.py http://127.0.0.1:8000
    PASS health (version 1.0.0)
    PASS ready: database and migrations (recorded)
    PASS the page is served
    PASS no sign-in -> 401
    PASS documents are indexed (36 indexed)
    PASS a question gets a cited answer (recorded: We refund the extra charge within 3 business days after confirming the double ch)
    PASS another shop -> 404
    7 of 7 checks passed.
  8. Ouvrez http://127.0.0.1:8000, choisissez Sign in (se connecter), sélectionnez Ines, puis posez la question « How long is a gift card valid? » (combien de temps une carte-cadeau est-elle valide?). Vous obtenez une réponse avec citation tirée des documents de Bramble Books. L’équipe du cours n’a pas effectué cette connexion dans le navigateur; elle a vérifié les mêmes routes avec curl.

  9. Lisez les dernières lignes du journal : docker compose --profile app logs api --tail 5. Trouvez la ligne de votre question : POST, le chemin contenant bramble, le statut 200 et l’utilisateur usr-ines.

Gardez la démo en marche pour la prochaine leçon, ou arrêtez-la avec docker compose --profile app down. Cette commande conserve les données.

Les sept vérifications couvrent le parcours principal depuis l’extérieur : le processus tourne, il est prêt et la page est servie. Une requête sans connexion reçoit 401, et la boutique possède des documents indexés. Une question reçoit une réponse avec citation, et le chemin d’une autre boutique reçoit 404. Le test de fumée utilise seulement la bibliothèque standard. Il fonctionne donc sur un exécuteur CI ou un nouvel ordinateur sans aucune installation. Il ne remplace pas l’évaluation : il pose une question, pas 41.

Changez une condition. Relancez le test de fumée, mais sans SMOKE_TOKEN (sur Windows, exécutez d’abord Remove-Item Env:SMOKE_TOKEN). Faites une prédiction : combien de vérifications s’exécutent, et lesquelles sont omises?

Afficher la réponse
PASS health (version 1.0.0)
PASS ready: database and migrations (recorded)
PASS the page is served
PASS no sign-in -> 401
4 of 4 checks passed.

Quatre vérifications s’exécutent : celles qui ne nécessitent aucune connexion. Les trois vérifications qui nécessitent un membre de Larkfield sont omises : les documents indexés, la réponse avec citation et le 404 pour une autre boutique. Une exécution sans jeton est utile sur un ordinateur sans .idp/, mais elle ne prouve pas le parcours principal. C’est pourquoi le flux de travail CI crée d’abord un jeton.

Erreur courante

En santé pour la plateforme, inutile pour l'utilisateur

Symptôme : pendant l’exécution de Sam, on a arrêté le conteneur de base de données avec docker compose stop db. Le conteneur de l’API a continué de tourner. /health indiquait encore ok (fonctionnel), comme vous l’avez vu au début de cette leçon. Mais /ready donnait :

HTTP/1.1 503 Service Unavailable
...
{"code":"not_ready","message":"the database does not answer","request_id":"1e6a14469ba74296"}

Cause : le processus était actif, mais pas la base de données. /health n’appelle pas la base de données, volontairement. /ready le fait.

Diagnostic : comparez les deux points de terminaison. Un processus actif, mais pas prêt, signifie qu’une dépendance manque. Le message la nomme : la base de données ne répond pas. docker compose --profile app ps montre que db ne tourne pas.

Reprise : redémarrez la base de données : docker compose up -d --wait db. Ensuite, /ready donne :

{"status":"ready","version":"1.0.0","answer_provider":"recorded","retrieval_mode":"hybrid","auth_mode":"oidc"}

L’API s’est reconnectée toute seule, sans redémarrage.

Conséquence pour le travail en IA : certaines équipes dirigent la vérification de vitalité vers /ready. Une panne de base de données pousse alors la plateforme à redémarrer l’API sans arrêt. Chaque redémarrage charge les modèles pendant plusieurs secondes, et un redémarrage ne peut pas réparer une base de données. Gardez la vitalité sur /health et l’état de préparation sur /ready, comme dans le cours sur Docker.

La démo de Sam est privée de quatre façons. Chaque choix est consigné dans docs/deployment.md :

  • Les ports écoutent sur 127.0.0.1. Seul cet ordinateur peut ouvrir la démo. Pour la montrer, partagez votre écran ou enregistrez une vidéo.
  • Le fournisseur d’identité d’exercice ne demande aucun mot de passe. Quiconque peut y accéder peut se connecter comme Grace. Ne le publiez jamais.
  • SESSION_COOKIE_SECURE=false permet au témoin (cookie) de fonctionner en http sur votre propre ordinateur. Ailleurs, utilisez https et gardez la valeur true.
  • Des documents synthétiques seulement. La démo montre les commerces fictifs du cours. Ne chargez jamais les documents d’une vraie entreprise dans une démo visible par d’autres, même « juste pour la réunion ». Une citation montre le passage à quiconque le demande.

Omar demande : « Est-ce qu’on peut la mettre en ligne pour le client? » Sam répond : la démo privée sur son écran constitue la mise en production de ce cours. Une démo publique exige un vrai fournisseur d’identité, https, une base de données gérée et un budget. Il faut aussi quelqu’un pour la supprimer ensuite.

Facultatif : le nuage (étapes écrites, non exécutées)

Section intitulée « Facultatif : le nuage (étapes écrites, non exécutées) »

Si vous avez un compte Azure et voulez une adresse publique, docs/deployment.md donne les étapes pour Azure Container Apps. L’équipe du cours les a rédigées à partir des étapes exécutées dans Registre et déploiement et Vérifier et supprimer. Elle ne les a pas exécutées pour ce projet et n’a créé aucune ressource infonuagique. En bref :

  1. Un serveur flexible PostgreSQL qui autorise l’extension vector, accessible seulement depuis l’application.
  2. L’image dans un registre, référencée par son empreinte, comme dans le cours CI/CD, tests et mises en production sûres.
  3. Une application conteneurisée : 1 vCPU et 2 Gio, au moins 1 réplique (un démarrage à froid chargerait les modèles), vérification de vivacité sur /health, vérification de l’état prêt sur /ready.
  4. Les secrets stockés comme secrets de la plateforme, et non comme paramètres en clair.
  5. Un vrai fournisseur d’identité à la place de celui d’exercice, et SESSION_COOKIE_SECURE=true.
  6. Le même test de fumée à l’adresse de l’application. Supprimez ensuite le groupe de ressources le jour même.

Les prix changent. Consultez donc les pages de tarifs actuels avant de commencer. Le cours Conception de systèmes d’IA et maîtrise des coûts estimait une conception semblable à environ 50 $ US par mois, dans Modèle de coûts. Une démo d’une journée coûte quelques dollars, si vous la supprimez. La prochaine leçon montre comment la supprimer.

  1. Ajoutez les services à votre compose.yaml : les migrations dans un service distinct, l’API avec une vérification de santé sur son point de terminaison d’état prêt, et tous les ports sur 127.0.0.1.
  2. Donnez à votre API les deux points de terminaison : /health sans dépendances, et /ready qui vérifie la base de données, les migrations et toute autre dépendance indispensable à son fonctionnement.
  3. Faites en sorte que chaque secret obligatoire manquant provoque une erreur avec un message (${NAME:?message}). Vérifiez que votre image ne contient aucun secret.
  4. Écrivez votre test de fumée : le parcours principal de votre produit en dix vérifications au plus, avec la bibliothèque standard seulement, et un code de sortie de 0 ou 1.
  5. Démarrez la démo à partir d’une copie propre, chargez vos données et exécutez le test de fumée. Enregistrez la sortie.
  6. Rédigez votre docs/deployment.md : les étapes, ce qui est privé et pourquoi, et ce que vous n’avez pas fait.

Preuves à conserver : la sortie de up --wait, de ps, des deux points de terminaison de santé et du test de fumée depuis une copie propre; deux lignes de journal avec des identifiants de requête; docs/deployment.md.

Liste de vérification

  • docker compose … config -q échoue avec un message clair quand un secret manque.
  • L’image ne contient ni .env ni clés, et s’exécute sous un utilisateur autre que root.
  • L’API démarre après les migrations, et --wait attend qu’elle soit prête.
  • /health et /ready répondent à des questions différentes, et vous pouvez expliquer la différence.
  • Le test de fumée réussit depuis une copie propre, avec une connexion.
  • Les journaux contiennent des identifiants de requête, mais aucun texte de question, aucune réponse ni aucun jeton.
  • La démo est privée et utilise seulement des documents synthétiques ou autorisés.

Vérifiez votre compréhension

À la boulangerie, la propriétaire s'achète le premier pain avant de tourner l'affiche sur « Ouvert ». À quelle partie de la mise en production de Sam cela correspond-il? Et quelle partie correspond à « attendre que le four soit chaud »?

Afficher la réponse

Le premier pain correspond au test de fumée : une courte vérification du parcours principal depuis l’extérieur, après le démarrage. Il comprend sept vérifications, avec une vraie question et sa citation. Attendre que le four soit chaud correspond à l’état prêt. docker compose … up --wait se termine seulement quand la vérification de santé de l’API sur /ready réussit. Cela signifie que la base de données répond et que toutes les migrations sont en place.

Vérifiez votre compréhension

Prédisez : la base de données s'arrête pendant que la démo fonctionne. Que renvoient /health et /ready? Que devrait faire une plateforme avec le conteneur de l'API, et pourquoi?

Afficher la réponse

/health renvoie 200 avec "status":"ok" (« état : correct »), car le processus fonctionne et le point de terminaison n’appelle pas la base de données. /ready renvoie 503 not_ready (non prêt) avec « la base de données ne répond pas ». La plateforme ne devrait envoyer aucun utilisateur vers l’API tant qu’elle n’est pas prête, mais elle ne devrait pas la redémarrer. Un redémarrage ne peut pas réparer la base de données, et il recharge les modèles chaque fois. Quand la base de données revient, /ready renvoie 200 sans redémarrage.

Vérifiez votre compréhension

Omar veut charger les vrais contrats fournisseurs de Larkfield pour une démo à un client, « juste cette fois ». Que lui dites-vous, et que montrez-vous à la place?

Afficher la réponse

Non. Une démo montre des passages à quiconque les demande. Sa base de données, ses journaux et ses captures d’écran en conservent des copies. Les vrais contrats exigent l’autorisation du propriétaire, un véritable contrôle d’accès et un plan pour les supprimer. Montrez plutôt l’ensemble synthétique : il présente les mêmes difficultés (deux versions d’une politique, une contradiction, une réponse uniquement dans un tableau, des documents réservés au personnel, une instruction cachée). Si le client a besoin de ses propres documents, c’est un projet pilote avec son autorisation, pas une démo.

Récapitulatif

  • Un secret donne accès. Il provient de .env ou du stockage de secrets de la plateforme au démarrage. Il ne se trouve jamais dans l’image ni dans Git. Compose refuse de démarrer quand un secret obligatoire manque.
  • Compose démarre les services dans l’ordre : la base de données en bon état, les migrations terminées, puis l’API. --wait se termine seulement quand l’API est prête.
  • La vivacité (/health) demande « le processus fonctionne-t-il? ». L’état prêt (/ready) demande « peut-il fonctionner maintenant? ». Quand la base de données est arrêtée, la première répond oui et le second répond non.
  • Un test de fumée vérifie le parcours principal depuis l’extérieur en quelques secondes : 7 sur 7 pour la démo de Sam.
  • Les journaux contiennent un identifiant de requête, le commerce et l’utilisateur, jamais la question, la réponse ni un jeton.
  • La démo est privée : ports sur 127.0.0.1, fournisseur d’exercice, documents synthétiques. Les étapes infonuagiques sont facultatives et écrites, mais non exécutées.

Ensuite, vous ferez échouer une mise en production volontairement et reviendrez à la version précédente. Vous limiterez les dépenses de la démo et supprimerez tout.

Leçon suivante : Reprise et maîtrise des coûts