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.

# Exécution d’exemples de code Amazon Bedrock Flows
<a name="flows-code-ex"></a>

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)
      ```

------