Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Eseguire esempi di codice Amazon Bedrock Flows
<a name="flows-code-ex"></a>

I seguenti esempi di codice presuppongono che tu abbia soddisfatto i seguenti prerequisiti:

1. Configura un ruolo per acquisire le autorizzazioni per le azioni di Amazon Bedrock. Se non lo hai già fatto, consulta [Guida introduttiva](getting-started.md).

1. Configura le tue credenziali per utilizzare l’API AWS. Se non lo hai già fatto, consulta [Iniziare a utilizzare l’API](getting-started-api.md).

1. Crea un ruolo di servizio per eseguire azioni relative al flusso per tuo conto. Se non lo hai già fatto, consulta [Creare un ruolo di servizio per Amazon Bedrock Flows in Amazon Bedrock](flows-permissions.md).

Per creare un flusso, invia una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt). Per l’esempio di codice, consulta [Eseguire esempi di codice Amazon Bedrock Flows](#flows-code-ex)

I seguenti campi sono obbligatori:


****  

| Campo | Descrizione di base | 
| --- | --- | 
| name | Un nome per il flusso. | 
| executionRoleArn | L’ARN del [ruolo di servizio con le autorizzazioni per creare e gestire i flussi](flows-permissions.md). | 

I seguenti campi sono facoltativi:


****  

| Campo | Caso d’uso | 
| --- | --- | 
| definizione | Contiene i nodes e le connections che compongono il flusso. | 
| description | Per descrivere il flusso. | 
| tag | Per associare tag al flusso. Per ulteriori informazioni, consulta [Assegnazione di tag alle risorse Amazon Bedrock](tagging.md). | 
| customerEncryptionKeyArn | Per crittografare la risorsa con una chiave KMS. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon Bedrock Flows](encryption-flows.md). | 
| clientToken | Per garantire che la richiesta API venga completata solo una volta. Per ulteriori informazioni, consulta [Garanzia di idempotenza](https://docs.aws.amazon.com/ec2/latest/devguide/ec2-api-idempotency.html). | 

Sebbene il campo `definition` sia facoltativo, è necessario per il funzionamento del flusso. Puoi scegliere di creare prima un flusso senza la definizione e aggiornare il flusso in un secondo momento.

Per ogni nodo dell’elenco `nodes`, specifica il tipo di nodo nel campo `type` e fornisci la configurazione corrispondente del nodo nel campo `config`. Per informazioni dettagliate sulla struttura API dei diversi tipi di nodi, consulta [Tipi di nodo per il flusso](flows-nodes.md).

Per provare alcuni esempi di codice per Amazon Bedrock Flows, scegli la scheda relativa al tuo metodo preferito, quindi segui le fasi:

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

1. Crea un flusso utilizzando una richiesta [CreateFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt) con i seguenti nodi:
   + Un nodo di input.
   + Un nodo prompt con un prompt definito inline che crea una playlist musicale utilizzando due variabili (`genre` e `number`).
   + Un nodo di output che restituisce il completamento del modello.

   Esegui il seguente frammento di codice per caricare AWS SDK per Python (Boto3), crea un client Agent per Amazon Bedrock e crea un flusso con i nodi (sostituisci il campo `executionRoleArn` con l’ARN del ruolo di servizio che hai creato per il flusso):

   ```
   # 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. Elenca i flussi nel tuo account, incluso quello appena creato, eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlows](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlows.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

   ```
   client.list_flows()
   ```

1. Ottieni informazioni sul flusso che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

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

1. Prepara il flusso in modo che vengano applicate le ultime modifiche della bozza di lavoro e in modo che sia pronto per la versione. Esegui il seguente frammento di codice per effettuare una richiesta [PrepareFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_PrepareFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

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

1. Crea una versione della bozza di lavoro del flusso per creare una snapshot statica del flusso e poi recuperare le informazioni relative con le seguenti azioni:

   1. Crea una versione eseguendo il seguente frammento di codice per effettuare una richiesta [CreateFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowVersion.html) con un [endpoint in fase di build di Agent per 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. Elenca tutte le versioni del flusso eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlowVersions](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowVersions.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

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

   1. Ottieni informazioni sulla versione eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowVersion.html) con un [endpoint in fase di build di Agent per 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. Crea un alias per indicare la versione del flusso che hai creato, quindi recupera le informazioni su di esso con le seguenti azioni:

   1. Crea un alias e puntalo alla versione che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [CreateFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_CreateFlowAlias.html) con un [endpoint in fase di build di Agent per 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. Elenca tutti gli alias del flusso eseguendo il seguente frammento di codice per effettuare una richiesta [ListFlowAliass](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_ListFlowAliass.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

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

   1. Ottieni informazioni sull’alias che hai appena creato eseguendo il seguente frammento di codice per effettuare una richiesta [GetFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_GetFlowAlias.html) con un [endpoint in fase di build di Agent per 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. Esegui il seguente frammento di codice per creare un client di runtime di Agent per Amazon Bedrock e invocare un flusso. La richiesta inserisce le variabili nel prompt del flusso e restituisce la risposta del modello per effettuare una richiesta [InvokeFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_InvokeFlow.html) con un [endpoint di runtime Agent per 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 risposta dovrebbe restituire una playlist di musica pop con tre brani.

1. Elimina l’alias, la versione e il flusso che hai creato con le seguenti azioni:

   1. Elimina l’alias eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlowAlias](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowAlias.html) con un [endpoint in fase di build di Agent per 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. Elimina la versione eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlowVersion](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlowVersion.html) con un [endpoint in fase di build di Agent per 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. Elimina il flusso eseguendo il seguente frammento di codice per effettuare una richiesta [DeleteFlow](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent_DeleteFlow.html) con un [endpoint in fase di build di Agent per Amazon Bedrock](https://docs.aws.amazon.com/general/latest/gr/bedrock.html#bra-bt):

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

------