# Usando comandos de terminal com uma função de execução
<a name="code-interpreter-s3-integration"></a>

Você pode criar uma ferramenta personalizada de interpretação de código com uma função de execução para upload/download arquivos do Amazon S3. Isso permite que seu código interaja com os buckets do S3 para armazenar e recuperar dados.

## Pré-requisitos
<a name="code-interpreter-s3-prerequisites"></a>

Antes de criar um interpretador de código personalizado com acesso ao S3, você precisa:

1. Crie um bucket S3 (por exemplo,`DOC-EXAMPLE-BUCKET`)

1. Crie uma pasta dentro do bucket (por exemplo,`output_artifacts`)

1. Crie uma função do IAM com a seguinte política de confiança:

   ```
   {
   "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Service": "bedrock-agentcore.amazonaws.com"
         },
         "Action": "sts:AssumeRole",
         "Condition": {
           "StringEquals": {
             "aws:SourceAccount": "111122223333"
           }
         }
       }
     ]
   }
   ```

1. Adicione as seguintes permissões à função:

   ```
   {
   "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Sid": "VisualEditor0",
         "Effect": "Allow",
         "Action": [
           "s3:PutObject",
           "s3:GetObject"
         ],
         "Resource": "arn:aws:s3:::DOC-EXAMPLE-BUCKET/*",
         "Condition": {
             "StringEquals": {
                 "s3:ResourceAccount": "${aws:PrincipalAccount}"
             }
         }
       }
     ]
   }
   ```

## Código de exemplo Python
<a name="code-interpreter-s3-code"></a>

Você pode implementar a integração do S3 usando o boto3 (AWS SDK para Python). O exemplo a seguir usa o boto3 para criar um interpretador de código personalizado com uma função de execução que pode carregar ou baixar arquivos do Amazon S3.

**nota**  
Antes de executar esse código, certifique-se de substituí-lo por `REGION` sua AWS região e número de AWS conta. `<awsaccountid>`

```
import boto3
import json
import time

REGION = "<Region>"
CP_ENDPOINT_URL = f"https://bedrock-agentcore-control.{REGION}.amazonaws.com"
DP_ENDPOINT_URL = f"https://bedrock-agentcore.{REGION}.amazonaws.com"

# Update the accountId to reflect the correct S3 path.
S3_BUCKET_NAME = "DOC-EXAMPLE-BUCKET"

bedrock_agentcore_control_client = boto3.client(
    'bedrock-agentcore-control',
    region_name=REGION,
    endpoint_url=CP_ENDPOINT_URL
)
bedrock_agentcore_client = boto3.client(
    'bedrock-agentcore',
    region_name=REGION,
    endpoint_url=DP_ENDPOINT_URL
)

unique_name = f"s3InteractionEnv_{int(time.time())}"
create_response = bedrock_agentcore_control_client.create_code_interpreter(
    name=unique_name,
    description="Combined test code sandbox",
    executionRoleArn="arn:aws:iam::123456789012:role/S3InteractionRole",
    networkConfiguration={
        "networkMode": "SANDBOX"
    }
)
code_interpreter_id = create_response['codeInterpreterId']
print(f"Created custom interpreter ID: {code_interpreter_id}")

session_response = bedrock_agentcore_client.start_code_interpreter_session(
    codeInterpreterIdentifier=code_interpreter_id,
    name="combined-test-session",
    sessionTimeoutSeconds=1800
)
session_id = session_response['sessionId']
print(f"Created session ID: {session_id}")

print(f"Downloading CSV generation script from S3")
command_to_execute = f"aws s3 cp s3://{S3_BUCKET_NAME}/generate_csv.py ."
response = bedrock_agentcore_client.invoke_code_interpreter(
    codeInterpreterIdentifier=code_interpreter_id,
    sessionId=session_id,
    name="executeCommand",
    arguments={
        "command": command_to_execute
    }
)

for event in response["stream"]:
    print(json.dumps(event["result"], default=str, indent=2))

print(f"Executing the CSV generation script")
response = bedrock_agentcore_client.invoke_code_interpreter(
    codeInterpreterIdentifier=code_interpreter_id,
    sessionId=session_id,
    name="executeCommand",
    arguments={
        "command": "python generate_csv.py 5 10"
    }
)

for event in response["stream"]:
    print(json.dumps(event["result"], default=str, indent=2))

print(f"Uploading generated artifact to S3")
command_to_execute = f"aws s3 cp generated_data.csv s3://{S3_BUCKET_NAME}/output_artifacts/"
response = bedrock_agentcore_client.invoke_code_interpreter(
    codeInterpreterIdentifier=code_interpreter_id,
    sessionId=session_id,
    name="executeCommand",
    arguments={
        "command": command_to_execute
    }
)

for event in response["stream"]:
    print(json.dumps(event["result"], default=str, indent=2))

print(f"Stopping the code interpreter session")
stop_response = bedrock_agentcore_client.stop_code_interpreter_session(
    codeInterpreterIdentifier=code_interpreter_id,
    sessionId=session_id
)

print(f"Deleting the code interpreter")
delete_response = bedrock_agentcore_control_client.delete_code_interpreter(
    codeInterpreterId=code_interpreter_id
)
print(f"Code interpreter status from response: {delete_response['status']}")
print(f"Clean up completed, script run successful")
```

Este exemplo mostra como:
+ Crie um interpretador de código personalizado com uma função de execução
+ Configurar o acesso à rede - Escolha o modo PÚBLICO se seu interpretador de código precisar se conectar à Internet pública. Se o seu interpretador de código precisar de acesso limitado ao Amazon S3, escolha o modo SANDBOX.
+ Carregue e baixe arquivos entre o ambiente do Code Interpreter e o S3
+ Execute comandos e scripts no ambiente do Code Interpreter
+ Limpe os recursos ao terminar