

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Ejecución de ejemplos de código de Flujos de Amazon Bedrock
<a name="flows-code-ex"></a>

En los siguientes ejemplos de código se supone que cumple los siguientes requisitos previos:

1. Configurar un rol para tener permisos para las acciones de Amazon Bedrock. Si no lo tiene, consulte [Inicio rápido](getting-started.md).

1. Configurar las credenciales para usar la API de AWS. Si no lo tiene, consulte [Introducción a la API](getting-started-api.md).

1. Crear un rol de servicio para que realice las acciones relacionadas con el flujo en su nombre. Si no lo tiene, consulte [Creación de un rol de servicio para Flujos de Amazon Bedrock en Amazon Bedrock](flows-permissions.md).

Para crear un flujo, envíe una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Para ver el código de ejemplo, consulte [Ejecución de ejemplos de código de Flujos de Amazon Bedrock](#flows-code-ex)

Los siguientes campos son obligatorios:


****  

| Campo | Descripción básica | 
| --- | --- | 
| nombre | Nombre para el flujo | 
| executionRoleArn | ARN del [rol de servicio con permisos para crear y administrar flujos](flows-permissions.md) | 

Los siguientes campos son opcionales:


****  

| Campo | Caso de uso | 
| --- | --- | 
| definición | Contiene los nodes y connections que componen el flujo. | 
| description | Para describir el flujo. | 
| etiquetas | Para asociar etiquetas con el flujo. Para obtener más información, consulte [Etiquetado de los recursos de Amazon Bedrock](tagging.md). | 
| customerEncryptionKeyArn | Cifrar el recurso con una clave de KMS. Para obtener más información, consulte [Cifrado de los recursos de Flujos de Amazon Bedrock](encryption-flows.md). | 
| clientToken | Para garantizar que la solicitud de la API se complete solo una vez. Para obtener más información, consulte [Ensuring idempotency](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). | 

Si bien el campo `definition` es opcional, es necesario para que el flujo funcione. Puede optar por crear primero un flujo sin la definición y actualizar el flujo más adelante.

Para cada nodo de la lista de `nodes`, especifique el tipo de nodo en el campo `type` y proporcione la configuración correspondiente del nodo en el campo `config`. Para obtener más información sobre la estructura de API de los distintos tipos de nodo, consulte [Tipos de nodos para el flujo](flows-nodes.md).

Para probar algunos ejemplos de código para Flujos de Amazon Bedrock, seleccione la pestaña correspondiente al método que prefiera y siga los pasos:

------
#### [ Python ]

1. Cree un flujo con una solicitud [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) con los siguientes nodos:
   + un nodo de entrada,
   + un nodo de petición con una petición definida en línea que crea una lista de reproducción de música con dos variables (`genre` y `number`),
   + un nodo de salida que devuelva la finalización del modelo.

   Ejecute el siguiente fragmento de código para cargar AWS SDK para Python (Boto3), crear un cliente de Agentes para Amazon Bedrock y crear un flujo con los nodos (sustituya el campo `executionRoleArn` por el ARN del rol de servicio que ha creado para el flujo):

   ```
   # 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. Muestre los flujos de la cuenta, incluido el que acaba de crear, ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

   ```
   client.list_flows()
   ```

1. Obtenga información sobre el flujo que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

   ```
   client.get_flow(flowIdentifier=flow_id)
   ```

1. Prepare el flujo para que se apliquen los cambios más recientes del borrador de trabajo y esté listo para la versión. Ejecute el siguiente fragmento de código para realizar una solicitud [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

   ```
   client.prepare_flow(flowIdentifier=flow_id)
   ```

1. Cree la versión del borrador de trabajo del flujo para crear una instantánea estática del flujo y, a continuación, obtenga la información sobre el trabajo mediante las siguientes acciones:

   1. Cree una versión ejecutando el siguiente fragmento de código para realizar una solicitud [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Muestre todas las versiones del flujo ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

      ```
      client.list_flow_versions(flowIdentifier=flow_id)
      ```

   1. Obtenga información sobre la versión ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Cree un alias que apunte a la versión del flujo creado y, a continuación, recupere la información del flujo realizando las siguientes acciones:

   1. Cree una alias y apúntelo hacia la versión que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Muestre todos los alias del flujo ejecutando el siguiente fragmento de código para realizar una solicitud [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

      ```
      client.list_flow_aliases(flowIdentifier=flow_id)
      ```

   1. Obtenga información sobre el alias que acaba de crear ejecutando el siguiente fragmento de código para realizar una solicitud [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Ejecute el siguiente fragmento de código para crear un cliente de tiempo de ejecución para agentes de Amazon Bedrock e invoque un flujo. La solicitud rellena las variables de la petición del flujo y devuelve la respuesta del modelo para realizar una solicitud [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un [punto de conexión en tiempo de ejecución de Agentes para 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 respuesta debería devolver una lista de reproducción de música pop con tres canciones.

1. Elimine el alias, la versión y el flujo que ha creado con las siguientes acciones:

   1. Elimine el alias ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Elimine la versión ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [punto de conexión en tiempo de compilación de Agentes para 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. Elimine el flujo ejecutando el siguiente fragmento de código para realizar una solicitud [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [punto de conexión en tiempo de compilación de Agentes para Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

      ```
      client.delete_flow(flowIdentifier=flow_id)
      ```

------