Limites des services
- Leçon 5
- 55 min
- Module 2 : Concevoir l'architecture de bout en bout
Où nous en sommes
Dans le module 1, nous avons écrit les parcours, les cibles et la demande, chaque nombre avec sa catégorie. Mais il n'y a pas encore de conception, alors aucune question sur le coût ou les défaillances ne concerne une partie précise. Dans cette leçon, nous divisons l'assistant en quelques parties, chacune avec une tâche et un responsable, et nous les dessinons sur une page. Nous commençons par un petit restaurant à l'heure du dîner.
Leçon 5 sur 19 · Conception de systèmes d'IA et maîtrise des coûtsLimites des services
1. Commencer par les besoins
2. Concevoir l'architecture de bout en bout
3. Estimer les ressources et le coût
4. Optimiser avec des compromis mesurés
5. Concevoir pour les défaillances et la croissance
6. Présenter la proposition
Ce que vous saurez faire
Divisez l’assistant documentaire en quelques parties, chacune avec une tâche et un responsable. Dessinez-les sur une page. Chaque question suivante concerne alors une partie précise : combien elle coûte, ce qui peut y échouer et qui la répare.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
- Les cinq parcours et les huit cibles de qualité, dans Utilisateurs et flux de travail et Attributs de qualité.
- Ce que l’assistant fait pour une question : créer un plongement, chercher, reclasser et répondre avec des citations. Voir Ce qu’est la génération augmentée par récupération dans RAG : créer une IA qui utilise vos données.
- Une file d’attente et un processus pour le travail lent, dans Cycle de vie d’une tâche, du cours Mettre à l’échelle les API et les charges de travail d’IA.
Ce qu’il vous faut sur votre ordinateur
- Votre dossier
design-packà la fin du module 1, avec l’environnement virtuel actif.python -m pytest -qaffiche12 passed(12 tests réussis). Si votre dossier ne fonctionne plus, copiez l’instantanéend-of-m01du dossier des laboratoires, comme dans Préparer le dossier de conception. - Le dossier des laboratoires
nextia-learning-labsà côté dedesign-pack. Exécutezgit -C nextia-learning-labs pullune fois pour obtenir les derniers instantanés. - Facultatif : draw.io, comme application de bureau ou à app.diagrams.net dans un navigateur. Aucun compte n’est nécessaire.
Testé avec Python 3.12 sur macOS (Apple silicon). Les commandes Windows (PowerShell) et Linux sont fournies, mais non testées.
Un restaurant à l’heure du dîner
Section intitulée « Un restaurant à l’heure du dîner »Imaginez un petit restaurant à l’heure du dîner. Un serveur prend les commandes en salle et apporte les plats. Le cuisinier prépare les plats. L’après-midi, un aide épluche des pommes de terre et prépare la soupe du lendemain. Le garde-manger contient les aliments, et un fournisseur les livre chaque matin.
Chaque poste a une tâche et une personne responsable. La séparation suit une question simple : qui attend? Un client attend son dîner, alors le cuisinier le prépare maintenant. Personne n’attend la soupe du lendemain, alors l’aide la prépare pendant une heure tranquille.
Imaginez maintenant que le serveur épluche aussi les pommes de terre entre les commandes. Une journée chargée, les clients attendent à la porte pendant qu’il épluche. Rien n’est brisé, et toutes les tâches sont accomplies. Mais la tâche lente bloque le passage à la tâche rapide.
Le problème : une partie qui fait tout
Section intitulée « Le problème : une partie qui fait tout »La première esquisse d’Amira pour l’assistant partagé contient un seul programme. Il répond aux questions. Il reçoit aussi les téléversements. Il lit, découpe, transforme en plongements et résume chaque nouveau document avant de répondre à la requête de téléversement. C’est simple, et cela fonctionne pour un petit fichier.
Puis Mei veut charger toute la collection de Larkfield pour tester l’assistant. L’équipe du cours a mesuré chaque étape d’une ingestion, un appel à la fois. Pour un document Markdown, les médianes sont de 0,11 ms pour l’analyser et le découper. Elles sont de 0,39 s pour créer les plongements des segments et de 1,89 s pour le résumer. Cela donne 2,28 s par document. Pour les 36 documents, traités l’un après l’autre, la requête de téléversement dure 36 × 2,28 = 82 secondes.
Pendant ces 82 secondes, le programme fait 36 appels de plongement et 36 appels de résumé : 72 appels aux modèles. Les agents posent des questions en même temps, avec le même programme et le même fournisseur. Le quota du fournisseur est de 100 requêtes de clavardage par minute, selon les mesures du cours sur la mise à l’échelle. Un téléversement lent concurrence maintenant les agents de Grace pour le quota et pour le programme lui-même.
Et si le téléversement échoue au document 20, qu’est-ce qui est sauvegardé? Personne ne peut le dire, car personne ne l’a décidé. Ce cas est construit : nous n’avons pas exécuté le téléversement de 82 secondes. Mais chaque nombre utilisé est une médiane mesurée.
L’idée : les limites des services
Section intitulée « L’idée : les limites des services »Une limite de service est une ligne autour d’une partie du système. À l’intérieur, cette partie a une responsabilité : une tâche décrite en une phrase, avec une personne responsable. Les autres parties demandent cette tâche de façon claire, sans accéder à son fonctionnement interne.
Trois questions permettent de trouver de bonnes limites, comme au restaurant :
- Une personne attend-elle ce travail? Les réponses sont interactives : une personne attend quelques secondes. L’ingestion se fait en arrière-plan : Ines peut attendre quelques minutes. Les travaux où les personnes attendent différemment appartiennent à des parties différentes.
- Quelles données conserve cette partie? Une partie qui stocke des données (documents, vecteurs, réponses) a des besoins différents d’une partie qui fait seulement des calculs. Il lui faut des sauvegardes, une limite de taille et des règles d’accès.
- Cette partie nous appartient-elle? Le fournisseur de modèles et le service de connexion appartiennent à quelqu’un d’autre. Nous ne pouvons pas les modifier. Nous les dessinons donc comme des parties externes et prévoyons leurs défaillances.
L’image de ces parties est un diagramme de conteneurs. Ici, « conteneur » ne désigne pas un conteneur Docker. Il désigne une partie qui fonctionne seule ou stocke des données seule : une application, une base de données, un stockage de fichiers. Le nom vient du modèle C4, une façon courante de dessiner un logiciel à quatre niveaux de détail. Le niveau des conteneurs est celui qu’un gestionnaire de produit et un développeur peuvent tous deux lire.
Un petit exemple : trier les tâches
Section intitulée « Un petit exemple : trier les tâches »Voici les étapes des deux principaux parcours, avec leurs durées médianes mesurées. Triez-les avec la première question : qui attend?
| Étape | Parcours | Qui attend? | Durée médiane |
|---|---|---|---|
| Créer le plongement de la question | J1, J2 : une question | l’agent ou le client | 0,34 s |
| Chercher et reclasser | J1, J2 | l’agent ou le client | 0,32 s |
| Rédiger la réponse (chat-small) | J1, J2 | l’agent ou le client | 1,52 s |
| Analyser et découper un document | J3 : un téléversement | personne : Ines vérifie plus tard | 0,11 ms |
| Créer les plongements des segments (un appel par document) | J3 | personne | 0,39 s |
| Résumer le document | J3 | personne | 1,89 s |
Les deux groupes prennent environ le même temps : 2,18 s pour une réponse et 2,28 s pour un document. La séparation ne dépend donc pas de la vitesse. Elle dépend de qui attend et de la façon dont le travail arrive. Les questions arrivent toute la journée, une à la fois, et chaque personne attend. Les documents arrivent par lots, et personne ne reste devant l’écran.
Description textuelle du graphique
Cinq colonnes, en secondes. Les étapes de réponse, où une personne attend : plongement de la question 0,34, recherche et reclassement 0,32, rédaction de la réponse 1,52. Les étapes d’ingestion, où personne n’attend : plongements des segments 0,39, résumé 1,89. L’analyse et le découpage (0,11 ms) sont trop courts pour être dessinés. Les appels aux modèles sont les colonnes hautes dans les deux groupes. La durée du modèle de reclassement vient du cours sur le RAG, sur un portable. Les autres durées correspondent à des appels au fournisseur de modèles.
La réponse va donc dans une partie, l’API de l’assistant, et l’ingestion dans une autre, le Processus d’ingestion. L’API sauvegarde un téléversement et une tâche, puis répond immédiatement. Le processus prend la tâche quand il le peut, comme dans la file d’attente du cours sur la mise à l’échelle. Maintenant, téléverser 36 documents ne coûte à Ines qu’une courte requête. Les 72 appels aux modèles passent dans une partie qui peut ralentir quand le quota est occupé.
Les parties de Larkfield
Section intitulée « Les parties de Larkfield »Kwame applique les trois questions à l’ensemble de l’assistant, avec Amira et Mei. Le plan du cours nomme cinq types de tâches : l’API interactive, l’ingestion en arrière-plan, la récupération, l’accès aux modèles et le stockage. Ils deviennent huit parties, car l’outil des utilisateurs et les services externes comptent aussi.
Description textuelle du diagramme
L’outil de soutien connecte la personne auprès du fournisseur d’identité et envoie la question avec le jeton à l’API de l’assistant. L’API utilise trois parties dans la colonne du milieu : le fournisseur de modèles, PostgreSQL et le stockage de fichiers. Ses flèches sont bleues et pleines, car une personne attend ces opérations. Le Processus d’ingestion, à droite, utilise les trois mêmes parties, avec des flèches grises en pointillés, car personne n’attend. Aucune flèche ne relie l’API et le processus. L’API écrit une ligne de tâche dans PostgreSQL, et le processus la lit. Journaux et alertes reçoit les journaux de chaque partie. Sur un téléphone, le diagramme montre les mêmes parties empilées, sans les étiquettes des flèches.
Chaque partie a une phrase, un responsable et une liste de ce qu’elle stocke :
| Partie | Type | Responsable | Sa seule tâche |
|---|---|---|---|
| Outil de soutien | client | Amira | présente l’assistant aux agents et aux clients sur le site Web de la boutique |
| Fournisseur d’identité | externe | Kwame | connecte les personnes; donne à chaque requête un jeton avec son locataire et son rôle |
| API de l’assistant | interne | Amira | répond à la question d’un locataire : vérifie le jeton, cherche, appelle le modèle, sauvegarde la réponse |
| Processus d’ingestion | interne | Mei | transforme une version de document téléversée en segments, vecteurs et résumé, en arrière-plan |
| PostgreSQL | stockage | Mei | conserve tous les enregistrements, avec une sécurité au niveau des lignes par locataire |
| Stockage de fichiers | stockage | Mei | conserve le fichier original de chaque version de document |
| Fournisseur de modèles | externe | Kwame | exécute les modèles de clavardage et de plongement |
| Journaux et alertes | stockage | Amira | recueille les journaux et les traces, et alerte une personne quand un signal dépasse sa limite |
Où sont passés la récupération et l’accès aux modèles? Ce ne sont pas des boîtes séparées. La récupération est du code que l’API et le processus utilisent, et ses données résident dans PostgreSQL. L’accès aux modèles est un module par lequel passe chaque appel à un modèle. Kwame peut ainsi changer un modèle à un seul endroit. Ces parties ont des limites, mais à l’intérieur de l’application, pas entre des machines. La leçon Simplicité et évolution explique pourquoi.
Tomás demande : « Pourquoi un seul PostgreSQL pour les enregistrements, les vecteurs, la file de tâches et le cache de réponses? Ce n’est pas quatre tâches? » (Le cache de réponses conserve les réponses sauvegardées. Une question répétée ne nécessite donc aucun appel au modèle. La prochaine leçon montre ce que sa clé doit contenir.) Mei répond que c’est une seule tâche : conserver les données de chaque locataire de façon sûre. Un seul stockage signifie une sauvegarde, un test de restauration et un endroit pour la règle des locataires. Le cours sur les bases de données a mesuré une recherche vectorielle parmi 10 000 vecteurs à environ 0,22 ms. Notre scénario de base stocke environ 18 Mo au premier mois, selon les calculs du module 3. Un deuxième stockage doublerait le travail sans gain mesuré.
Exercice guidé : lister les parties dans le dossier
Section intitulée « Exercice guidé : lister les parties dans le dossier »Le dossier vérifie l’architecture comme il vérifie les prix : chaque partie doit avoir une responsabilité et un responsable. Elle doit aussi apparaître sur le diagramme. Vous ajoutez la vérification, puis les parties, puis le diagramme.
-
Essayez d’abord la commande. Elle n’existe pas encore dans votre dossier :
Fenêtre de terminal python -m costmodel componentsThis command arrives in Module 2. Download the end-of-module-2 snapshot or keep going. -
Copiez la vérification et ses tests depuis l’instantané
end-of-m02. Vous les lisez; vous ne les écrivez pas.Fenêtre de terminal cp ../nextia-learning-labs/C26/snapshots/end-of-m02/costmodel/components.py costmodel/cp ../nextia-learning-labs/C26/snapshots/end-of-m02/tests/test_components.py tests/Fenêtre de terminal Copy-Item ..\nextia-learning-labs\C26\snapshots\end-of-m02\costmodel\components.py costmodel\Copy-Item ..\nextia-learning-labs\C26\snapshots\end-of-m02\tests\test_components.py tests\ -
Exécutez de nouveau la commande. Elle demande maintenant la liste des parties :
Input problem: components.toml is missing (expected at …/design-pack/architecture/components.toml) -
Créez le dossier
architectureavecmkdir architecture; la commande est la même dans les deux interpréteurs de commandes. Dans ce dossier, créez un fichiercomponents.tomlet écrivez la première partie :# Every part of the design: one responsibility, one owner, what it stores.# kind: client | app | store | external. The check: python -m costmodel components[components.api]name = "Assistant API"kind = "app"responsibility = "Answers one tenant's question: checks the token, searches, calls the model, saves the answer."owner = "Amira"stores = ""stores(éléments stockés) est vide volontairement : l’API ne conserve rien elle-même. Tout ce qu’elle sauvegarde va dans PostgreSQL. -
Ajoutez les sept autres parties du tableau ci-dessus, avec une table
[components.<key>]chacune. Utilisez les clésclient,identity,worker,database,files,modelsetmonitoring. Écrivez ce que chaque partie stocke, par exemple"uploaded files, one folder per tenant"(fichiers téléversés, un dossier par locataire). La commande liste les parties dans l’ordre du fichier. Vos lignes peuvent donc suivre un autre ordre que la sortie ci-dessous. -
Exécutez la commande. Les parties sont complètes, mais le diagramme n’existe pas encore. La dernière ligne indique :
8 components, each with one responsibility and an owner; NOT on the diagram: Help-desk tool, Identity provider, Assistant API, Ingestion worker, PostgreSQL, File storage, Model provider, Logs and alertsLes lignes précédentes forment le tableau des huit parties. La vérification lit le fichier source du diagramme,
architecture/container.drawio, et cherche le nom de chaque partie. -
Dessinez le diagramme dans draw.io, avec une boîte par partie et les flèches du diagramme ci-dessus. Commencez chaque étiquette par le nom de la partie. Enregistrez-le sous
architecture/container.drawio. Puis utilisez File › Export as › SVG (Fichier › Exporter au format › SVG) pour enregistrerarchitecture/container.svgà côté. Si vous n’avez pas draw.io, copiez plutôt les deux fichiers depuis l’instantané :Fenêtre de terminal cp ../nextia-learning-labs/C26/snapshots/end-of-m02/architecture/container.* architecture/Fenêtre de terminal Copy-Item ..\nextia-learning-labs\C26\snapshots\end-of-m02\architecture\container.* architecture\ -
Exécutez de nouveau la commande. La sortie est maintenant :
component kind owner responsibilityHelp-desk tool client Amira Shows the assistant to agents and to customers on the shop's website.Identity provider external Kwame Signs people in and gives each request a token with its tenant and role.Assistant API app Amira Answers one tenant's question: checks the token, searches, calls the model, saves the answer.Ingestion worker app Mei Turns an uploaded document version into chunks, vectors and a summary, in the background.PostgreSQL store Mei Keeps every record of the system, with row-level security per tenant.File storage store Mei Keeps the original file of every document version.Model provider external Kwame Runs the chat and embedding models that the API and the worker call.Logs and alerts store Amira Collects logs and traces, and alerts a person when a signal crosses its line.8 components, each with one responsibility and an owner; all are on the container diagram -
Exécutez les tests :
Fenêtre de terminal python -m pytest -qFAILED tests/test_components.py::test_the_sequences_name_the_parts_of_the_diagramFAILED tests/test_components.py::test_the_tenant_travels_with_every_flow - Fi...2 failed, 14 passed in 0.05sC’est le résultat attendu. Les deux tests qui échouent lisent les fichiers de flux que vous écrirez dans les deux prochaines leçons. Les deux tests de cette leçon réussissent.
Comparez votre components.toml à celui de l’instantané end-of-m02. Vos phrases peuvent différer. Vérifiez que chaque partie a une tâche, qu’aucune tâche n’apparaît dans deux parties et que chaque nom correspond à une boîte.
Quand tracer les limites, et ce qu’elles coûtent
Section intitulée « Quand tracer les limites, et ce qu’elles coûtent »Dessinez les parties avant d’estimer les coûts. Le modèle de coûts du module 3 a une ligne par facteur de coût. Chaque facteur appartient à une partie : le calcul de l’API, le serveur de base de données, les jetons des modèles. Une partie sans ligne dans le modèle de coûts est une partie dont vous avez oublié d’estimer le prix.
Ne dessinez pas une boîte pour chaque fonction. Huit parties tiennent sur une page, et Omar peut les lire. Si votre diagramme nécessite une longue légende, les parties sont trop petites. Les modules de code, comme la recherche, vont dans une boîte, pas dans leurs propres boîtes.
Chaque limite a aussi un coût. Deux processus nécessitent deux façons de démarrer et deux ensembles de journaux. La ligne de tâche entre l’API et le processus est un élément de plus qui peut rester bloqué. Le processus a donc besoin des nouvelles tentatives et des vérifications d’état du cours sur la mise à l’échelle. Pour Larkfield, ce coût est faible et le gain est clair : un téléversement ne bloque jamais une réponse.
Erreurs courantes
Section intitulée « Erreurs courantes »Erreur courante
Une partie absente du diagramme
Symptôme : python -m costmodel components se termine par NOT on the diagram: Monitoring (absent du diagramme : surveillance). Les tests affichent 3 failed, 13 passed (3 échecs, 13 réussites). Le premier échec est test_every_component_has_a_job_an_owner_and_is_on_the_diagram.
Cause : quelqu’un a renommé « Logs and alerts » (journaux et alertes) en « Monitoring » (surveillance) dans components.toml, mais pas sur le diagramme. La liste et l’image décrivent maintenant deux systèmes différents, et le lecteur se fie au mauvais.
Solution : utilisez le même nom aux deux endroits. Changez l’étiquette du diagramme ou rétablissez le nom précédent. Exécutez la commande jusqu’à ce que la dernière ligne indique all are on the container diagram (toutes les parties sont sur le diagramme de conteneurs).
Erreur courante
Une partie sans responsable
Symptôme : la commande s’arrête avec Input problem: component 'worker' has no owner (problème d’entrée : le composant « worker » n’a pas de responsable).
Cause : le champ owner (responsable) du processus est une chaîne vide. Peut-être que personne n’en voulait. Une partie sans responsable est celle que personne ne surveille quand sa file d’attente grossit.
Solution : décidez du responsable avec l’équipe et écrivez son nom. Mei est responsable du processus, car il écrit les données qu’elle sauvegarde. Si deux personnes partagent une partie, nommez celle qui répond à l’alerte.
À vous de jouer : le service de recherche de Tomás
Section intitulée « À vous de jouer : le service de recherche de Tomás »Changez une chose. Tomás ajoute une neuvième partie à la fin de components.toml :
[components.search]name = "Search service"kind = "app"responsibility = "Searches a tenant's chunks."owner = "Amira"stores = ""Prédisez ce que la commande et les tests affichent. Puis exécutez-les. La recherche devrait-elle être une partie distincte? Utilisez les trois questions.
Afficher la réponse
La dernière ligne de la commande est 9 components, each with one responsibility and an owner; NOT on the diagram: Search service (9 composants, chacun avec une responsabilité et un responsable; absent du diagramme : service de recherche). Les tests affichent 3 failed, 13 passed (3 échecs, 13 réussites). Le premier échec montre assert 9 == 8 : le test du dossier attend les huit parties de Kwame.
Passons aux trois questions. Qui attend? La même personne qui attend la réponse : la recherche est une étape de la réponse, soit 0,32 s sur 2,18 s. Quelles données? Aucune donnée propre : les segments et les vecteurs sont dans PostgreSQL. Est-ce à nous? Oui, mais l’API aussi. La recherche n’a donc aucune raison propre de s’exécuter séparément. C’est un module que l’API et le processus appellent tous deux, à l’intérieur de l’application. Un service distinct ajouterait un appel réseau à chaque réponse et un élément de plus à déployer. Supprimez la neuvième table. La leçon Simplicité et évolution présente les indicateurs mesurés qui changeraient cette réponse.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Pourquoi le téléversement d'un document passe-t-il par un processus en arrière-plan, alors qu'une ingestion (2,28 s) dure presque autant qu'une réponse (2,18 s)?
Afficher la réponse
Parce que la séparation dépend de qui attend, et non de la vitesse. Une personne attend chaque réponse. Personne n’attend une ingestion : Ines vérifie plus tard. Les documents arrivent aussi par lots : dans le cas construit, 36 documents représentaient 82 s d’appels aux modèles dans une seule requête. Avec le processus, le téléversement renvoie une réponse immédiatement. Un lot de téléversements ne garde jamais une requête ouverte. Le processus peut ralentir lorsque le quota du modèle est fortement utilisé.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Prédisez : vous remplacez « File storage » (stockage de fichiers) par « Blob storage » (stockage d'objets binaires) dans components.toml seulement. Qu'affiche python -m costmodel components à la dernière ligne, et pourquoi le dossier considère-t-il cela comme un problème?
Afficher la réponse
8 components, each with one responsibility and an owner; NOT on the diagram: Blob storage (8 composants, chacun avec une responsabilité et un responsable; absent du diagramme : stockage d’objets binaires). La liste et le diagramme ne concordent plus. L’un des deux est donc incorrect, et le lecteur ne peut pas savoir lequel. Le dossier vérifie les noms parce qu’Omar et Grace lisent le diagramme. Le modèle de coûts et le tableau des défaillances utilisent la liste.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Vérification pratique : pour trois parties de votre choix, indiquez leur tâche unique, leur responsable, leurs données stockées et leur raison d'être distinctes.
Afficher la réponse
Par exemple :
- Processus d’ingestion (Mei) : transforme une version de document téléversée en segments, en vecteurs et en résumé. Il ne stocke rien lui-même. Il existe parce que personne n’attend l’ingestion et qu’elle ne doit pas bloquer les réponses.
- PostgreSQL (Mei) : conserve chaque enregistrement, avec une sécurité au niveau des lignes pour chaque locataire. Il stocke les locataires, les versions de documents, les segments, les vecteurs, les réponses, la file de tâches et le cache des réponses. Il existe parce que les données ont besoin d’un seul endroit, avec des sauvegardes et une règle commune pour les locataires.
- Fournisseur de modèles (Kwame) : exécute les modèles de conversation et de plongement (embedding). Nous n’y conservons rien. C’est une partie distincte parce qu’elle appartient à quelqu’un d’autre. Nous planifions en fonction de son quota et de ses pannes plutôt que de la modifier.
Une bonne réponse donne une raison tirée des trois questions : qui attend, quelles données sont conservées et si la partie nous appartient.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Une limite de service délimite une partie qui a une responsabilité et un responsable. Trois questions permettent de la trouver : une personne attend-elle, quelles données conserve-t-elle et est-elle à nous?
- Une réponse (2,18 s) et une ingestion (2,28 s) prennent environ le même temps. Elles restent deux parties distinctes, parce qu’une personne attend l’une et que personne n’attend l’autre.
- Le diagramme de conteneurs de Larkfield comporte huit parties : l’outil de soutien, le fournisseur d’identité, l’API de l’assistant, le processus d’ingestion, PostgreSQL, le stockage de fichiers, le fournisseur de modèles, ainsi que les journaux et les alertes.
- La récupération et l’accès aux modèles sont des modules internes de l’application, pas des blocs distincts.
python -m costmodel componentsvérifie que chaque partie a une tâche et un responsable, et figure sur le diagramme. Les tests affichent2 failed, 14 passed(2 échecs, 14 réussites) jusqu’à ce que vous écriviez les fichiers de flux.
Ensuite, vous suivrez le locataire le long de chaque flèche de ce diagramme.
Leçon suivante : Flux de données et d'identité