Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Créez un flux de travail d'IA end-to-end génératif avec Amazon Bedrock Flows
Amazon Bedrock Flows vous permet d'utiliser des modèles de base pris en charge (FMs) pour créer des flux de travail en associant des invites, des modèles de base et d'autres AWS services afin de créer des solutions. end-to-end
Avec les flux, vous pouvez rapidement créer des flux de travail d'IA générative complexes à l'aide d'un générateur visuel, les intégrer facilement aux offres Amazon Bedrock telles que FMs les bases de connaissances et d'autres AWS services, notamment AWS Lambda en transférant des données entre eux, et déployer des flux de travail immuables pour passer des tests à la production en quelques clics.
Pour plus d’informations sur Amazon Bedrock Flows, consultez les ressources suivantes :
+ La tarification d’Amazon Bedrock Flows dépend des ressources que vous utilisez. Par exemple, si vous invoquez un flux avec un nœud d’invite qui utilise un modèle Amazon Titan, l’invocation de ce modèle vous est facturée. Pour plus d’informations, consultez [Tarification d’Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
+ Pour voir les quotas des flux, consultez [Points de terminaison et quotas Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html) dans la Références générales AWS.
Voici des exemples de tâches pour lesquelles vous pouvez créer un flux dans Amazon Bedrock :
+ **Création et envoi d’une invitation par e-mail** : créez un flux connectant un nœud d’invite, un nœud de base de connaissances et un nœud de fonction Lambda. Fournissez l’invite suivante pour générer le corps d’un e-mail : **Send invite to John Smith’s extended team for in-person documentation read for an hour at 2PM EST next Tuesday**. Après avoir traité l’invite, le flux interroge une base de connaissances pour rechercher les adresses e-mail de l’équipe élargie de John Smith, puis envoie l’entrée à une fonction Lambda pour envoyer l’invitation à tous les membres de l’équipe figurant dans la liste.
+ **Résolution des problèmes à l’aide du message d’erreur et de l’identifiant de la ressource à l’origine de l’erreur** : le flux recherche les causes possibles de l’erreur à partir d’une base de connaissances documentaire, extrait les journaux système et d’autres informations pertinentes sur la ressource, puis met à jour les configurations et valeurs défectueuses pour la ressource.
+ **Génération de rapports** : créez un flux pour générer des métriques pour les meilleurs produits. Le flux recherche les métriques de vente dans une base de données, les agrège, génère un rapport récapitulatif des principaux achats de produits et publie le rapport sur le portail spécifié.
+ **Ingestion des données d’un jeu de données spécifié** : fournissez une invite telle que la suivante : **Start ingesting new datasets added after 3/31 and report failures**. Le flux commence à préparer les données pour l’ingestion et continue de rendre compte du statut. Une fois la préparation des données terminée, le flux lance le processus d’ingestion en filtrant les données défaillantes. Une fois l’ingestion de données terminée, le flux résume les défaillances et publie un rapport d’échec.
Flows for Amazon Bedrock vous permet de lier facilement des modèles de base (FMs), des invites et d'autres AWS services pour créer, tester et exécuter rapidement vos flux. Vous pouvez gérer les flux à l'aide du générateur visuel de la console Amazon Bedrock ou via le APIs.
Voici les étapes générales de création, test et déploiement d’un flux :
**Création du flux :**
1. Spécifiez un nom de flux, une description et les autorisations IAM appropriées.
1. Concevez votre flux en choisissant les nœuds que vous souhaitez utiliser.
1. Créez ou définissez toutes les ressources dont vous avez besoin pour chaque nœud. Par exemple, si vous prévoyez d'utiliser une AWS Lambda fonction, définissez les fonctions dont le nœud a besoin pour accomplir sa tâche.
1. Ajoutez des nœuds à votre flux, configurez-les et créez des connexions entre les nœuds en liant la sortie d’un nœud à l’entrée d’un autre dans le flux.
**Test du flux :**
1. Préparez le flux, de sorte que les modifications les plus récentes s’appliquent à sa *version préliminaire*, qui vous permet de le tester et de le mettre à jour de manière itérative.
1. Testez le flux en l’invoquant avec des exemples d’entrées pour voir les sorties qu’il produit.
1. Une fois que la configuration d’un flux vous convient, vous pouvez en créer un instantané en publiant une *version*. Cette version préserve la définition du flux telle qu’elle est au moment de sa création. Les versions sont immuables, car elles constituent un instantané du flux au moment de sa création.
**Déploiement du flux :**
1. Créez un alias qui pointe vers la version de votre flux que vous souhaitez utiliser dans votre application.
1. Configurez votre application afin qu’elle envoie des demandes `InvokeFlow` à l’alias. Si vous devez revenir à une ancienne version ou passer à une version plus récente, vous pouvez modifier la configuration de routage de l’alias.
**Topics**
+ [Fonctionnement d’Amazon Bedrock Flows](flows-how-it-works.md)
+ [Régions et modèles pris en charge pour les flux](flows-supported.md)
+ [Conditions préalables pour Amazon Bedrock Flows](flows-prereq.md)
+ [Création et conception d’un flux dans Amazon Bedrock](flows-create.md)
+ [Affichage d’informations sur les flux dans Amazon Bedrock](flows-view.md)
+ [Modification d’un flux dans Amazon Bedrock](flows-modify.md)
+ [Inclusion de barrières de protection dans votre flux dans Amazon Bedrock](flows-guardrails.md)
+ [Test d’un flux dans Amazon Bedrock](flows-test.md)
+ [Exécution de flux Amazon Bedrock de manière asynchrone avec des exécutions de flux](flows-create-async.md)
+ [Déploiement d’un flux dans votre application à l’aide de versions et d’alias](flows-deploy.md)
+ [Invoquer une AWS Lambda fonction depuis un flux Amazon Bedrock dans un autre compte AWS](flow-cross-account-lambda.md)
+ [Conversation avec un flux Amazon Bedrock](flows-multi-turn-invocation.md)
+ [Exécution d’exemples de code Amazon Bedrock Flows](flows-code-ex.md)
+ [Suppression d’un flux dans Amazon Bedrock](flows-delete.md)
# Fonctionnement d’Amazon Bedrock Flows
Amazon Bedrock Flows vous permet de créer des flux de travail d’IA générative en connectant des nœuds, chacun correspondant à une étape du flux qui invoque une ressource Amazon Bedrock ou associée. Pour définir les entrées et les sorties des nœuds, vous spécifiez la manière dont les entrées sont interprétées à l’aide d’expressions. Pour mieux comprendre ces concepts, consultez les rubriques suivantes :
**Topics**
+ [Définitions clés pour Amazon Bedrock Flows](key-definitions-flow.md)
+ [Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock Flows](flows-expressions.md)
+ [Types de nœuds pour votre flux](flows-nodes.md)
# Définitions clés pour Amazon Bedrock Flows
La liste suivante présente les concepts de base d’Amazon Bedrock Flows.
+ **Flux** : un flux est une construction composée d’un nom, d’une description, d’autorisations, d’un ensemble de nœuds et de connexions entre les nœuds. Lorsqu’un flux est invoqué, l’entrée de l’invocation est envoyée via chaque nœud du flux jusqu’à ce qu’un nœud de sortie soit atteint. La réponse à l’invocation renvoie le résultat final.
+ **Nœud** : un nœud est une étape à l’intérieur d’un flux. Pour chaque nœud, vous configurez son nom, sa description, son entrée, sa sortie et toute autre configuration supplémentaire. La configuration d’un nœud varie en fonction de son type. Pour en savoir plus sur les types de nœuds, consultez [Types de nœuds pour votre flux](flows-nodes.md).
+ **Connexion** : deux types de connexions sont utilisés dans Amazon Bedrock Flows :
+ Une **connexion de données** est établie entre la sortie d’un nœud (le *nœud source*) et l’entrée d’un autre nœud (le *nœud cible*) et elle envoie des données d’un nœud en amont à un nœud en aval. Dans le volet de la console Amazon Bedrock, les connexions de données sont représentées par des lignes grises continues.
+ Une **connexion conditionnelle** est établie entre une condition dans un nœud de condition et un nœud en aval et envoie des données du nœud qui précède le nœud de condition à un nœud en aval si la condition est remplie. Dans la console Amazon Bedrock, les connexions conditionnelles sont représentées par des lignes violettes tiretées.
+ **Expressions** : une expression définit comment extraire une entrée de l’ensemble des entrées entrant dans un nœud. Pour savoir comment écrire des expressions, consultez [Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock FlowsDéfinition d’entrées avec des expressions](flows-expressions.md).
+ **Générateur de flux** : le générateur de flux est un outil de la console Amazon Bedrock permettant de créer et de modifier des flux via une interface visuelle. Vous utilisez l’interface visuelle pour glisser-déposer des nœuds sur l’interface et configurer les entrées et les sorties de ces nœuds afin de définir votre flux.
+ Dans les sections suivantes, nous utiliserons les termes suivants :
+ **Entrée complète** : entrée complète envoyée du nœud précédent au nœud actuel.
+ **En amont** : fait référence aux nœuds qui apparaissent plus tôt dans le flux.
+ **En aval** : fait référence aux nœuds qui apparaissent plus tard dans le flux.
+ **Entrée** : un nœud peut avoir plusieurs entrées. Vous utilisez des expressions pour extraire les parties pertinentes de l’ensemble de l’entrée à utiliser pour chaque entrée individuelle. Dans le créateur de flux de la console Amazon Bedrock, une entrée apparaît sous la forme d’un cercle sur la périphérie gauche d’un nœud. Connectez chaque entrée à la sortie appropriée à partir d’un nœud en amont.
+ **Sortie** : un nœud peut avoir plusieurs sorties. Dans le créateur de flux de la console Amazon Bedrock, une sortie apparaît sous la forme d’un cercle sur la périphérie droite d’un nœud. Connectez chaque sortie à au moins une entrée d’un nœud en aval.
+ **Branche** : si une sortie d’un nœud est envoyée à plusieurs nœuds, ou si un nœud conditionnel est inclus, le chemin d’un flux sera divisé en plusieurs branches. Chaque branche peut potentiellement générer une autre sortie dans la réponse d’invocation du flux.
# Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock Flows
Lorsque vous configurez les entrées d’un nœud, vous devez les définir par rapport à l’intégralité de l’entrée saisie dans le nœud. L’intégralité de l’entrée peut être une chaîne, un nombre, une valeur booléenne, un tableau ou un objet. Pour définir une entrée par rapport à l’intégralité de l’entrée, vous devez utiliser un sous-ensemble d’expressions prises en charge basées sur [JsonPath](https://github.com/json-path/JsonPath). Chaque expression doit commencer par `$.data`, ce qui fait référence à l’intégralité de l’entrée. Notez les points suivants concernant l’utilisation d’expressions :
+ Si l’intégralité de l’entrée est une chaîne, un nombre ou une valeur booléenne, la seule expression vous permettant de définir une entrée individuelle est `$.data`.
+ Si l’intégralité de l’entrée est un tableau ou un objet, vous pouvez définir une entrée individuelle à l’aide de l’extraction d’une partie de celui-ci.
À titre d’exemple, pour comprendre comment utiliser des expressions, supposons que l’intégralité de l’entrée est l’objet JSON suivant :
```
{
"animals": {
"mammals": ["cat", "dog"],
"reptiles": ["snake", "turtle", "iguana"]
},
"organisms": {
"mammals": ["rabbit", "horse", "mouse"],
"flowers": ["lily", "daisy"]
},
"numbers": [1, 2, 3, 5, 8]
}
```
Vous pouvez extraire une partie de l’entrée à l’aide des expressions suivantes (Les exemples font référence à ce qui serait renvoyé par l’objet JSON précédent.) :
****
| Expression | Signification | Exemple | Exemple de résultat |
| --- | --- | --- | --- |
| \$1.data | L’intégralité de l’entrée. | \$1.data | L’intégralité de l’objet. |
| .name | Valeur d’un champ nommé name dans un objet JSON. | \$1.data.numbers | [1, 2, 3, 5, 8] |
| [int] | Membre à l’index spécifié par int dans un tableau. | \$1.data.animals.reptiles[2] | iguane |
| [int1, int2, ...] | Membres aux indices spécifiés par chaque valeur int dans un tableau. | \$1.data.numbers[0, 3] | [1, 5] |
| [int1:int2] | Tableau composé des éléments aux indices compris entre int1 (inclusif) et int2 (exclusif) dans un tableau. L’omission d’int1 ou int2 équivaut à marquer le début ou la fin du tableau. | \$1.data.organisms.mammals[1:] | [« cheval », « souris »] |
| \$1 | Caractère générique utilisable à la place d’une valeur name ou int. S’il existe plusieurs résultats, ils sont renvoyés sous forme de tableau. | \$1.data.\$1.mammals | [[« chat », « chien »], [« lapin », « cheval », « souris »]] |
# Types de nœuds pour votre flux
Amazon Bedrock Flows fournit les types de nœuds suivants pour créer votre flux. Lorsque vous configurez un nœud, vous devez fournir les champs suivants :
+ Nom : saisissez un nom pour le nœud.
+ Type : dans la console, vous devez glisser-déposer le type de nœud à utiliser. Dans l'API, utilisez le `type` champ et [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)le `configuration` champ correspondant.
+ Entrées : renseignez les informations suivantes pour chaque entrée :
+ Nom : nom de l’entrée. Certains nœuds ont des noms ou types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, consultez [Types de nœuds logiques](#flows-nodes-logic-table).
+ Expression : définissez la partie de l’ensemble de l’entrée à utiliser comme entrée individuelle. Pour de plus amples informations, veuillez consulter [Définition d’entrées à l’aide d’expressions en extrayant la partie pertinente de l’intégralité d’une entrée dans Amazon Bedrock FlowsDéfinition d’entrées avec des expressions](flows-expressions.md).
+ Type : type de données de l’entrée. Lorsque ce nœud est atteint lors de l’exécution, Amazon Bedrock applique l’expression à l’ensemble de l’entrée et vérifie que le résultat correspond au type de données.
+ Sorties : renseignez les informations suivantes pour chaque sortie :
+ Nom : nom de la sortie. Certains nœuds ont des noms ou types prédéfinis que vous devez utiliser. Pour savoir lesquels ont des noms prédéfinis, consultez [Types de nœuds logiques](#flows-nodes-logic-table).
+ Type : type de données de la sortie. Lorsque ce nœud est atteint lors de l’exécution, Amazon Bedrock vérifie que la sortie du nœud correspond au type de données.
+ Configuration : dans la console, vous définissez des champs spécifiques au nœud en haut du nœud. Dans l'API, utilisez le code approprié [FlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNodeConfiguration.html)et renseignez ses champs.
Chaque type de nœud est décrit ci-dessous et sa structure dans l’API est fournie. Développez une section pour en savoir plus sur ce type de nœud.
## Nœuds permettant de contrôler la logique de flux
Contrôlez la logique de votre flux à l’aide des types de nœuds suivants.
### Nœud d’entrée de flux
Chaque flux ne contient qu’un seul nœud d’entrée de flux et doit commencer par celui-ci. Le nœud d’entrée de flux prend le `content` de la demande `InvokeFlow`, vérifie le type de données et l’envoie au nœud suivant.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet d'entrée dans l'API :
```
{
"name": "string",
"type": "Input",
"outputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
}
],
"configuration": {
"input": CONTEXT-DEPENDENT
}
}
```
### Nœud de sortie de flux
Un nœud de sortie de flux extrait les données d’entrée du nœud précédent, en fonction de l’expression définie, et les renvoie. Dans la console, la sortie est la réponse renvoyée après un clic sur **Exécuter** dans la fenêtre de test. Dans l’API, la sortie est renvoyée dans le champ `content` de l’`flowOutputEvent` de la réponse `InvokeFlow`. Un flux peut comporter plusieurs nœuds de sortie de flux.
Un flux peut comporter plusieurs nœuds de sortie de flux s’il compte plusieurs branches.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de sortie :
```
{
"name": "string",
"type": "Output",
"inputs": [
{
"name": "document",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"output": CONTEXT-DEPENDENT
}
}
```
### Nœud de condition
Un nœud de condition envoie des données du nœud précédent à différents nœuds, en fonction des conditions définies. Un nœud de condition peut accepter plusieurs entrées.
Pour obtenir un exemple, consultez [Création d’un flux avec un nœud de condition](flows-ex-condition.md).
**Pour définir un nœud de condition**
1. Ajoutez autant d’entrées que nécessaire pour évaluer les conditions que vous prévoyez d’ajouter.
1. Saisissez un nom pour chaque entrée, spécifiez le type attendu et écrivez une expression pour extraire la partie pertinente de l’ensemble de l’entrée.
1. Connectez chaque entrée à la sortie appropriée à partir d’un nœud en amont.
1. Ajoutez autant de conditions que nécessaire.
1. Pour chaque condition :
1. Saisissez un nom pour la condition.
1. Définissez une condition qui compare les entrées à d’autres ou à une constante à l’aide d’opérateurs relationnels et logiques.
**Note**
Les conditions sont évaluées dans l’ordre. Si plusieurs conditions sont remplies, la première prévaut.
1. Connectez chaque condition au nœud en aval auquel vous souhaitez envoyer les données si la condition concernée est remplie.
#### Expressions conditionnelles
Pour définir une condition, vous devez faire référence à une entrée par son nom et la comparer à une valeur à l’aide de l’un des opérateurs relationnels suivants :
****
| Opérateur | Signification | Types de données pris en charge | Exemple d’utilisation | Signification de l’exemple |
| --- | --- | --- | --- | --- |
| == | Égal à (Le type de données doit également être égal.) | Chaîne, Nombre, Booléen | A == B | Si A est égal à B |
| \$1= | Non égal à | Chaîne, Nombre, Booléen | A \$1= B | Si A n’est pas égal à B |
| > | Supérieur à | Number | A > B | Si A est supérieur à B |
| >= | Supérieur ou égal à | Number | A >= B | Si A est supérieur ou égal à B |
| < | Inférieur à | Number | A < B | Si A est inférieur à B |
| <= | Inférieur ou égal à | Number | A <= B | Si A est inférieur ou égal à B |
Vous pouvez comparer les entrées à d’autres ou à une constante dans une expression conditionnelle. Par exemple, si vous avez une entrée numérique nommée `profit` et une autre nommée `expenses`, **profit > expenses** et **profit <= 1000** sont des expressions valides.
Vous pouvez combiner des expressions correspondant à des conditions plus complexes à l’aide des opérateurs logiques suivants. Nous vous recommandons de résoudre les ambiguïtés liées au regroupement d’expressions à l’aide de parenthèses :
****
| Opérateur | Signification | Exemple d’utilisation | Signification de l’exemple |
| --- | --- | --- | --- |
| and | Les deux expressions ont la valeur true | (A < B) and (C == 1) | Si les deux expressions ont la valeur true : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html) |
| or | Au moins une expression a la valeur true | (A \$1= 2) or (B > C) | Si l’une des expressions a la valeur true : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html) |
| not | L’expression n’a pas la valeur true | not (A > B) | Si A n’est pas supérieur à B (équivalent à A <= B) |
Dans l'API, vous définissez les éléments suivants dans le `definition` champ lorsque vous envoyez une [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html)demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html)or :
1. Un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de condition dans le `nodes` tableau. Voici e format général (Notez que les nœuds conditionnels n’ont pas de `outputs`) :
```
{
"name": "string",
"type": "Condition",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"configuration": {
"condition": {
"conditions": [
{
"name": "string",
"expression": "string"
},
...
]
}
}
}
```
1. Pour chaque entrée dans le nœud de condition, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet dans le `connections` tableau. Incluez un [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html)objet dans le `configuration` champ de l'`FlowConnection`objet. Voici le format général de l’objet `FlowConnection` :
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Data",
"configuration": {
"data": {
"sourceOutput": "string",
"expression": "string"
}
}
}
```
1. Pour chaque condition (y compris la condition par défaut) du nœud de condition, un [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet du `connections` tableau. Incluez un [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html)objet dans le `configuration` champ de l'`FlowConnection`objet. Le format général de l'[FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html)objet est le suivant :
```
{
"name": "string",
"source": "string",
"target": "string",
"type": "Conditional",
"configuration": {
"conditional": {
"condition": "string"
}
}
}
```
Définissez la `condition` qui connecte ce nœud `source` conditionnel à un nœud `target` en aval à l’aide d’opérateurs relationnels et logiques. Pour la condition par défaut, spécifiez la condition sous la forme **default**.
### Nœuds itérateurs
Un nœud itérateur prend un tableau et renvoie itérativement ses éléments en sortie au nœud en aval. Les entrées du nœud itérateur sont traitées une par une et non en parallèle les unes avec les autres. Le nœud de sortie de flux renvoie le résultat final pour chaque entrée dans une réponse différente. Vous pouvez également recueillir les réponses itérées à l’aide d’un nœud collecteur en aval du nœud itérateur et les renvoyer sous forme de tableau, en sus de la taille du tableau.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet itérateur :
```
{
"name": "string",
"type": "Iterator",
"inputs": [
{
"name": "array",
"type": "Array",
"expression": "string"
}
],
"outputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
},
{
"name": "arraySize",
"type": "Number"
}
],
"configuration": {
"iterator": CONTEXT-DEPENDENT
}
}
```
### Nœud collecteur
Un nœud collecteur prend une entrée itérée, en sus de la taille du tableau, et les renvoie sous forme de tableau. Vous pouvez recueillir les éléments itérés à l’aide d’un nœud collecteur en aval d’un nœud itérateur après les avoir envoyés au moyen de certains nœuds.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de collection :
```
{
"name": "string",
"type": "Collector",
"inputs": [
{
"name": "arrayItem",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "arraySize",
"type": "Number"
}
],
"outputs": [
{
"name": "collectedArray",
"type": "Array"
},
],
"configuration": {
"collector": CONTEXT-DEPENDENT
}
}
```
### DoWhile nœud en boucle
Un nœud DoWhile en boucle exécute une séquence de nœuds à plusieurs reprises tant qu'une condition spécifiée reste vraie. La boucle s’exécute au moins une fois avant d’évaluer la condition, ce qui la rend idéale pour les scénarios dans lesquels vous devez effectuer une action, puis vérifier si elle doit être répétée en fonction du résultat.
Le nœud de DoWhile boucle prend les données d'entrée et les fait passer par le corps de la boucle. Après chaque itération, la condition est évaluée pour déterminer s’il convient de poursuivre la boucle ou d’y mettre fin. La boucle continue tant que la condition est remplie ou que le `maxIterations` n’est pas dépassé.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet DoWhile en boucle :
```
{
"name": "string",
"type": "DoWhile",
"inputs": [
{
"name": "loopInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
}
],
"outputs": [
{
"name": "loopOutput",
"type": "String | Number | Boolean | Object | Array"
},
{
"name": "iterationCount",
"type": "Number"
}
],
"configuration": {
"doWhile": {
"condition": "string",
"maxIterations": "number"
}
}
}
```
Dans la configuration :
+ `condition` : expression booléenne qui détermine s’il convient de poursuivre la boucle. Utilisez les mêmes opérateurs relationnels et logiques que ceux des nœuds conditionnels. La condition est évaluée après chaque itération.
+ `maxIterations` : nombre maximal d’itérations. La valeur par défaut est 10. Vous devez spécifier un nombre positif. Ce paramètre vous permet d’éviter les boucles infinies.
**Note**
Le paramètre `maxIterations` a une valeur par défaut de 10 et n’accepte que des nombres positifs. La boucle se termine lorsque la condition n’est plus remplie ou lorsque le nombre maximal d’itérations est atteint.
## Nœuds dédiés à la gestion des données dans le flux
Gérez les données de votre flux à l’aide des types de nœuds suivants :
### Nœud d’invite
Un nœud d’invite définit une invite à utiliser dans le flux. Vous pouvez utiliser une invite de Prompt Management ou en définir une en ligne dans le nœud. Pour de plus amples informations, veuillez consulter [Création et stockage d’invites réutilisables avec la gestion des invites dans Amazon Bedrock](prompt-management.md).
Pour obtenir un exemple, consultez [Test d’exemples de flux](flows-ex.md).
Les entrées du nœud d’invite sont des valeurs permettant de renseigner les variables. La sortie est la réponse générée par le modèle.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet d'invite :
```
{
"name": "string",
"type": "prompt",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
],
"configuration": {
"prompt": {
"sourceConfiguration": [PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html) object (see below),
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
L'[PromptFlowNodeSourceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeSourceConfiguration.html)objet varie selon que vous utilisez une invite de la gestion des invites ou que vous la définissez en ligne :
+ Si vous utilisez une invite de Prompt Management, l’objet doit présenter la structure générale suivante :
```
{
"resource": {
"promptArn": "string"
}
}
```
+ Si vous définissez une invite inline, suivez les instructions pour définir une variante dans l’onglet API de [Création d’une invite à l’aide de la gestion des invites](prompt-management-create.md). (Notez toutefois que cet objet ne comporte aucun champ `name`.) L’objet que vous utilisez doit présenter la structure générale suivante :
```
{
"inline": {
"modelId": "string",
"templateType": "TEXT",
"templateConfiguration": {
"text": {
"text": "string",
"inputVariables": [
{
"name": "string"
},
...
]
}
},
"inferenceConfiguration": {
"text": {
"maxTokens": int,
"stopSequences": ["string", ...],
"temperature": float,
"topP": float
}
},
"additionalModelRequestFields": {
"key": "value",
...
}
}
}
```
Pour appliquer une barrière de protection Amazon Bedrock à votre invite ou à la réponse générée depuis celui-ci, incluez le champ `guardrailConfiguration` et spécifiez l’identifiant ou l’ARN de la barrière de protection dans le champ `guardrailIdentifier` et la version de la barrière de protection dans le champ `guardrailVersion`.
### Nœud d’agent
Un nœud d'agent vous permet d'envoyer une invite à un agent, qui orchestre les ressources associées entre FMs elles afin d'identifier et d'exécuter des actions pour un utilisateur final. Pour de plus amples informations, veuillez consulter [Automatisation des tâches de votre application à l’aide d’agents d’IA](agents.md).
Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de l’alias de l’agent à utiliser. Les entrées dans le nœud sont l’invite pour l’agent et tout [attribut d’invite ou de session](agents-session-state.md) associé. Le nœud renvoie la réponse de l’agent sous forme de sortie.
Un nœud d’agent peut prendre en charge les invocations à plusieurs tours, permettant ainsi des conversations interactives entre les utilisateurs et l’agent pendant l’exécution du flux. Lorsqu’un nœud d’agent a besoin d’informations ou de précisions supplémentaires, il peut suspendre l’exécution du flux et demander des entrées spécifiques à l’utilisateur. Une fois que l’utilisateur a fourni les informations demandées, le nœud d’agent poursuit son traitement avec la nouvelle entrée. Cela continue jusqu’à ce que le nœud d’agent dispose de toutes les informations requises pour terminer son exécution.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet agent :
```
{
"name": "string",
"type": "Agent",
"inputs": [
{
"name": "agentInputText"
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "promptAttributes"
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes"
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "agentResponse",
"type": "String"
}
],
"configuration": {
"agent": {
"agentAliasArn": "string"
}
}
}
```
### Nœud de base de connaissances
Un nœud de base de connaissances vous permet d’envoyer une requête à une base de connaissances à partir d’Amazon Bedrock Knowledge Bases. Pour de plus amples informations, veuillez consulter [Récupération de données et génération de réponses basées sur l’IA avec Amazon Bedrock Knowledge Bases](knowledge-base.md).
Dans la configuration, indiquez au minimum l’`knowledgeBaseId`. Vous pouvez éventuellement inclure les champs suivants en fonction de votre cas d’utilisation :
+ `modelId` : incluez un [ID de modèle](models-supported.md) à utiliser si vous souhaitez générer une réponse basée sur les résultats récupérés. Pour renvoyer les résultats récupérés sous forme de tableau, omettez l’ID du modèle.
+ `guardrailConfiguration` : incluez l’identifiant ou l’ARN de la barrière de protection, défini dans les barrières de protection Amazon Bedrock, dans le champ `guardrailIdentifier` et la version de la barrière de protection dans le champ `guardrailVersion`.
**Note**
Les barrières de protection peuvent être appliquées uniquement en cas d’utilisation de `RetrieveAndGenerate` dans un nœud de base de connaissances.
L’entrée dans le nœud est la requête envoyée à la base de connaissances. La sortie est soit la réponse du modèle, sous forme de chaîne, soit un tableau des résultats récupérés.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de base de connaissances :
```
{
"name": "string",
"type": "KnowledgeBase",
"inputs": [
{
"name": "retrievalQuery",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "retrievalResults" | "outputText",
"type": "Array | String"
}
],
"configuration": {
"knowledgeBase": {
"knowledgeBaseId": "string",
"modelId": "string",
"guardrailConfiguration": {
"guardrailIdentifier": "string",
"guardrailVersion": "string"
}
}
}
}
```
### Nœud de stockage S3
Un nœud de stockage S3 vous permet de stocker des données dans le flux vers un compartiment Amazon S3. Dans la configuration, vous spécifiez le compartiment S3 à utiliser pour le stockage de données. Les entrées dans le nœud sont le contenu à stocker et la [clé de l’objet](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Le nœud renvoie l’URI de l’emplacement S3 en sortie.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de stockage S3 :
```
{
"name": "string",
"type": "Storage",
"inputs": [
{
"name": "content",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Uri",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### Nœud de récupération S3
Un nœud de récupération S3 vous permet de récupérer des données depuis un emplacement Amazon S3 pour les introduire dans le flux. Dans la configuration, vous spécifiez le compartiment S3 à partir duquel vous souhaitez récupérer les données. L’entrée dans le nœud est la [clé de l’objet](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html). Le nœud renvoie le contenu de l’emplacement S3 en sortie.
**Note**
À l’heure actuelle, les données de l’emplacement S3 doivent être une chaîne codée en UTF-8.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de récupération S3 :
```
{
"name": "string",
"type": "Retrieval",
"inputs": [
{
"name": "objectKey",
"type": "String",
"expression": "string"
}
],
"outputs": [
{
"name": "s3Content",
"type": "String"
}
],
"configuration": {
"retrieval": {
"serviceConfiguration": {
"s3": {
"bucketName": "string"
}
}
}
}
}
```
### Nœud de fonction Lambda
Un nœud de fonction Lambda vous permet d’appeler une fonction Lambda dans laquelle vous pouvez définir du code pour exécuter une logique métier. Lorsque vous incluez un nœud Lambda dans un flux, Amazon Bedrock envoie un événement d’entrée à la fonction Lambda que vous spécifiez.
Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de la fonction Lambda. Définissez les entrées à envoyer dans l’événement d’entrée Lambda. Vous pouvez écrire du code en fonction de ces entrées et définir ce que la fonction renvoie. La réponse de la fonction est renvoyée dans la sortie.
Voici la structure générale d'un objet de fonction [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)Lambda :
```
{
"name": "string",
"type": "LambdaFunction",
"inputs": [
{
"name": "codeHookInput",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [
{
"name": "functionResponse",
"type": "String | Number | Boolean | Object | Array"
}
],
"configuration": {
"lambdaFunction": {
"lambdaArn": "string"
}
}
}
```
#### Événement d’entrée Lambda pour un flux
L’événement d’entrée envoyé à une fonction Lambda dans un nœud Lambda est au format suivant :
```
{
"messageVersion": "1.0",
"flow": {
"flowArn": "string",
"flowAliasArn": "string"
},
"node": {
"name": "string",
"inputs": [
{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string",
"value": ...
},
...
]
}
}
```
Les champs de chaque entrée correspondent aux champs que vous spécifiez lors de la définition du nœud Lambda, tandis que la valeur du champ `value` est renseignée avec l’intégralité de l’entrée dans le nœud après avoir été résolue par l’expression. Par exemple, si la totalité de l’entrée du nœud est `[1, 2, 3]` et que l’expression est `$.data[1]`, la valeur envoyée dans l’événement d’entrée à la fonction Lambda est `2`.
Pour plus d’informations sur les événements dans Lambda, consultez [Concepts Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-event) dans le [Guide du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
#### Réponse Lambda pour un flux
Lorsque vous écrivez une fonction Lambda, vous définissez la réponse renvoyée par celle-ci. Cette réponse est renvoyée à votre flux en tant que sortie du nœud Lambda.
### Nœud de code inline
Un nœud de code inline vous permet d’écrire et d’exécuter du code directement dans votre flux, ce qui permet des transformations de données, une logique personnalisée et des intégrations sans utiliser de fonction Lambda externe. Lorsque vous incluez un nœud de code intégré dans votre flux, Amazon Bedrock exécute votre code dans un environnement AWS géré isolé qui n'est partagé avec personne et qui n'a pas accès à Internet.
**Note**
La fonctionnalité de nœud de code inline est actuellement disponible en version préliminaire pour Amazon Bedrock et susceptible d’être modifiée.
Dans la configuration du nœud, spécifiez le code à exécuter et le langage de programmation. (`Python_3` est actuellement la seule option.) Définissez les entrées auxquelles votre code peut accéder en tant que variables. Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que sortie du nœud.
L'exemple suivant montre la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet de code en ligne :
```
{
"name": "string",
"type": "InlineCode",
"inputs": [{
"name": "string",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
...
],
"outputs": [{
"name": "response",
"type": "String | Number | Boolean | Object | Array"
}],
"configuration": {
"inlineCode": {
"code": "string",
"language": "Python_3"
}
}
}
```
#### Éléments à prendre en compte en cas d’utilisation de nœuds de code inline
Lorsque vous utilisez des nœuds de code inline dans votre flux, tenez compte des éléments suivants :
**Important**
Nous vous recommandons de tester votre code avant de l’ajouter à un nœud de code inline.
+ Les nœuds de code inline ne sont pas pris en charge dans l’[exécution de flux asynchrones](flows-create-async.md).
+ À l’heure actuelle, le seul langage de programmation pris en charge par les nœuds de code inline est Python 3.12 (`Python_3)`.
+ Le code inline fait office de session Python interactive. Seul le résultat de la dernière ligne exécutée est capturé et renvoyé en tant que sortie du nœud.
+ La sortie de la console Python (comme celle de la fonction `print`) n’est pas capturée.
+ Les entrées pour votre nœud de code inline sont disponibles sous forme de variables Python dans votre code. Utilisez le nom exact de l’entrée du nœud pour les référencer.
+ Configurez correctement les types d’entrées et de sorties pour éviter les erreurs d’exécution. Vous pouvez configurer jusqu’à cinq entrées de nœud.
+ Vous pouvez avoir jusqu’à cinq nœuds de code inline par flux.
+ Vous pouvez avoir un maximum de 25 nœuds de code inline en cours d’exécution par Compte AWS.
+ Votre code ne doit pas dépasser 5 Mo.
#### Entrées de nœud de code inline
Les entrées que vous définissez pour un nœud de code inline sont disponibles sous forme de variables Python dans votre code. Par exemple, si vous définissez une entrée nommée `userData`, vous pouvez y accéder directement dans votre code en tant que `userData`.
La valeur de chaque entrée est renseignée en fonction de l’expression que vous définissez. Par exemple, si l’entrée du nœud est `{"name": "John", "age": 30}` et que l’expression est `$.name`, la valeur de la variable d’entrée est `"John"`.
#### Sortie de nœud de code inline
Le résultat de la dernière ligne exécutée de votre code est renvoyé en tant que nœud de code inline. Cette sortie est disponible pour les nœuds suivants de votre flux.
Par exemple, le code suivant renvoie un dictionnaire comme sortie du nœud :
```
# Process input data
result = {"processed": True, "data": userData}
# The last line's result is returned as the node output
result
```
### Nœud Lex
**Note**
Le nœud Lex repose sur le service Amazon Lex, qui peut stocker et utiliser le contenu des clients pour le développement et l'amélioration continue d'autres AWS services. En tant que AWS client, vous pouvez refuser que votre contenu soit stocké ou utilisé pour améliorer le service. Pour découvrir comment implémenter une stratégie de désactivation pour Amazon Lex, consultez [Stratégies de désactivation des services d’IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html).
Un nœud Lex vous permet d’appeler un bot Amazon Lex pour traiter un énoncé à l’aide du traitement du langage naturel et identifier une intention, en fonction de la définition du bot. Pour plus d’informations, consultez le [Guide du développeur Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
Dans la configuration, spécifiez l’Amazon Resource Name (ARN) de l’alias du bot à utiliser et les paramètres régionaux à utiliser. Les entrées dans le nœud sont l’énoncé et tous les [attributs de demande](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) ou [attributs de session](https://docs.aws.amazon.com/lexv2/latest/dg/context-mgmt-request-attribs.html) qui l’accompagnent. Le nœud renvoie l’intention identifiée en sortie.
**Note**
À l’heure actuelle, le nœud Lex ne prend pas en charge les conversations à plusieurs tours. Un nœud Lex ne peut traiter qu’un seul énoncé.
Voici la structure générale d'un [FlowNode](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowNode.html)objet Lex :
```
{
"name": "string",
"type": "Lex",
"inputs": [
{
"name": "inputText",
"type": "String | Number | Boolean | Object | Array",
"expression": "string"
},
{
"name": "requestAttributes",
"type": "Object",
"expression": "string"
},
{
"name": "sessionAttributes",
"type": "Object",
"expression": "string"
}
],
"outputs": [
{
"name": "predictedIntent",
"type": "String"
}
],
"configuration": {
"lex": {
"botAliasArn": "string",
"localeId": "string"
}
}
}
```
## Tableaux récapitulatifs pour les types de nœuds
Les tableaux suivants récapitulent les entrées et sorties autorisées pour chaque type de nœud. Notez ce qui suit :
+ Si un nom est marqué comme **N’importe lequel**, vous pouvez fournir toute chaîne comme nom. Sinon, vous devez utilisez la valeur spécifiée dans le tableau.
+ Si un type est marqué comme **N’importe lequel**, vous pouvez spécifier l’un des types de données suivants : Chaîne, Nombre, Booléen, Objet, Tableau. Sinon, vous devez utilisez le type spécifié dans le tableau.
+ Vous pouvez définir plusieurs entrées pour les nœuds **Condition**, **Invite**, **Fonction Lambda** et **Code inline**.
**Types de nœuds logiques**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html)
**Types de nœuds de traitement des données**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-nodes.html)
# Régions et modèles pris en charge pour les flux
Amazon Bedrock Flows est pris en charge dans les domaines suivants : Régions AWS
+ ap-northeast-1
+ ap-northeast-2
+ ap-northeast-3
+ ap-south-1
+ ap-south-2
+ ap-southeast-1
+ ap-southeast-2
+ ca-central-1
+ eu-central-1
+ eu-central-2
+ eu-north-1
+ eu-south-1
+ eu-south-2
+ eu-west-1
+ eu-west-2
+ eu-west-3
+ sa-east-1
+ us-east-1
+ us-east-2
+ us-gov-east-1
+ us-gov-west-1
+ us-west-2
Les modèles pris en charge dans Amazon Bedrock Flows dépendent des nœuds que vous utilisez dans le flux :
+ Nœud d’invite : vous pouvez utiliser Prompt Management avec tout modèle de texte pris en charge pour l’API [Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html). Pour obtenir la liste des modèles pris en charge, consultez [Modèles et fonctionnalités des modèles pris en charge](conversation-inference-supported-models-features.md).
+ Nœud d’agent : pour obtenir la liste des modèles pris en charge, consultez [Régions prises en charge par les agents Amazon Bedrock](agents-supported.md).
+ Nœud de base de connaissances : pour obtenir la liste des modèles pris en charge, consultez [Modèles et régions pris en charge pour les bases de connaissances Amazon Bedrock](knowledge-base-supported.md).
Pour obtenir un tableau indiquant quels modèles sont pris en charge dans quelles régions, consultez [Modèles de fondation pris en charge dans Amazon Bedrock](models-supported.md).
# Conditions préalables pour Amazon Bedrock Flows
Avant de créer un flux, passez en revue les conditions préalables suivantes et déterminez celles que vous devez remplir :
1. Définissez ou créez des ressources pour un ou plusieurs nœuds que vous prévoyez d’ajouter à votre flux :
+ Pour un nœud d’invite : créez une invite à l’aide de Prompt Management. Pour de plus amples informations, veuillez consulter [Création et stockage d’invites réutilisables avec la gestion des invites dans Amazon Bedrock](prompt-management.md). Si vous prévoyez de définir des invites inline lors de la création du nœud dans le flux, il n’est pas nécessaire de créer une invite dans Prompt Management.
+ Pour un nœud de base de connaissances : créez une base de connaissances que vous prévoyez d’utiliser dans le flux. Pour de plus amples informations, veuillez consulter [Récupération de données et génération de réponses basées sur l’IA avec Amazon Bedrock Knowledge Bases](knowledge-base.md).
+ Pour un nœud d’agent : créez un agent que vous prévoyez d’utiliser dans le flux. Pour de plus amples informations, veuillez consulter [Automatisation des tâches de votre application à l’aide d’agents d’IA](agents.md).
+ Pour un nœud de stockage S3 : créez un compartiment S3 pour stocker une sortie provenant d’un nœud du flux.
+ Pour un nœud de récupération S3 : créez un objet S3 dans un compartiment à partir duquel vous pouvez récupérer des données pour le flux. L’objet S3 doit être une chaîne encodée en UTF-8.
+ Pour un nœud Lambda : définissez une AWS Lambda fonction pour la logique métier que vous prévoyez d'implémenter dans le flux. Pour plus d’informations, consultez le [Guide du développeur AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/).
+ Pour un nœud Amazon Lex : créez un bot Amazon Lex pour identifier les intentions. Pour plus d’informations, consultez le [Guide du développeur Amazon Lex](https://docs.aws.amazon.com/lex/latest/dg/).
1. Pour utiliser des flux, vous devez avoir deux rôles différents :
1. **Rôle utilisateur : le rôle** IAM que vous utilisez pour vous connecter à l'API AWS Management Console ou pour effectuer des appels d'API doit être autorisé à effectuer des actions liées aux flux.
Si la [AmazonBedrockFullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonBedrockFullAccess)politique est attachée à votre rôle, vous n'avez pas besoin de configurer d'autorisations supplémentaires pour ce rôle. Pour restreindre les autorisations d’un rôle aux actions utilisées pour les flux, attachez la politique basée sur l’identité suivante au rôle IAM :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "FlowPermissions",
"Effect": "Allow",
"Action": [
"bedrock:CreateFlow",
"bedrock:UpdateFlow",
"bedrock:GetFlow",
"bedrock:ListFlows",
"bedrock:DeleteFlow",
"bedrock:ValidateFlowDefinition",
"bedrock:CreateFlowVersion",
"bedrock:GetFlowVersion",
"bedrock:ListFlowVersions",
"bedrock:DeleteFlowVersion",
"bedrock:CreateFlowAlias",
"bedrock:UpdateFlowAlias",
"bedrock:GetFlowAlias",
"bedrock:ListFlowAliases",
"bedrock:DeleteFlowAlias",
"bedrock:InvokeFlow",
"bedrock:TagResource",
"bedrock:UntagResource",
"bedrock:ListTagsForResource"
],
"Resource": "*"
}
]
}
```
------
Vous pouvez restreindre davantage les autorisations en omettant des [actions](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-actions) ou en spécifiant des [ressources](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-resources) et des [clés de condition](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies-conditionkeys). Une identité IAM peut appeler des opérations d’API au niveau de ressources spécifiques. Si vous spécifiez une opération d’API qui ne peut pas être utilisée sur la ressource spécifiée dans la politique, Amazon Bedrock renvoie une erreur.
1. **Rôle de service** : rôle qui permet à Amazon Bedrock d’effectuer des actions en votre nom. Vous devez spécifier ce rôle lors de la création ou de la mise à jour d’un flux. Vous pouvez créer un [[rôle de service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html#iam-term-service-role) Gestion des identités et des accès AWS personnalisé](flows-permissions.md).
**Note**
Si vous prévoyez de créer automatiquement un rôle à l’aide de la console Amazon Bedrock lorsque vous créez un flux, il n’est pas nécessaire de configurer ce rôle manuellement.
# Création et conception d’un flux dans Amazon Bedrock
Dans cette section, découvrez comment créer et concevoir des flux avec la console Amazon Bedrock. Pour vous aider à démarrer, les flux que vous créez avec la console sont configurés pour s’exécuter avec un seul nœud d’invite. Cette section inclut également d’autres exemples et modèles permettant de créer différents types de flux.
Si vous souhaitez créer un flux à l’aide du kit AWS SDK, consultez [Exécution d’exemples de code Amazon Bedrock Flows](flows-code-ex.md).
**Topics**
+ [Création de votre premier flux dans Amazon Bedrock](flows-get-started.md)
+ [Conception d’un flux dans Amazon Bedrock](flows-design.md)
+ [Test d’exemples de flux](flows-ex.md)
+ [Création d’un flux Amazon Bedrock à l’aide d’un modèle](flows-templates.md)
# Création de votre premier flux dans Amazon Bedrock
Chaque fois que vous créez un flux, la console Amazon Bedrock crée un flux de démarrage pour vous. Le flux comprend un nœud **Entrée du flux**, un nœud **Invite** et un nœud **Sortie du flux**. Lorsque vous exécutez le flux, vous saisissez un sujet pour le flux qui résume le sujet à l’aide du nœud d’invite. Avant de pouvoir exécuter les flux, vous devez définir le modèle de l’invite.
Pour créer un flux, vous devez fournir un nom et une description pour le flux. Par défaut, Amazon Bedrock crée un rôle de service avec les autorisations appropriées. Vous pouvez éventuellement spécifier un rôle de service existant.
Amazon Bedrock chiffre vos données au repos. Par défaut, Amazon Bedrock chiffre ces données à l’aide d’une clé gérée par AWS. Vous pouvez éventuellement chiffrer les données d’exécution du flux à l’aide d’une clé gérée par le client. Pour plus d’informations, consultez [Chiffrement des ressources Amazon Bedrock Flows](encryption-flows.md).
Une fois le flux de démarrage terminé ou si vous n’en avez pas besoin, vous pouvez continuer à créer votre flux. Nous vous recommandons de lire [Fonctionnement d’Amazon Bedrock Flows](flows-how-it-works.md) pour vous familiariser avec les concepts et les termes d’Amazon Bedrock Flows et découvrir les types de nœuds à votre disposition. Pour plus d’informations, consultez [Conception d’un flux dans Amazon Bedrock](flows-design.md).
**Pour créer votre premier flux**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche.
1. Dans la section **Flux Amazon Bedrock**, cliquez sur **Créer un flux**.
1. Saisissez un **Nom** pour le flux et une **Description** facultative.
1. Pour le champ **Nom du rôle de service**, choisissez l’une des options suivantes :
+ **Créer et utiliser un nouveau rôle de service** : laissez Amazon Bedrock créer un rôle de service que vous pourrez utiliser.
+ **Utiliser un rôle de service existant** : sélectionnez un rôle de service personnalisé que vous avez configuré précédemment. Pour plus d’informations, consultez [Création d’un rôle de service pour Amazon Bedrock Flows dans Amazon Bedrock](flows-permissions.md).
1. (Facultatif) Chiffrez votre flux avec une clé gérée par le client en procédant comme suit :
1. Choisissez **Configurations supplémentaires**.
1. Dans le champ **Sélection de la clé KMS**, sélectionnez **Personnaliser les paramètres de chiffrement (avancé)**. Effectuez ensuite l’une des opérations suivantes dans **Choisir une clé AWS KMS** :
+ Pour utiliser une clé existante, saisissez l’ARN ou recherchez la clé que vous souhaitez utiliser.
+ Pour créer une clé, choisissez **Créer une clé AWS KMS** pour ouvrir la console AWS Key Management Service et [créer la clé](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html). Lorsque vous créez la clé, notez son ARN. De retour dans la console Amazon Bedrock, saisissez l’ARN de la clé dans **Choisir une clé AWS KMS**.
Pour plus d’informations, consultez [Chiffrement des ressources Amazon Bedrock Flows](encryption-flows.md).
1. Cliquez sur **Créer**. Amazon Bedrock crée le flux de démarrage et vous redirige vers le **créateur de flux**.
1. Dans la section **Créateur de flux**, notez que le volet central (canevas) affiche un nœud **Entrée du flux**, un nœud **Invite** et un nœud **Sortie du flux**. Les nœuds sont déjà connectés entre eux.
1. Dans le canevas, sélectionnez le nœud d’**invite**.
1. Dans le volet Créateur de flux, cliquez sur la section **Configurations**.
1. Sous **Nom du nœud**, assurez-vous que l’option **Définir dans le nœud** est sélectionnée.
1. Dans le champ **Sélectionner un modèle**, sélectionnez un modèle à utiliser.
1. Cliquez sur **Enregistrer** pour enregistrer votre flux.
1. Dans le volet **Tester le flux** à droite, saisissez un sujet pour le flux à résumer.
1. Cliquez sur **Exécuter** pour exécuter le flux. Le flux affiche le sujet résumé.
# Conception d’un flux dans Amazon Bedrock
Dans cette section, vous allez concevoir un flux Amazon Bedrock. Avant de concevoir un flux, nous vous recommandons de lire [Fonctionnement d’Amazon Bedrock Flows](flows-how-it-works.md) pour vous familiariser avec les concepts et les termes d’Amazon Bedrock Flows et découvrir les types de nœuds à votre disposition. Pour obtenir des exemples de flux que vous pouvez essayer, consultez [Test d’exemples de flux](flows-ex.md).
**Pour créer votre flux**
1. Si vous n’êtes pas encore dans le **Créateur de flux**, procédez comme suit :
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Choisissez ensuite un flux dans la section **Flux Amazon Bedrock**.
1. Choisissez **Modifier dans le créateur de flux**.
1. Dans la section **Créateur de flux**, le volet central affiche un nœud **Entrée du flux** et un nœud **Sortie du flux**. Il s’agit des nœuds d’entrée et de sortie de votre flux.
1. Procédez comme suit pour ajouter et configurer des nœuds :
1. Dans le volet **Créateur de flux**, sélectionnez **Nœuds**.
1. Faites glisser le nœud que vous souhaitez utiliser pour la première étape de votre flux et déposez-le dans le volet central.
1. Les cercles sur les nœuds sont des points de connexion. Pour connecter votre nœud d’entrée de flux au deuxième nœud, faites glisser une ligne entre le cercle du nœud **Entrée du flux** et le cercle de la section **Entrée** du nœud que vous venez d’ajouter.
1. Sélectionnez le nœud que vous venez d’ajouter.
1. Dans la section **Configurer** du volet **Créateur de flux**, fournissez les configurations pour le nœud sélectionné et définissez les noms, les types de données et les expressions pour les entrées et les sorties du nœud.
1. Dans le volet **Créateur de flux**, sélectionnez **Nœuds**.
1. Répétez les étapes pour ajouter et configurer les nœuds restants de votre flux.
**Note**
Si vous utilisez un rôle de service qu’Amazon Bedrock a automatiquement créé pour vous, le rôle est mis à jour avec les autorisations appropriées au fur et à mesure que vous ajoutez des nœuds. Cependant, si vous utilisez un rôle de service personnalisé, vous devez ajouter les autorisations appropriées à la politique attachée à votre rôle de service en consultant [Création d’un rôle de service pour Amazon Bedrock Flows dans Amazon Bedrock](flows-permissions.md).
1. Connectez la **Sortie** du dernier nœud de votre flux à l’**Entrée** du nœud **Sortie du flux**. Vous pouvez disposer de plusieurs nœuds **Sortie du flux**. Pour ajouter des nœuds de sortie de flux supplémentaires, faites glisser le nœud **Sortie du flux** et déposez-le en regard du nœud où vous souhaitez que le flux s’arrête. Veillez à établir des connexions entre les deux nœuds.
1. Passez à la procédure suivante pour [Test d’un flux dans Amazon Bedrock](flows-test.md) ou revenez plus tard. Cliquez sur **Enregistrer** pour passer à l’étape suivante. Pour revenir plus tard, cliquez sur **Enregistrer et quitter**.
**Suppression d’un nœud ou d’une connexion**
Au cours du processus de création de votre flux, vous devrez peut-être supprimer un nœud ou des connexions de nœud.
**Pour supprimer un nœud**
1. Sélectionnez le nœud que vous souhaitez supprimer.
1. Dans le volet **Créateur de flux**, cliquez sur l’icône de suppression (![\[Trapezoid-shaped diagram showing data flow from source to destination through AWS Transfer Family.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/icons/trash.png)).
**Note**
Si vous utilisez un rôle de service qu’Amazon Bedrock a automatiquement créé pour vous, le rôle est mis à jour avec les autorisations appropriées au fur et à mesure que vous ajoutez des nœuds. Cependant, si vous supprimez des nœuds, les autorisations correspondantes ne sont pas supprimées. Nous vous recommandons de supprimer les autorisations dont vous n’avez plus besoin en suivant les étapes sous [Modification d’un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_manage_modify.html).
**Pour supprimer une connexion**
+ Sur la page **Créateur de flux**, survolez la connexion que vous souhaitez supprimer jusqu’à ce que l’icône de développement s’affiche, puis faites glisser la connexion hors du nœud.
Les exigences suivantes s’appliquent à la création d’un flux :
+ Votre flux ne doit comporter qu’un seul nœud d’entrée de flux et au moins un nœud de sortie de flux.
+ Vous ne pouvez pas inclure d’entrées pour un nœud d’entrée de flux.
+ Vous ne pouvez pas inclure de sorties pour un nœud de sortie de flux.
+ Chaque sortie d’un nœud doit être connectée à une entrée d’un nœud en aval. (Dans l’API, vous y parvenez au moyen d’une connexion [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) avec une configuration [FlowDataConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDataConnectionConfiguration.html).)
+ Chaque condition (y compris celle par défaut) d’un nœud de condition doit être connectée à un nœud en aval. (Dans l’API, vous y parvenez au moyen d’une connexion [FlowConnection](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConnection.html) avec une configuration [FlowConditionalConnectionConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowConditionalConnectionConfiguration.html).)
Les conseils suivants s’appliquent à la création d’un flux :
+ Commencez par définir le type de données pour la sortie du nœud d’entrée du flux. Ce type de données doit correspondre à ce que vous comptez envoyer en entrée lorsque vous invoquez le flux.
+ Lorsque vous définissez les entrées d’un flux à l’aide d’expressions, vérifiez que le résultat correspond au type de données que vous avez choisi pour l’entrée.
+ Si vous incluez un nœud itérateur, incluez un nœud collecteur en aval après avoir envoyé la sortie au moyen des nœuds dont vous avez besoin. Le nœud collecteur renvoie les sorties sous forme de tableau.
# Test d’exemples de flux
Cette rubrique fournit des exemples de flux que vous pouvez essayer pour commencer à utiliser Amazon Bedrock Flows. Vous pouvez également créer un flux initial à l’aide de modèles. Pour plus d’informations, consultez [Création d’un flux Amazon Bedrock à l’aide d’un modèle](flows-templates.md).
Développez un exemple pour découvrir comment le créer dans la console Amazon Bedrock :
**Topics**
+ [Création d’un flux avec une seule invite](flows-ex-prompt.md)
+ [Création d’un flux avec un nœud de condition](flows-ex-condition.md)
# Création d’un flux avec une seule invite
L’image suivante montre un flux composé d’une seule invite, définie inline dans le nœud. L’invite génère une liste de lecture de chansons à partir d’une entrée d’objet JSON qui inclut le genre et le nombre de chansons à inclure dans la liste de lecture.
![\[Exemple d’utilisation d’un nœud d’invite avec deux variables.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-prompt.png)
**Pour créer et tester ce flux dans la console**
1. Créez un flux en suivant les instructions sous [Création de votre premier flux dans Amazon Bedrock](flows-get-started.md).
1. Configurez le nœud d’invite en procédant comme suit :
1. Sélectionnez le nœud **Invite** dans le volet central.
1. Cliquez sur l’onglet **Configurer** dans le volet **Créateur de flux**.
1. Saisissez **MakePlaylist** comme **Nom du nœud**.
1. Choisissez **Définir dans le nœud**.
1. Paramétrez les configurations suivantes pour l’invite :
1. Sous **Sélectionner un modèle**, sélectionnez un modèle pour exécuter l’inférence sur l’invite.
1. Dans la zone de texte **Message**, saisissez **Make me a \$1\$1genre\$1\$1 playlist consisting of the following number of songs: \$1\$1number\$1\$1.** Deux variables s’affichant en tant qu’entrées dans le nœud sont alors créées.
1. (Facultatif) Modifiez les **configurations d’inférence**.
1. (Facultatif) En cas de prise en charge par le modèle, vous pouvez configurer la **Mise en cache des invites** pour le message d’invite. Pour plus d’informations, consultez [Création et conception d’un flux dans Amazon Bedrock](flows-create.md).
1. Développez la section **Entrées**. Les noms des entrées sont pré-renseignés par les variables du message d’invite. Configurez les entrées comme suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-ex-prompt.html)
Cette configuration signifie que le nœud d’invite attend un objet JSON contenant un champ nommé `genre` mappé à l’entrée `genre` et un champ nommé `number` mappé à l’entrée `number`.
1. Vous ne pouvez pas modifier la **Sortie**. Il s’agit de la réponse du modèle, renvoyée sous forme de chaîne.
1. Choisissez le nœud **Entrée du flux** et cliquez sur l’onglet **Configurer**. Sélectionnez **Objet** comme **Type**. Autrement dit, l’invocation du flux s’attend à recevoir un objet JSON.
1. Connectez vos nœuds pour terminer le flux en procédant comme suit :
1. Faites glisser une connexion du nœud de sortie du nœud **Entrée du flux** vers l’entrée **genre** dans le nœud d’invite **MakePlaylist**.
1. Faites glisser une connexion du nœud de sortie du nœud **Entrée du flux** vers l’entrée **number** dans le nœud d’invite **MakePlaylist**.
1. Faites glisser une connexion du nœud de sortie de la sortie **modelCompletion** dans le nœud d’invite **MakePlaylist** vers l’entrée **document** dans le nœud **Sortie du flux**.
1. Cliquez sur **Enregistrer** pour enregistrer votre flux. Votre flux devrait maintenant être prêt pour les tests.
1. Testez votre flux en saisissant l’objet JSON suivant dans le volet **Tester le flux** à droite. Cliquez sur **Exécuter** et le flux devrait renvoyer une réponse de modèle.
```
{
"genre": "pop",
"number": 3
}
```
# Création d’un flux avec un nœud de condition
L’image suivante montre un flux avec un nœud de condition, qui renvoie l’une des trois valeurs possibles en fonction de la condition remplie :
![\[Exemple d’utilisation d’un nœud de condition avec deux conditions.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-condition.png)
**Pour créer et tester ce flux dans la console :**
1. Créez un flux en suivant les instructions sous [Création de votre premier flux dans Amazon Bedrock](flows-get-started.md).
1. Supprimez le nœud **Invite** dans le volet central.
1. Configurez le nœud de condition en procédant comme suit :
1. Dans le volet gauche **Créateur de flux**, cliquez sur l’onglet **Nœuds**.
1. Faites glisser un nœud **Condition** dans votre flux dans le volet central.
1. Cliquez sur l’onglet **Configurer** dans le volet **Créateur de flux**.
1. Développez la section **Entrées**. Configurez les entrées comme suit :
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/flows-ex-condition.html)
Cette configuration signifie que le nœud de condition attend un objet JSON contenant les champs `retailPrice`, `marketPrice` et `type`.
1. Configurez les conditions en procédant comme suit :
1. Dans la section **Conditions**, modifiez éventuellement le nom de la condition. Ajoutez ensuite la condition suivante dans la zone de texte **Condition** : **(retailPrice > 10) and (type == "produce")**.
1. Ajoutez une deuxième condition en cliquant sur **Ajouter une condition**. Modifiez éventuellement le nom de la deuxième condition. Ajoutez ensuite la condition suivante dans la zone de texte **Condition** : **(retailPrice < marketPrice)**.
1. Choisissez le nœud **Entrée du flux** et cliquez sur l’onglet **Configurer**. Sélectionnez **Objet** comme **Type**. Autrement dit, l’invocation du flux s’attend à recevoir un objet JSON.
1. Ajoutez des nœuds de sortie de flux pour en avoir trois au total. Configurez-les comme suit dans l’onglet **Configurer** du volet **Créateur de flux** de chaque nœud de sortie de flux :
1. Définissez le type d’entrée du premier nœud de sortie de flux sur **String** et l’expression sur **\$1.data.action[0]** pour renvoyer la première valeur du tableau dans le champ `action` de l’objet entrant.
1. Définissez le type d’entrée du deuxième nœud de sortie de flux sur **String** et l’expression sur **\$1.data.action[1]** pour renvoyer la deuxième valeur du tableau dans le champ `action` de l’objet entrant.
1. Définissez le type d’entrée du troisième nœud de sortie de flux sur **String** et l’expression sur **\$1.data.action[2]** pour renvoyer la troisième valeur du tableau dans le champ `action` de l’objet entrant.
1. Connectez la première condition au premier nœud de sortie de flux, la deuxième condition au deuxième nœud de sortie de flux et la condition par défaut au troisième nœud de sortie de flux.
1. Connectez les entrées et les sorties de tous les nœuds pour terminer le flux en procédant comme suit :
1. Faites glisser une connexion du nœud de sortie du nœud **Entrée du flux** vers l’entrée **retailPrice** dans le nœud de condition.
1. Faites glisser une connexion du nœud de sortie du nœud **Entrée du flux** vers l’entrée **marketPrice** dans le nœud de condition.
1. Faites glisser une connexion du nœud de sortie du nœud **Entrée du flux** vers l’entrée **type** dans le nœud de condition.
1. Faites glisser une connexion de la sortie du nœud **Entrée du flux** vers l’entrée **document** dans chacun des trois nœuds de sortie.
1. Cliquez sur **Enregistrer** pour enregistrer votre flux. Votre flux devrait maintenant être prêt pour les tests.
1. Testez votre flux en saisissant les objets JSON suivants dans le volet **Tester le flux** à droite. Cliquez sur **Exécuter** pour chaque entrée :
1. L’objet suivant remplit la première condition (L’entrée `retailPrice` est supérieure à 10 et l’entrée `type` est définie sur « produce ».) et renvoie la première valeur dans `action` (« don’t buy ») :
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "produce",
"action": ["don't buy", "buy", "undecided"]
}
```
**Note**
Même si les première et deuxième conditions sont remplies, la première prévaut, car elle est la première.
1. L’objet suivant remplit la deuxième condition (L’entrée `retailPrice` est inférieure à l’entrée `marketPrice`.) et renvoie la deuxième valeur dans `action` (« buy ») :
```
{
"retailPrice": 11,
"marketPrice": 12,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
1. L’objet suivant ne remplit ni la première condition (L’entrée `retailPrice` est supérieure à 10, mais l’entrée `type` n’est pas définie sur « produce ».), ni la deuxième (L’entrée `retailPrice` n’est pas inférieure à l’entrée `marketPrice`.), donc la troisième valeur dans `action` (« undecided ») est renvoyée :
```
{
"retailPrice": 11,
"marketPrice": 11,
"type": "meat",
"action": ["don't buy", "buy", "undecided"]
}
```
# Création d’un flux Amazon Bedrock à l’aide d’un modèle
Pour vous aider à commencer à définir et orchestrer Amazon Bedrock Flows, vous pouvez créer des flux pour diverses configurations de flux à l’aide de modèles. Par exemple, un modèle vous permet de voir un flux qui inclut une base de connaissances ou un flux qui oriente la logique de flux à l’aide de conditions.
Vous pouvez accéder aux modèles depuis le référentiel GitHub [Amazon Bedrock Flows Samples](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file). La console Amazon Bedrock fournit également un lien vers le référentiel depuis la page de canevas d’un flux.
Les modèles de flux sont fournis sous forme de [modèles JSON](https://github.com/aws-samples/amazon-bedrock-flows-samples/tree/main/templates) pour chaque définition de flux prise en charge et d’un script Python vous permettant de créer et d’exécuter le flux. Vous pouvez également accéder au flux à partir de la console Amazon Bedrock.
Le référentiel fournit les modèles suivants :
+ [Flux de base de connaissances](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1) : montre comment intégrer et interroger une [base de connaissances](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#1-knowledgebase-flow-1), y compris la génération à enrichissement contextuel (RAG) et la recherche et la récupération dans la base de connaissances.
+ [Flux d’agent de conversation à plusieurs tours](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#2-multi-turn-conversation-agent-flow-1) : montre comment effectuer des conversations interactives avec état avec un flux. Pour plus d’informations, consultez [Conversation avec un flux Amazon Bedrock](flows-multi-turn-invocation.md).
+ [Flux de conditions](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#3-conditions-flow-1) : montre comment exécuter une logique conditionnelle et une ramification au sein d’un flux.
+ [Nœud d’invite avec flux de barrière de protection](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#4-prompt-node-with-guardrail-flow-1) : montre comment protéger un nœud d’invite avec une barrière de protection.
+ [Flux itérateur et collecteur](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1) : montre comment traiter plusieurs entrées et agréger des réponses.
+ [Flux multi-agent](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#5-iterator--collector-flow-1) : affiche divers flux de travail basés sur des agents, notamment la collaboration multi-agent et la délégation de tâches.
Avant de pouvoir exécuter le script, vous devez créer les ressources Amazon Bedrock, comme une base de connaissances ou un agent, utilisées par le flux. Il vous incombe de supprimer ces ressources lorsque vous n’en avez plus besoin.
Pour créer et exécuter un flux à partir d’un modèle, vous devez exécuter le script (`flow_manager.py`). Le script demande toutes les informations supplémentaires dont il a besoin, comme le modèle de flux que vous souhaitez utiliser et les identifiants des ressources dont le modèle a besoin. Vous pouvez inclure une invite de test pour essayer le flux.
Vous pouvez éventuellement définir la région AWS dans laquelle vous souhaitez que le flux soit créé. Le script crée les ressources nécessaires avec un ensemble par défaut d’[autorisations de rôle IAM](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#iam-role-permissions). Vous pouvez également choisir d’utiliser un rôle IAM que vous créez.
Si vous souhaitez utiliser le flux dans la console Amazon Bedrock, n’utilisez pas le paramètre `--cleanup`, car cela entraîne la suppression du flux une fois que le script l’a exécuté. Si vous n’utilisez pas le paramètre `--cleanup`, vous devez supprimer le flux lorsque vous n’en avez plus besoin.
Pour plus d’informations, consultez [https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file\$1how-to-use](https://github.com/aws-samples/amazon-bedrock-flows-samples?tab=readme-ov-file#how-to-use).
# Affichage d’informations sur les flux dans Amazon Bedrock
Pour découvrir comment afficher des informations sur un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour afficher les détails d’un flux**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Ensuite, dans la section **Flux Amazon Bedrock**, sélectionnez un flux.
1. Consultez les détails du flux dans le volet **Détails du flux**.
------
#### [ API ]
Pour obtenir des informations sur un flux, envoyez une demande [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`.
Pour répertorier des informations sur vos flux, envoyez une demande [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Vous pouvez préciser les paramètres facultatifs suivants :
****
| Champ | Description abrégée |
| --- | --- |
| maxResults | Nombre maximum de résultats à renvoyer en réponse. |
| nextToken | Si le nombre de résultats est supérieur à ce que vous avez spécifié dans le champ maxResults, la réponse renvoie une valeur nextToken. Pour voir le prochain lot de résultats, envoyez la valeur nextToken dans une autre demande. |
------
# Modification d’un flux dans Amazon Bedrock
Pour découvrir comment modifier un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour modifier les détails d’un flux**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Ensuite, dans la section **Flux Amazon Bedrock**, sélectionnez un flux.
1. Dans la section **Détails du flux**, cliquez sur **Modifier**.
1. Vous pouvez modifier le nom et la description du flux et lui associer un rôle de service différent.
1. Cliquez sur **Enregistrer les modifications**.
**Pour modifier un flux**
1. Si vous n’êtes pas encore dans le **Créateur de flux**, procédez comme suit :
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Choisissez ensuite un flux dans la section **Flux Amazon Bedrock**.
1. Choisissez **Modifier dans le créateur de flux**.
1. Ajoutez, supprimez et modifiez des nœuds et des connexions si nécessaire. Pour plus d’informations, consultez [Création et conception d’un flux dans Amazon Bedrock](flows-create.md) et [Types de nœuds pour votre flux](flows-nodes.md).
1. Après avoir modifié votre flux, cliquez sur **Enregistrer** ou **Enregistrer et quitter**.
------
#### [ API ]
Pour modifier un flux, envoyez une demande [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Incluez les champs que vous souhaitez conserver et ceux que vous souhaitez modifier. Pour plus d’informations sur les champs de la demande, consultez [Création et conception d’un flux dans Amazon Bedrock](flows-create.md).
------
# Inclusion de barrières de protection dans votre flux dans Amazon Bedrock
Amazon Bedrock Flows s’intègre aux barrières de protection Amazon Bedrock pour vous permettre d’identifier, de bloquer ou de filtrer le contenu indésirable de votre flux. Pour découvrir comment appliquer des barrières de protection aux types de nœuds pris en charge dans un flux, consultez le tableau suivant :
****
| Type de nœud | Console | API |
| --- | --- | --- |
| Nœud d’invite | Lorsque vous [créez](flows-create.md) ou [mettez à jour](flows-modify.md) un flux, sélectionnez le nœud d’invite et spécifiez la barrière de protection dans la section Configurer. | Lorsque vous définissez le nœud d’invite dans le champ nodes d’une demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) ou [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), incluez un champ guardrailConfiguration dans [PromptFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PromptFlowNodeConfiguration.html). |
| Nœud de base de connaissances | Lorsque vous [créez](flows-create.md) ou [mettez à jour](flows-modify.md) un flux, sélectionnez le nœud de la base de connaissances et spécifiez la barrière de protection dans la section Configurer. Vous pouvez inclure une barrière de protection seulement si vous générez des réponses basées sur les résultats récupérés. | Lorsque vous définissez le nœud de base de connaissances dans le champ nodes d’une demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) ou [UpdateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlow.html), incluez un champ guardrailConfiguration dans [KnowledgeBaseFlowNodeConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_KnowledgeBaseFlowNodeConfiguration.html). Vous pouvez inclure une barrière de protection seulement si vous utilisez RetrieveAndGenerate, donc vous devez inclure un modelId. |
Pour plus d’informations sur les barrières de protection, consultez [Détection et filtrage des contenus préjudiciables à l’aide des barrières de protection Amazon Bedrock](guardrails.md).
Pour plus d’informations sur les types de nœuds, consultez [Types de nœuds pour votre flux](flows-nodes.md).
# Test d’un flux dans Amazon Bedrock
Après avoir créé un flux, vous disposez d’une *version préliminaire*. La version préliminaire est une version du flux que vous pouvez créer et tester de manière itérative. Chaque fois que vous apportez des modifications à votre flux, la version préliminaire est mise à jour.
Lorsque vous testez votre flux, Amazon Bedrock vérifie d’abord les points suivants et génère une exception en cas d’échec de la vérification :
+ Connectivité entre tous les nœuds du flux.
+ Au moins un nœud de sortie du flux est configuré.
+ Les types de variables d’entrée et de sortie sont mis en correspondance si nécessaire.
+ Les expressions de condition sont valides et un résultat par défaut est fourni.
Si la vérification échoue, vous devez corriger les erreurs avant de pouvoir tester et valider les performances de votre flux. Voici les étapes à suivre pour tester votre flux. Choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour tester votre flux**
1. Si vous n’êtes pas encore dans le **Créateur de flux**, procédez comme suit :
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Ensuite, dans la section **Flux Amazon Bedrock**, sélectionnez le flux que vous souhaitez tester.
1. Choisissez **Modifier dans le créateur de flux**.
1. Sur la page **Créateur de flux**, dans le volet droit, saisissez une entrée pour invoquer votre flux. Vérifiez que le type de données d’entrée correspond au type de données de sortie que vous avez configuré pour le nœud d’entrée du flux.
1. Cliquez sur **Exécuter**.
1. Les nœuds ou connexions de la configuration du flux qui déclenchent des erreurs sont surlignés en rouge et ceux qui déclenchent des avertissements sont surlignés en jaune. Lisez les messages d’erreur et les avertissements, résolvez les problèmes identifiés, enregistrez le flux et réexécutez votre test.
**Note**
Vous devez enregistrer le flux afin que les modifications que vous avez apportées soient appliquées lorsque vous testez le flux.
1. (Facultatif) Pour afficher les entrées, les sorties et la durée d’exécution de chaque nœud, cliquez sur **Afficher la trace** dans la réponse. Pour plus d’informations, consultez [Suivi de chaque étape de votre flux en consultant sa trace dans Amazon BedrockSuivi de chaque étape de votre flux en consultant sa trace](flows-trace.md). Pour revenir au créateur visuel, cliquez sur **Masquer la trace** ou sur l’icône de réduction.
1. Une fois que les performances de votre flux vous conviennent, cliquez sur **Enregistrer et quitter**.
1. Vous pouvez continuer à itérer pour créer votre flux. Lorsqu’il vous convient et que vous êtes prêt(e) à le déployer en production, créez une version du flux et un alias pour pointer vers cette version. Pour plus d’informations, consultez [Déploiement d’un flux dans votre application à l’aide de versions et d’alias](flows-deploy.md).
------
#### [ API ]
Pour tester votre flux, envoyez une demande [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) avec un [point de terminaison d’exécution des agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Incluez l’ARN ou l’identifiant du flux dans le champ `flowIdentifier` et l’ARN ou l’identifiant de l’alias à utiliser dans le champ `flowAliasIdentifier`.
Pour afficher les entrées et sorties de chaque nœud, définissez le champ `enableTrace` sur `TRUE`. Pour plus d’informations, consultez [Suivi de chaque étape de votre flux en consultant sa trace dans Amazon BedrockSuivi de chaque étape de votre flux en consultant sa trace](flows-trace.md).
Le corps de la requête indique l’entrée du flux et est au format suivant :
```
{
"inputs": [
{
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeOutputName": "string"
}
],
"enableTrace": TRUE | FALSE
}
```
Saisissez l’entrée dans le champ `document`, un nom pour l’entrée dans le champ `nodeName` et un nom pour la sortie dans le champ `nodeOutputName`.
La réponse est renvoyée dans un flux. Chaque événement renvoyé contient la sortie d’un nœud dans le champ `document`, le nœud traité dans le champ `nodeName` et le type de nœud dans le champ `nodeType`. Ces événements sont au format suivant :
```
{
"flowOutputEvent": {
"content": {
"document": "JSON-formatted string"
},
"nodeName": "string",
"nodeType": "string"
}
}
```
Si le flux se termine, un champ `flowCompletionEvent` contenant le `completionReason` est également renvoyé. En cas d’erreur, le champ d’erreur correspondant est renvoyé.
------
# Suivi de chaque étape de votre flux en consultant sa trace dans Amazon Bedrock
Lorsque vous invoquez un flux, vous pouvez consulter la *trace* pour voir les entrées et les sorties de chaque nœud. La trace vous permet de suivre le chemin entre l’entrée et la réponse renvoyée. La trace vous permet de corriger les erreurs qui se produisent, d’identifier les étapes qui entraînent un résultat inattendu ou un ralentissement des performances et de réfléchir aux moyens d’améliorer le flux.
Pour consulter la trace, procédez comme suit :
+ Dans la console, suivez les étapes dans l’onglet **Console** sous [Test d’un flux dans Amazon Bedrock](flows-test.md) et choisissez **Afficher la trace** dans la réponse à l’invocation du flux.
+ Dans l’API, définissez le champ `enableTrace` sur `true` dans une demande [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html). Chaque `flowOutputEvent` dans la réponse est renvoyé avec un `flowTraceEvent`.
Chaque événement de trace inclut le nom du nœud qui a reçu une entrée ou produit une sortie et la date à laquelle l’entrée ou la sortie a été traitée. Cliquez sur un onglet pour en savoir plus sur un type d’événement de trace :
------
#### [ FlowTraceConditionNodeResultEvent ]
Ce type de trace identifie les conditions remplies pour un nœud de condition et vous aide à identifier la ou les branches du flux activées lors de l’invocation. L’objet JSON suivant montre à quoi ressemble un événement [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) pour le résultat d’un nœud de condition :
```
{
"trace": {
"conditionNodeOutputTrace": {
"nodeName": "string",
"satisfiedConditions": [
{
"conditionName": "string"
},
...
],
"timestamp": timestamp
}
}
}
```
------
#### [ FlowTraceNodeInputEvent ]
Ce type de trace affiche l’entrée envoyée à un nœud. Si l’événement se situe en aval d’un nœud itérateur mais en amont d’un nœud collecteur, le champ `iterationIndex` indique l’index de l’élément du tableau dont provient l’entrée. L’objet JSON suivant montre à quoi ressemble un événement [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) pour l’entrée d’un nœud :
```
{
"trace": {
"nodeInputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeInputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
#### [ FlowTraceNodeOutputEvent ]
Ce type de trace affiche la sortie produite par un nœud. Si l’événement se situe en aval d’un nœud itérateur mais en amont d’un nœud collecteur, le champ `iterationIndex` indique l’index de l’élément du tableau dont provient la sortie. L’objet JSON suivant montre à quoi ressemble un événement [FlowTraceEvent](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowTraceEvent.html) pour la sortie d’un nœud :
```
{
"trace": {
"nodeOutputTrace": {
"fields": [
{
"content": {
"document": JSON object
},
"nodeOutputName": "string"
},
...
],
"nodeName": "string",
"timestamp": timestamp,
"iterationIndex": int
}
}
}
```
------
# Exécution de flux Amazon Bedrock de manière asynchrone avec des exécutions de flux
Avec des exécutions de flux, vous pouvez exécuter des flux Amazon Bedrock de manière asynchrone. Ainsi, vos flux peuvent s’exécuter plus longtemps et contrôler les rendements, afin que votre application puisse effectuer d’autres tâches.
Lorsque vous exécutez un flux à l'aide de la console Amazon Bedrock ou avec l'[InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)opération, le flux s'exécute jusqu'à ce qu'il se termine ou expire au bout d'une heure (selon la première éventualité). Lorsque vous exécutez un flux, celui-ci peut s’exécuter bien plus longtemps : les nœuds individuels peuvent s’exécuter pendant cinq minutes maximum et l’ensemble de votre flux peut s’exécuter pendant 24 heures maximum.
**Note**
Les exécutions de flux sont disponibles en version préliminaire pour Amazon Bedrock et peuvent encore évoluer.
## Autorisations requises pour exécuter des flux
+ Assurez-vous que votre rôle de service Amazon Bedrock Flows dispose de toutes les autorisations nécessaires. Pour de plus amples informations, veuillez consulter [Création d’un rôle de service pour Amazon Bedrock Flows dans Amazon Bedrock](flows-permissions.md).
+ (Facultatif) Chiffrez les données d'exécution de votre flux à l'aide d'une AWS KMS clé gérée par le client. Pour de plus amples informations, veuillez consulter [Chiffrement des ressources Amazon Bedrock Flows](encryption-flows.md).
## Création et gestion d’une exécution de flux
Vous pouvez créer une exécution de flux dans la console ou à l'aide de l'[StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)opération.
------
#### [ Console ]
1. Créez un flux en suivant les instructions sous [Création et conception d’un flux dans Amazon Bedrock](flows-create.md).
1. Créez un alias pour le flux en suivant les instructions sous [Création d’un alias d’un flux dans Amazon Bedrock](flows-alias-create.md).
1. Si vous n’êtes pas encore dans le **Créateur de flux**, procédez comme suit :
1. Connectez-vous au AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ouvrez ensuite la console Amazon Bedrock à l'adresse [https://console.aws.amazon.com/bedrock.](https://console.aws.amazon.com/bedrock)
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche, puis choisissez votre flux.
1. Cliquez sur l’onglet **Exécutions**, puis choisissez **Créer une exécution**.
1. Dans la boîte de dialogue **Créer une exécution**, saisissez ce qui suit :
1. Dans le champ **Nom**, saisissez le nom de l’exécution de flux.
1. Dans le champ **Sélectionner un alias**, choisissez l’alias du flux que vous souhaitez utiliser.
1. Dans le champ **Entrée d’invite**, saisissez l’invite avec laquelle vous souhaitez démarrer le flux.
1. Choisissez **Créer** pour créer l’exécution de flux et commencer à l’exécuter.
1. Sur la page des détails du flux, cliquez sur l’onglet **Exécutions** et notez le statut de l’exécution du flux indiqué dans **Statut d’exécution**.
1. (Facultatif) Choisissez une exécution pour ouvrir le flux et afficher le résumé de l’exécution.
Sous **Sortie d’exécution**, vous pouvez voir la sortie du flux.
1. (Facultatif) Pour arrêter une exécution de flux, sélectionnez-la et choisissez **Arrêter**.
------
#### [ API ]
**Lancement d’une exécution de flux**
Pour exécuter un flux, envoyez une [StartFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StartFlowExecution.html)demande avec un point de [terminaison Agents for Amazon Bedrock Runtime](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt). Dans la demande, spécifiez l’identifiant de flux et l’identifiant d’alias de flux du flux que vous souhaitez exécuter. Vous pouvez aussi spécifier les éléments suivants :
+ **inputs** : tableau contenant le nœud d’[entrée](flows-nodes.md#flows-nodes-input) à partir duquel vous souhaitez que le flux commence à s’exécuter. Vous spécifiez l’entrée à envoyer au nœud d’entrée du flux d’invite dans le champ `content`.
+ **name** : nom de l’exécution de flux.
```
{
"inputs": [{
"nodeName": "FlowInputNode",
"nodeOutputName": "document",
"content": {
"document": "Test"
}
}],
"name": "MyExecution"
}
```
La réponse est l’Amazon Resource Name (ARN) de l’exécution de flux. Vous pouvez interroger l’état actuel du flux à l’aide de l’`executionArn`, par exemple lorsque l’exécution du flux est terminée ou qu’un nœud de condition évalue ses conditions.
```
{
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution"
}
```
**Suivi de la progression d’une exécution de flux**
Utilisez l'[GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)opération pour obtenir l'état actuel d'un flux que vous identifiez par son ARN d'exécution. Le statut d’un flux est `Running`, `Succeeded`, `Failed`, `TimedOut` ou `Aborted`.
```
{
"endedAt": null,
"errors": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"startedAt": "2025-03-20T23:32:28.899221162Z",
"status": "Running"
}
```
Les erreurs (telles que le délai d’expiration d’un nœud Lambda) sont renvoyées dans le tableau `errors`, comme dans l’exemple suivant :
```
"errors": [{
"nodeName": "LambdaNode1",
"errorType": "ExecutionTimedOut",
"message": "Call to lambda function timed out"
}],
```
**Obtention des résultats d’une exécution de flux**
Amazon Bedrock écrit les sorties d’un flux dans les nœuds de [sortie](flows-nodes.md#flows-nodes-output) du flux. Vous pouvez obtenir les sorties une fois le flux terminé ou pendant son exécution (selon votre cas d’utilisation).
Si vous souhaitez que le flux soit terminé d’abord, appelez `GetFlowExecution` et assurez-vous que la valeur du champ `status` dans la réponse est `Succeeded`.
Pour obtenir une liste des événements de sortie de l'exécution du flux, appelez [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html). Dans la réponse, vérifiez la présence d’objets `flowOutputEvent` dans `flowExecutionEvents`. Par exemple, vous pouvez obtenir la sortie d’un flux dans le champ `content` :
```
{
"flowOutputEvent": {
"content": {
"document": "The model response."
},
"nodeName": "FlowOutputNode"
}
}
```
Vous pouvez limiter la sortie de `ListFlowExecutions` aux seuls nœuds d’entrée et de sortie en définissant le paramètre de requête `eventType` sur `Flow`.
**Affichage des événements**
Pour aider à débuguer l'exécution de votre flux, vous pouvez utiliser cette [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)opération pour afficher les événements générés par les nœuds pendant l'exécution du flux. Définissez le paramètre de requête `eventType` sur `Node` pour afficher les entrées et sorties de tous les nœuds (y compris les nœuds intermédiaires) dans la réponse semblable à l’exemple suivant :
```
{
"flowExecutionEvents": [{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "document"
}],
"nodeName": "FlowInputNode",
"timestamp": "2025-05-05T18:38:56.637867516Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "History book"
},
"name": "book"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:38:57.434600163Z"
}
},
{
"nodeOutputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "modelCompletion"
}],
"nodeName": "Prompt_1",
"timestamp": "2025-05-05T18:39:06.034157077Z"
}
},
{
"nodeInputEvent": {
"fields": [{
"content": {
"document": "Here's a summary of the history book."
},
"name": "document"
}],
"nodeName": "FlowOutputNode",
"timestamp": "2025-05-05T18:39:06.453128251Z"
}
}
]
}
```
**Obtenez un instantané de votre exécution de flux**
Amazon Bedrock prend automatiquement un instantané de la définition et des métadonnées d’un flux lorsqu’une exécution de flux démarre. Cela est utile, car un flux peut être mis à jour lorsqu’il s’exécute de manière asynchrone. Pour récupérer cet instantané, appelez l'[GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)opération. La réponse inclut les champs de flux suivants :
+ **customerEncryptionKeyArn** — L'ARN de la AWS KMS clé qui chiffre le flux.
+ **definition** : [définition](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_FlowDefinition.html) du flux.
+ **executionRoleArn**— L'ARN du rôle de service IAM utilisé par l'exécution du flux.
+ **flowAliasIdentifier**— L'identifiant d'alias du flux.
+ **flowIdentifier** : identifiant du flux.
+ **flowVersion** : version du flux.
```
{
"customerEncryptionKeyArn": null,
"definition": "{flow-definition}",
"executionRoleArn": "arn:aws:iam::111122223333:role/name",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT"
}
```
**Établissement de la liste de vos exécutions de flux**
Vous pouvez obtenir la liste de vos exécutions de flux en appelant l'[ListFlowExecutions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutions.html)opération. La réponse inclut un `flowExecutionSummaries` tableau contenant des informations sur chacune de vos exécutions de flux en cours Région AWS pour un flux ou un alias de flux. Chaque élément inclut des informations telles que l’ARN d’exécution, l’heure de début et le statut actuel du flux.
```
{
"flowExecutionSummaries": [{
"createdAt": "2025-03-11T23:21:02.875598966Z",
"endedAt": null,
"executionArn": "arn:aws:bedrock:us-west-2:111122223333:flow/FLOWID/alias/TSTALIASID/execution/MyExecution",
"flowAliasIdentifier": "TSTALIASID",
"flowIdentifier": "FLOWID",
"flowVersion": "DRAFT",
"status": "Running"
}]
}
```
**Arrêt d’une exécution de flux en cours**
Si vous devez arrêter l'exécution d'un flux en cours, appelez l'[StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)opération et transmettez l'ID de flux, l'ID d'alias de flux et l'ID d'exécution de flux pour l'exécution que vous souhaitez arrêter.
------
## Statuts d’exécution de flux
Une exécution de flux peut avoir l’un des statuts suivants :
+ **En cours** : l’exécution de flux est en cours.
+ **Réussite** : l’exécution de flux s’est terminée avec succès.
+ **Échec** : l’exécution de flux a échoué à cause d’une erreur.
+ **TimedOut**— L'exécution du flux a dépassé le temps d'exécution maximal de 24 heures.
+ **Annulé** — L'exécution du flux a été arrêtée manuellement à l'aide de l'[StopFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_StopFlowExecution.html)opération.
Les exécutions de flux qui ne sont plus en cours sont automatiquement supprimées au bout de 90 jours.
## Bonnes pratiques relatives aux exécutions de flux
Tenez compte des éléments suivants lorsque vous utilisez des exécutions de flux :
+ Interrogez régulièrement l'état d'exécution de votre flux [GetFlowExecution](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetFlowExecution.html)jusqu'à ce que votre flux atteigne un état terminal (qui est autre chose que`Running`).
+ Lorsque l'exécution de votre flux atteint un état terminal, utilisez [ListFlowExecutionEvents](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_ListFlowExecutionEvents.html)pour obtenir les résultats de votre flux. Par exemple, vous pouvez créer une certaine logique autour de votre flux à l’aide de ces résultats.
+ Obtenez un aperçu de l'exécution de votre flux [GetExecutionFlowSnapshot](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_GetExecutionFlowSnapshot.html)à l'aide du débogage si des problèmes surviennent lors de l'exécution.
# Déploiement d’un flux dans votre application à l’aide de versions et d’alias
Lorsque vous créez un flux pour la première fois, une version préliminaire (`DRAFT`) et un alias de test (`TSTALIASID`) qui pointe vers la version préliminaire sont créés. Lorsque vous apportez des modifications à votre flux, celles-ci s’appliquent à la version préliminaire. Il s’agit donc de la version la plus récente de votre flux. Vous itérez sur votre version préliminaire jusqu’à ce que le comportement de votre flux vous convienne. Vous pouvez ensuite configurer votre flux à des fins de déploiement en créant des *versions* de votre flux.
Une *version* est un instantané qui préserve la ressource telle qu’elle est au moment de sa création. Vous pouvez continuer à modifier la version préliminaire et créer des versions de votre flux si nécessaire. Amazon Bedrock crée des versions par ordre numérique, en commençant par 1. Les versions sont immuables, car elles font office d’instantané de votre flux au moment de sa création. Pour mettre à jour un flux que vous avez déployé en production, vous devez créer une version à partir de la version préliminaire et effectuer des appels à l’alias qui pointe vers cette version.
Pour déployer votre flux, vous devez créer un *alias* qui pointe vers une version de votre flux. Ensuite, vous envoyez des demandes `InvokeFlow` à cet alias. Grâce aux alias, vous pouvez passer efficacement d’une version à l’autre de votre flux sans effectuer le suivi de la version. Par exemple, vous pouvez modifier un alias afin qu’il pointe vers une version précédente de votre flux si des modifications doivent être annulées rapidement.
Les rubriques suivantes décrivent comment créer des versions et des alias de votre flux.
**Topics**
+ [Création d’une version d’un flux dans Amazon Bedrock](flows-version-create.md)
+ [Affichage d’informations sur les versions de flux dans Amazon Bedrock](flows-version-view.md)
+ [Suppression d’une version d’un flux dans Amazon Bedrock](flows-version-delete.md)
+ [Création d’un alias d’un flux dans Amazon Bedrock](flows-alias-create.md)
+ [Affichage d’informations sur les alias de flux dans Amazon Bedrock](flows-alias-view.md)
+ [Modification d’un alias d’un flux dans Amazon Bedrock](flows-alias-modify.md)
+ [Suppression d’un alias d’un flux dans Amazon Bedrock](flows-alias-delete.md)
# Création d’une version d’un flux dans Amazon Bedrock
Une fois que la configuration de votre flux vous convient, créez une version immuable du flux vers laquelle vous pouvez pointer avec un alias. Pour découvrir comment créer une version de votre flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour créer une version de vos flux Amazon Bedrock**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Choisissez ensuite un flux dans la section **Flux Amazon Bedrock**.
1. Dans la section **Versions**, cliquez sur **Publier la version**.
1. Une fois la version publiée, une bannière de réussite s’affiche en haut.
------
#### [ API ]
Pour supprimer un flux, envoyez une demande [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`.
La réponse renvoie un identifiant et un ARN pour la version. Les versions sont créées de manière incrémentielle, en commençant par 1.
------
# Affichage d’informations sur les versions de flux dans Amazon Bedrock
Pour découvrir comment afficher des informations sur les versions d’un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour afficher des informations sur une version d’un flux**
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Bedrock.
1. Sélectionnez **Flux** dans le volet de navigation gauche. Ensuite, dans la section **Flux**, sélectionnez le flux que vous souhaitez afficher.
1. Sélectionnez la version à afficher dans la section **Versions**.
1. Pour afficher des détails sur les nœuds et configurations attachés à la version du flux, sélectionnez le nœud et affichez les détails dans le volet **Créateur de flux**. Pour apporter des modifications au flux, utilisez la version préliminaire et créez une version.
------
#### [ API ]
Pour obtenir des informations sur une version de votre flux, envoyez une demande [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`. Dans le champ `flowVersion`, spécifiez le numéro de version.
Pour répertorier des informations sur toutes les versions d’un flux, envoyez une demande [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`. Vous pouvez préciser les paramètres facultatifs suivants :
****
| Champ | Description abrégée |
| --- | --- |
| maxResults | Nombre maximum de résultats à renvoyer en réponse. |
| nextToken | Si le nombre de résultats est supérieur à ce que vous avez spécifié dans le champ maxResults, la réponse renvoie une valeur nextToken. Pour voir le prochain lot de résultats, envoyez la valeur nextToken dans une autre demande. |
------
# Suppression d’une version d’un flux dans Amazon Bedrock
Pour découvrir comment supprimer une version d’un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour supprimer une version d’un flux**
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Bedrock.
1. Sélectionnez **Flux** dans le volet de navigation gauche. Ensuite, dans la section **Flux**, sélectionnez un flux.
1. Sélectionnez **Supprimer**.
1. Une boîte de dialogue s’affiche alors pour vous avertir des conséquences de la suppression. Pour confirmer que vous souhaitez supprimer la version, saisissez **delete** dans le champ de saisie, puis cliquez sur **Supprimer**.
1. Une bannière s’affiche alors pour vous informer que la version est en cours de suppression. Une fois la suppression terminée, une bannière de réussite s’affiche.
------
#### [ API ]
Pour supprimer une version d’un flux, envoyez une demande [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Spécifiez l’ARN ou l’identifiant du flux dans le champ `flowIdentifier` et la version à supprimer dans le champ `flowVersion`.
------
# Création d’un alias d’un flux dans Amazon Bedrock
Pour invoquer un flux, vous devez d’abord créer un alias qui pointe vers une version du flux. Pour découvrir comment créer un alias, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour créer un alias pour vos flux Amazon Bedrock**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Choisissez ensuite un flux dans la section **Flux**.
1. Dans la section **Alias**, cliquez sur **Créer un alias**.
1. Saisissez un nom unique pour l’alias et fournissez une description facultative.
1. Choisissez l’une des options suivantes :
+ Pour créer une version, choisissez **Créer une version et l’associer à cet alias**.
+ Pour utiliser une version existante, choisissez **Utiliser une version existante à associer à cet alias**. Dans le menu déroulant, choisissez la version à laquelle vous souhaitez associer l’alias.
1. Cliquez sur **Créer un alias**. Une bannière de réussite s’affiche en haut.
------
#### [ API ]
Pour créer un alias afin de pointer vers une version de votre flux, envoyez une demande [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt).
Les champs suivants sont obligatoires :
****
| Champ | Description de base |
| --- | --- |
| flowIdentifier | ARN ou identifiant du flux pour lequel créer un alias. |
| name | Nom de l’alias. |
| routingConfiguration | Spécifiez la version à laquelle mapper l’alias dans le champ flowVersion. |
Les champs suivants sont facultatifs :
****
| Champ | Cas d’utilisation |
| --- | --- |
| description | Permet de fournir une description de l’alias. |
| clientToken | Permet d’empêcher la duplication de la demande. |
------
La création d’un alias produit une ressource avec un identifiant et un Amazon Resource Name (ARN) que vous pouvez spécifier lorsque vous invoquez un flux depuis votre application. Pour découvrir comment invoquer un flux, consultez [Test d’un flux dans Amazon Bedrock](flows-test.md).
# Affichage d’informations sur les alias de flux dans Amazon Bedrock
Pour découvrir comment afficher des informations sur les alias d’un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour afficher les détails d’un alias**
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Bedrock.
1. Sélectionnez **Flux** dans le volet de navigation gauche. Ensuite, dans la section **Flux**, sélectionnez un flux.
1. Choisissez l’alias à afficher dans la section **Alias**.
1. Vous pouvez consulter le nom et la description de l’alias ainsi que les balises associées à l’alias.
------
#### [ API ]
Pour obtenir des informations sur un alias de votre flux, envoyez une demande [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`. Dans le champ `aliasIdentifier`, spécifiez l’identifiant ou l’ARN de l’alias.
Pour répertorier des informations sur tous les alias d’un flux, envoyez une demande [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`. Vous pouvez préciser les paramètres facultatifs suivants :
****
| Champ | Description abrégée |
| --- | --- |
| maxResults | Nombre maximum de résultats à renvoyer en réponse. |
| nextToken | Si le nombre de résultats est supérieur à ce que vous avez spécifié dans le champ maxResults, la réponse renvoie une valeur nextToken. Pour voir le prochain lot de résultats, envoyez la valeur nextToken dans une autre demande. |
------
# Modification d’un alias d’un flux dans Amazon Bedrock
Pour découvrir comment modifier un alias d’un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour modifier un alias**
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Bedrock.
1. Sélectionnez **Flux** dans le volet de navigation gauche. Ensuite, dans la section **Flux**, sélectionnez un flux.
1. Dans la section **Alias**, cliquez sur la case d’option en regard de l’alias que vous souhaitez modifier.
1. Vous pouvez modifier le nom et la description de l’alias. En outre, vous pouvez effectuer l’une des actions suivantes :
+ Pour créer une version et associer cet alias à cette version, cliquez sur **Créer une version et l’associer à cet alias**.
+ Pour associer cet alias à une autre version existante, cliquez sur **Utiliser une version existante et l’associer à cet alias**.
1. Cliquez sur **Enregistrer**.
------
#### [ API ]
Pour mettre à jour un alias, envoyez une demande [UpdateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_UpdateFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Incluez les champs que vous souhaitez conserver et ceux que vous souhaitez modifier dans la demande.
------
# Suppression d’un alias d’un flux dans Amazon Bedrock
Pour découvrir comment supprimer un alias d’un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour supprimer un alias**
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Bedrock.
1. Sélectionnez **Flux** dans le volet de navigation gauche. Ensuite, dans la section **Flux**, sélectionnez un flux.
1. Pour choisir l’alias que vous souhaitez supprimer, dans la section **Alias**, cliquez sur la case d’option en regard de l’alias que vous souhaitez supprimer.
1. Sélectionnez **Supprimer**.
1. Une boîte de dialogue s’affiche alors pour vous avertir des conséquences de la suppression. Pour confirmer que vous souhaitez supprimer l’alias, saisissez **delete** dans le champ de saisie, puis choisissez **Supprimer**.
1. Une bannière s’affiche alors pour vous informer que l’alias est en cours de suppression. Une fois la suppression terminée, une bannière de réussite s’affiche.
------
#### [ API ]
Pour supprimer un alias de flux, envoyez une demande [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Spécifiez l’ARN ou l’identifiant du flux dans le champ `flowIdentifier` et l’ARN ou l’identifiant de l’alias à supprimer dans le champ `aliasIdentifier`.
------
# Invoquer une AWS Lambda fonction depuis un flux Amazon Bedrock dans un autre compte AWS
Un flux Amazon Bedrock peut invoquer une AWS Lambda fonction qui se trouve dans un AWS compte différent de celui du flux. Configurez la fonction Lambda (*compte A*) et le flux (*compte B*) à l’aide de la procédure suivante.
**Pour configurer un flux de flux afin d'appeler une fonction Lambda dans un autre compte AWS**
1. Dans le compte A (fonction Lambda), ajoutez une politique basée sur les ressources à la fonction Lambda, en utilisant le rôle d’exécution du flux du compte B comme principal. Pour plus d’informations, consultez [Octroi d’un accès à la fonction Lambda à d’autres comptes](https://docs.aws.amazon.com/lambda/latest/dg/permissions-function-cross-account.html) dans la documentation *AWS Lambda*.
1. Dans le compte B (flux Amazon Bedrock), ajoutez l’autorisation pour l’opération d’[invocation](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) au rôle d’exécution du flux pour l’ARN de la fonction Lambda que vous utilisez. Pour plus d’informations, consultez [Mettre à jour les autorisations pour un rôle](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) dans la documentation *Gestion des identités et des accès AWS*.
# Conversation avec un flux Amazon Bedrock
**Note**
La conversation à plusieurs tours Amazon Bedrock Flows est en version préliminaire pour Amazon Bedrock et susceptible d’être modifiée.
La conversation à plusieurs tours Amazon Bedrock Flows permet back-and-forth des conversations dynamiques entre les utilisateurs et les flux, comme dans le cas d'un dialogue naturel. Lorsqu’un nœud d’agent a besoin de précisions ou de contexte supplémentaire, il peut suspendre intelligemment l’exécution du flux et demander des informations spécifiques à l’utilisateur. Cela crée une expérience plus interactive et plus contextuelle, car le nœud peut adapter son comportement en fonction des réponses utilisateur. Par exemple, si la requête utilisateur initiale est ambiguë ou incomplète, le nœud peut poser des questions complémentaires pour recueillir les informations nécessaires. Une fois que l’utilisateur a fourni les informations demandées, le flux reprend facilement son exécution avec l’entrée enrichie, garantissant ainsi des résultats plus précis et plus pertinents. Cette fonctionnalité est particulièrement utile pour les scénarios complexes dans lesquels une seule interaction peut ne pas être suffisante pour bien comprendre les besoins de l’utilisateur et y répondre pleinement.
**Topics**
+ [Traitement d’une conversation à plusieurs tours dans un flux](#flows-multi-turn-invocation-how)
+ [Création et exécution d’un exemple de flux](#flows-multi-turn-invocation-example-flow)
## Traitement d’une conversation à plusieurs tours dans un flux
Pour utiliser une conversation à plusieurs tours dans un flux, vous avez besoin d’un [nœud d’agent](flows-nodes.md#flows-nodes-agent) connecté à un agent Amazon Bedrock. Lorsque vous exécutez le flux, une conversation à plusieurs tours a lieu lorsque l’agent a besoin d’informations supplémentaires de la part de l’utilisateur avant de pouvoir continuer. Cette section décrit un flux qui utilise un agent avec les instructions suivantes :
```
You are a playlist creator for a radio station.
When asked to create a playlist, ask for the number of songs,
the genre of music, and a theme for the playlist.
```
Pour plus d’informations sur la création d’un agent, consultez [Automatisation des tâches de votre application à l’aide d’agents d’IA](agents.md).
### Étape 1 : démarrage du flux
Vous démarrez un flux en appelant l'[InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html)opération. Vous incluez le contenu initial que vous souhaitez envoyer au flux. Dans l’exemple suivant, le champ `document` contient une demande de *création d’une liste de lecture*. Chaque conversation possède un identifiant unique (*identifiant d’exécution*) qui l’identifie au sein du flux. Pour obtenir l’identifiant d’exécution, vous n’envoyez pas le champ `executionID` lors de votre premier appel à l’opération `InvokeFlow`. La réponse de l’opération `InvokeFlow` inclut l’identifiant d’exécution. Dans votre code, suivez plusieurs conversations et identifiez une conversation lors d’appels ultérieurs à l’opération `InvokeFlow` à l’aide de l’identifiant.
Voici un exemple de code JSON pour une demande envoyée à l’opération `InvokeFlow` :
```
{
"flowIdentifier": "XXXXXXXXXX",
"flowAliasIdentifier": "YYYYYYYYYY",
"inputs": [
{
"content": {
"document": "Create a playlist."
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
]
}
```
### Étape 2 : récupération des demandes d’agent
Si le nœud d’agent du flux décide qu’il a besoin d’informations supplémentaires de la part de l’utilisateur, le flux de réponse (`responseStream`) de l’opération `InvokeFlow` inclut un objet d’événement `FlowMultiTurnInputRequestEvent`. L’événement comporte les informations demandées dans le champ `content` (`FlowMultiTurnInputContent`). Dans l’exemple suivant, la demande dans le champ `document` concerne des informations sur le nombre de chansons, le genre musical et le thème de la liste de lecture. Dans votre code, vous devez ensuite obtenir ces informations auprès de l’utilisateur.
Voici un exemple d’objet JSON `FlowMultiTurnInputRequestEvent` :
```
{
"nodeName": "AgentsNode_1",
"nodeType": "AgentNode",
"content": {
"document": "Certainly! I'd be happy to create a playlist for you. To make sure it's tailored to your preferences, could you please provide me with the following information:
1. How many songs would you like in the playlist?
2. What genre of music do you prefer?
3. Is there a specific theme or mood you'd like for the playlist? Once you provide these details, I'll be able to create a customized playlist just for you."
}
}
```
Comme le flux ne peut pas continuer tant que d’autres entrées ne sont pas reçues, il émet également un événement `FlowCompletionEvent`. Un flux émet toujours l’événement `FlowMultiTurnInputRequestEvent` avant l’événement `FlowCompletionEvent`. Si la valeur du paramètre `completionReason` de l’événement `FlowCompletionEvent` est `INPUT_REQUIRED`, le flux a besoin d’informations supplémentaires avant de pouvoir continuer.
Voici un exemple d’objet JSON `FlowCompletionEvent` :
```
{
"completionReason": "INPUT_REQUIRED"
}
```
### Étape 3 : envoi de la réponse utilisateur au flux
Renvoyez la réponse utilisateur au flux en appelant à nouveau l’opération `InvokeFlow`. Veillez à inclure l’`executionId` pour la conversation.
Voici un exemple de code JSON pour la demande envoyée à l’opération `InvokeFlow` : Le champ `document` contient la réponse de l’utilisateur.
```
{
"flowIdentifier": "AUS7BMHXBE",
"flowAliasIdentifier": "4KUDB8VBEF",
"executionId": "b6450554-f8cc-4934-bf46-f66ed89b60a0",
"inputs": [
{
"content": {
"document": "1. 5 songs 2. Welsh rock music 3. Castles"
},
"nodeName": "AgentsNode_1",
"nodeInputName": "agentInputText"
}
]
}
```
Si le flux a besoin d’informations supplémentaires, il crée d’autres événements `FlowMultiTurnInputRequestEvent`.
### Étape 4 : achèvement du flux
Lorsqu’aucune information supplémentaire n’est nécessaire, le flux émet un événement `FlowOutputEvent` qui contient la réponse finale.
Voici un exemple d’objet JSON `FlowOutputEvent` :
```
{
"nodeName": "FlowOutputNode",
"content": {
"document": "Great news! I've created a 5-song Welsh rock playlist centered around the theme of castles.
Here's the playlist I've put together for you: Playlist Name: Welsh Rock Castle Anthems
Description: A 5-song Welsh rock playlist featuring songs about castles
Songs:
1. Castell y Bere - Super Furry Animals
2. The Castle - Manic Street Preachers
3. Caerdydd (Cardiff Castle) - Stereophonics
4. Castell Coch - Catatonia
5. Chepstow Castle - Feeder
This playlist combines Welsh rock bands with songs that reference castles or specific Welsh castles.
Enjoy your castle-themed Welsh rock music experience!"
}
}
```
Le flux émet également un événement `FlowCompletionEvent`. La valeur du paramètre `completionReason` est `SUCCESS`.
Voici un exemple d’objet JSON `FlowCompletionEvent` :
```
{
"completionReason": "SUCCESS"
}
```
Le diagramme de séquence suivant montre les étapes d’un flux à plusieurs tours.
![\[Étapes d’un flux pour une conversation à plusieurs tours.\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-multi-turn-steps.png)
## Création et exécution d’un exemple de flux
Dans cet exemple, vous allez créer un flux qui crée des listes de lecture pour une station de radio à l’aide d’un agent. L’agent pose des questions de clarification pour déterminer le nombre de chansons, le genre musical et le thème de la liste de lecture.
**Pour créer le flux**
1. Créez un agent dans la console Amazon Bedrock en suivant les instructions sous [Création et configuration manuelles de l’agent](agents-create.md).
+ Pour l’étape *2.d*, saisissez **You are a playlist creator for a radio station. When asked to create a playlist, ask for the number of songs, the genre of music, and a theme for the playlist.**
+ Pour l’étape *2.e*, choisissez **Activé** dans **Entrée utilisateur**. Ainsi, l’agent peut demander des informations supplémentaires, si nécessaire.
1. Créez le flux en suivant les instructions sous [Création et conception d’un flux dans Amazon Bedrock](flows-create.md). Assurez-vous que le flux possède un nœud d’entrée, un nœud d’agent et un nœud de sortie.
1. Liez le nœud d’agent à l’agent que vous avez créé à l’étape 1. Le flux devrait ressembler à l’image suivante :
![\[Conversation à plusieurs tours de flux\]](http://docs.aws.amazon.com/fr_fr/bedrock/latest/userguide/images/flows/flows-multi-turn.png)
1. Exécutez le flux dans la console Amazon Bedrock. Pour les tests, vous pouvez suivre les étapes effectuées par le flux. Pour de plus amples informations, veuillez consulter [Test d’un flux dans Amazon Bedrock](flows-test.md).
L’exemple de code Python suivant montre comment utiliser le flux.
Pour exécuter le code, spécifiez les éléments suivants :
+ `region_name`— La AWS région dans laquelle vous exécutez le flux.
+ `FLOW_ID` : identifiant du flux.
+ `FLOW_ALIAS_ID` : identifiant de l’alias du flux.
Pour plus d'informations sur l'obtention du IDs, voir[Affichage d’informations sur les flux dans Amazon Bedrock](flows-view.md). Le code invite à envoyer une demande initiale au flux et demande des entrées supplémentaires selon les besoins du flux. Le code ne gère pas les autres demandes de l'agent, telles que les demandes d'appel de AWS Lambda fonctions. Pour de plus amples informations, veuillez consulter [Fonctionnement des agents Amazon Bedrock](agents-how.md). Pendant l’exécution, le code génère des objets `FlowTraceEvent` vous permettant de suivre le chemin entre l’entrée et la réponse renvoyée par le flux. Pour de plus amples informations, veuillez consulter [Suivi de chaque étape de votre flux en consultant sa trace dans Amazon BedrockSuivi de chaque étape de votre flux en consultant sa trace](flows-trace.md).
```
"""
Runs an Amazon Bedrock flow and handles muli-turn interaction for a single conversation.
"""
import logging
import boto3
import botocore
import botocore.exceptions
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def invoke_flow(client, flow_id, flow_alias_id, input_data, execution_id):
"""
Invoke an Amazon Bedrock flow and handle the response stream.
Args:
client: Boto3 client for Amazon Bedrock agent runtime
flow_id: The ID of the flow to invoke
flow_alias_id: The alias ID of the flow
input_data: Input data for the flow
execution_id: Execution ID for continuing a flow. Use the value None on first run.
Returns:
Dict containing flow_complete status, input_required info, and execution_id
"""
response = None
request_params = None
if execution_id is None:
# Don't pass execution ID for first run.
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"inputs": [input_data],
"enableTrace": True
}
else:
request_params = {
"flowIdentifier": flow_id,
"flowAliasIdentifier": flow_alias_id,
"executionId": execution_id,
"inputs": [input_data],
"enableTrace": True
}
response = client.invoke_flow(**request_params)
if "executionId" not in request_params:
execution_id = response['executionId']
input_required = None
flow_status = ""
# Process the streaming response
for event in response['responseStream']:
# Check if flow is complete.
if 'flowCompletionEvent' in event:
flow_status = event['flowCompletionEvent']['completionReason']
# Check if more input us needed from user.
elif 'flowMultiTurnInputRequestEvent' in event:
input_required = event
# Print the model output.
elif 'flowOutputEvent' in event:
print(event['flowOutputEvent']['content']['document'])
elif 'flowTraceEvent' in event:
logger.info("Flow trace: %s", event['flowTraceEvent'])
return {
"flow_status": flow_status,
"input_required": input_required,
"execution_id": execution_id
}
if __name__ == "__main__":
session = boto3.Session(profile_name='default', region_name='YOUR_FLOW_REGION')
bedrock_agent_client = session.client('bedrock-agent-runtime')
# Replace these with your actual flow ID and alias ID
FLOW_ID = 'YOUR_FLOW_ID'
FLOW_ALIAS_ID = 'YOUR_FLOW_ALIAS_ID'
flow_execution_id = None
finished = False
# Get the intial prompt from the user.
user_input = input("Enter input: ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": "FlowInputNode",
"nodeOutputName": "document"
}
logger.info("Starting flow %s", FLOW_ID)
try:
while not finished:
# Invoke the flow until successfully finished.
result = invoke_flow(
bedrock_agent_client, FLOW_ID, FLOW_ALIAS_ID, flow_input_data, flow_execution_id)
status = result['flow_status']
flow_execution_id = result['execution_id']
more_input = result['input_required']
if status == "INPUT_REQUIRED":
# The flow needs more information from the user.
logger.info("The flow %s requires more input", FLOW_ID)
user_input = input(
more_input['flowMultiTurnInputRequestEvent']['content']['document'] + ": ")
flow_input_data = {
"content": {
"document": user_input
},
"nodeName": more_input['flowMultiTurnInputRequestEvent']['nodeName'],
"nodeInputName": "agentInputText"
}
elif status == "SUCCESS":
# The flow completed successfully.
finished = True
logger.info("The flow %s successfully completed.", FLOW_ID)
except botocore.exceptions.ClientError as e:
print(f"Client error: {str(e)}")
logger.error("Client error: %s", {str(e)})
except Exception as e:
print(f"An error occurred: {str(e)}")
logger.error("An error occurred: %s", {str(e)})
logger.error("Error type: %s", {type(e)})
```
# Exécution d’exemples de code Amazon Bedrock Flows
Les exemples de code suivants supposent que vous avez rempli les conditions préalables suivantes :
1. Configurez un rôle afin qu’il soit autorisé à effectuer des actions Amazon Bedrock. Si vous ne l’avez pas encore fait, consultez [Démarrage rapide](getting-started.md).
1. Configurez vos informations d’identification pour utiliser l’API AWS. Si vous ne l’avez pas encore fait, consultez [Démarrage avec l’API](getting-started-api.md).
1. Créez un rôle de service afin qu’il effectue des actions liées aux flux en votre nom. Si vous ne l’avez pas encore fait, consultez [Création d’un rôle de service pour Amazon Bedrock Flows dans Amazon Bedrock](flows-permissions.md).
Pour créer un flux, envoyez une demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Pour obtenir un exemple de code, consultez [Exécution d’exemples de code Amazon Bedrock Flows](#flows-code-ex)
Les champs suivants sont obligatoires :
****
| Champ | Description de base |
| --- | --- |
| name | Nom du flux. |
| executionRoleArn | ARN du [rôle de service doté des autorisations nécessaires pour créer et gérer des flux](flows-permissions.md). |
Les champs suivants sont facultatifs :
****
| Champ | Cas d’utilisation |
| --- | --- |
| definition | Contient les nodes et connections qui constituent le flux. |
| description | Permet de décrire le flux. |
| tags | Pour associer des balises au flux. Pour plus d’informations, consultez [Balisage des ressources Amazon Bedrock](tagging.md). |
| customerEncryptionKeyArn | Permet de chiffrer la ressource avec une clé KMS. Pour plus d’informations, consultez [Chiffrement des ressources Amazon Bedrock Flows](encryption-flows.md). |
| clientToken | Pour garantir que la demande d’API n’est exécutée qu’une seule fois. Pour plus d’informations, consultez [Garantie de l’idempotence](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). |
Bien que le champ `definition` soit facultatif, il est obligatoire afin que le flux soit fonctionnel. Vous pouvez choisir de créer un flux sans la définition au préalable et de le mettre à jour ultérieurement.
Pour chaque nœud de votre liste `nodes`, vous spécifiez le type de nœud dans le champ `type` et fournissez la configuration correspondante du nœud dans le champ `config`. Pour plus de détails sur la structure d’API des différents types de nœuds, consultez [Types de nœuds pour votre flux](flows-nodes.md).
Pour tester des exemples de code pour Amazon Bedrock Flows, choisissez l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Python ]
1. Créez un flux à l’aide d’une demande [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) avec les nœuds suivants :
+ Un nœud d’entrée
+ Un nœud d’invite avec une invite définie inline qui crée une liste de lecture musicale à l’aide de deux variables (`genre` et `number`)
+ Un nœud de sortie qui renvoie l’achèvement du modèle
Exécutez l’extrait de code suivant pour charger le kit AWS SDK pour Python (Boto3), créer un client pour agents Amazon Bedrock et créer un flux avec les nœuds (Remplacez le champ `executionRoleArn` par l’ARN du rôle de service que vous avez créé pour le flux.) :
```
# Import Python SDK and create client
import boto3
client = boto3.client(service_name='bedrock-agent')
# Replace with the service role that you created. For more information, see https://docs.aws.amazon.com/bedrock/latest/userguide/flows-permissions.html
FLOWS_SERVICE_ROLE = "arn:aws:iam::123456789012:role/MyFlowsRole"
# Define each node
# The input node validates that the content of the InvokeFlow request is a JSON object.
input_node = {
"type": "Input",
"name": "FlowInput",
"outputs": [
{
"name": "document",
"type": "Object"
}
]
}
# This prompt node defines an inline prompt that creates a music playlist using two variables.
# 1. {{genre}} - The genre of music to create a playlist for
# 2. {{number}} - The number of songs to include in the playlist
# It validates that the input is a JSON object that minimally contains the fields "genre" and "number", which it will map to the prompt variables.
# The output must be named "modelCompletion" and be of the type "String".
prompt_node = {
"type": "Prompt",
"name": "MakePlaylist",
"configuration": {
"prompt": {
"sourceConfiguration": {
"inline": {
"modelId": "amazon.nova-lite-v1:0",
"templateType": "TEXT",
"inferenceConfiguration": {
"text": {
"temperature": 0.8
}
},
"templateConfiguration": {
"text": {
"text": "Make me a {{genre}} playlist consisting of the following number of songs: {{number}}."
}
}
}
}
}
},
"inputs": [
{
"name": "genre",
"type": "String",
"expression": "$.data.genre"
},
{
"name": "number",
"type": "Number",
"expression": "$.data.number"
}
],
"outputs": [
{
"name": "modelCompletion",
"type": "String"
}
]
}
# The output node validates that the output from the last node is a string and returns it as is. The name must be "document".
output_node = {
"type": "Output",
"name": "FlowOutput",
"inputs": [
{
"name": "document",
"type": "String",
"expression": "$.data"
}
]
}
# Create connections between the nodes
connections = []
# First, create connections between the output of the flow input node and each input of the prompt node
for input in prompt_node["inputs"]:
connections.append(
{
"name": "_".join([input_node["name"], prompt_node["name"], input["name"]]),
"source": input_node["name"],
"target": prompt_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": input_node["outputs"][0]["name"],
"targetInput": input["name"]
}
}
}
)
# Then, create a connection between the output of the prompt node and the input of the flow output node
connections.append(
{
"name": "_".join([prompt_node["name"], output_node["name"]]),
"source": prompt_node["name"],
"target": output_node["name"],
"type": "Data",
"configuration": {
"data": {
"sourceOutput": prompt_node["outputs"][0]["name"],
"targetInput": output_node["inputs"][0]["name"]
}
}
}
)
# Create the flow from the nodes and connections
response = client.create_flow(
name="FlowCreatePlaylist",
description="A flow that creates a playlist given a genre and number of songs to include in the playlist.",
executionRoleArn=FLOWS_SERVICE_ROLE,
definition={
"nodes": [input_node, prompt_node, output_node],
"connections": connections
}
)
flow_id = response.get("id")
```
1. Répertoriez les flux de votre compte, y compris celui que vous venez de créer, en exécutant l’extrait de code suivant pour effectuer une demande [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.list_flows()
```
1. Obtenez des informations sur le flux que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.get_flow(flowIdentifier=flow_id)
```
1. Préparez votre flux de sorte que les modifications les plus récentes de la version préliminaire soient appliquées et qu’il soit prêt à être versionné. Exécutez l’extrait de code suivant pour effectuer une demande [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.prepare_flow(flowIdentifier=flow_id)
```
1. Versionnez la version préliminaire de votre flux pour créer un instantané statique de votre flux, puis récupérez les informations le concernant à l’aide des actions suivantes :
1. Créez une version en exécutant l’extrait de code suivant pour effectuer une demande [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
response = client.create_flow_version(flowIdentifier=flow_id)
flow_version = response.get("version")
```
1. Répertoriez toutes les versions de votre flux en exécutant l’extrait de code suivant pour effectuer une demande [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.list_flow_versions(flowIdentifier=flow_id)
```
1. Obtenez des informations sur la version en exécutant l’extrait de code suivant pour effectuer une demande [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.get_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Créez un alias pour pointer vers la version de votre flux que vous avez créée, puis récupérez les informations le concernant à l’aide des actions suivantes :
1. Créez un alias et pointez-le vers la version que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
response = client.create_flow_alias(
flowIdentifier=flow_id,
name="latest",
description="Alias pointing to the latest version of the flow.",
routingConfiguration=[
{
"flowVersion": flow_version
}
]
)
flow_alias_id = response.get("id")
```
1. Répertoriez tous les alias de votre flux en exécutant l’extrait de code suivant pour effectuer une demande [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.list_flow_aliases(flowIdentifier=flow_id)
```
1. Obtenez des informations sur l’alias que vous venez de créer en exécutant l’extrait de code suivant pour effectuer une demande [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.get_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Exécutez l’extrait de code suivant pour créer un client d’exécution pour agents Amazon Bedrock et invoquer un flux. La demande renseigne les variables de l’invite de votre flux et renvoie la réponse du modèle pour effectuer une demande [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) avec un [point de terminaison d’exécution des agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-rt) :
```
client_runtime = boto3.client('bedrock-agent-runtime')
response = client_runtime.invoke_flow(
flowIdentifier=flow_id,
flowAliasIdentifier=flow_alias_id,
inputs=[
{
"content": {
"document": {
"genre": "pop",
"number": 3
}
},
"nodeName": "FlowInput",
"nodeOutputName": "document"
}
]
)
result = {}
for event in response.get("responseStream"):
result.update(event)
if result['flowCompletionEvent']['completionReason'] == 'SUCCESS':
print("Flow invocation was successful! The output of the flow is as follows:\n")
print(result['flowOutputEvent']['content']['document'])
else:
print("The flow invocation completed because of the following reason:", result['flowCompletionEvent']['completionReason'])
```
La réponse devrait renvoyer une liste de lecture de musique pop avec trois chansons.
1. Supprimez l’alias, la version et le flux que vous avez créés à l’aide des actions suivantes :
1. Supprimez l’alias en exécutant l’extrait de code suivant pour effectuer une demande [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.delete_flow_alias(flowIdentifier=flow_id, aliasIdentifier=flow_alias_id)
```
1. Supprimez la version en exécutant l’extrait de code suivant pour effectuer une demande [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.delete_flow_version(flowIdentifier=flow_id, flowVersion=flow_version)
```
1. Supprimez le flux en exécutant l’extrait de code suivant pour effectuer une demande [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) :
```
client.delete_flow(flowIdentifier=flow_id)
```
------
# Suppression d’un flux dans Amazon Bedrock
Si vous n’avez plus besoin d’un flux, vous pouvez le supprimer. Les flux que vous supprimez sont conservés sur les serveurs AWS pendant une durée maximale de quatorze jours. Pour découvrir comment supprimer un flux, cliquez sur l’onglet correspondant à votre méthode préférée, puis suivez les étapes :
------
#### [ Console ]
**Pour supprimer un flux**
1. Connectez-vous à la AWS Management Console avec une identité IAM autorisée à utiliser la console Amazon Bedrock. Ensuite, ouvrez la console Amazon Bedrock à l’adresse [https://console.aws.amazon.com/bedrock](https://console.aws.amazon.com/bedrock).
1. Sélectionnez **Flux Amazon Bedrock** dans le volet de navigation gauche. Ensuite, dans la section **Flux Amazon Bedrock**, sélectionnez le flux à supprimer.
1. Sélectionnez **Supprimer**.
1. Une boîte de dialogue s’affiche alors pour vous avertir des conséquences de la suppression. Pour confirmer que vous souhaitez supprimer le flux, saisissez **delete** dans le champ de saisie, puis choisissez **Supprimer**.
1. Une bannière s’affiche alors pour vous informer que le flux est en cours de suppression. Une fois la suppression terminée, une bannière de réussite s’affiche.
------
#### [ API ]
Pour supprimer un flux, envoyez une demande [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) avec un [point de terminaison de compilation pour agents Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) et spécifiez l’ARN ou l’identifiant du flux comme `flowIdentifier`.
------