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.
# Comience a utilizar los agentes gestionados por Amazon Bedrock (con OpenAI) en tiempo de ejecución AgentCore
**nota**
Amazon Bedrock Managed Agents (con OpenAI) está en versión preliminar. Las funciones y las API pueden cambiar antes de que estén disponibles para el público en general.
Amazon Bedrock Managed Agents utiliza el arnés OpenAI Codex. AWS El arnés sirve de enlace entre el modelo y las herramientas, mantiene la sesión y compacta el contexto a medida que la conversación crece. Cuando el agente debe ejecutar un comando o trabajar con archivos, Bedrock Managed Agents envía el trabajo a un entorno. Usted decide dónde se ejecuta ese entorno.
Puede ejecutar el servidor ejecutivo del Codex en su propio ordenador para el desarrollo local. Para otras cargas de trabajo, Bedrock Managed Agents invoca un Runtime en su cuenta. AgentCore El tiempo de ejecución proporciona a cada sesión su propia microVM. La sesión se ejecuta bajo una función de ejecución que usted controla, y el Runtime se puede conectar a su VPC para que el agente pueda acceder a los recursos privados. Las llamadas al modelo permanecen en Bedrock Managed Agents, por lo que el contenedor solo ejecuta los comandos que envía el agente.
En este tutorial, realizará las siguientes tareas:
+ Cree e implemente el tiempo de ejecución con la AgentCore CLI.
+ Inicie una sesión con el SDK de OpenAI. El agente utiliza una habilidad de muestra en su tiempo de ejecución.
+ (Opcional) Añada sus propias habilidades.
Los pasos 1 a 4 tardan unos 15 minutos.
Los AWS recursos que cree en este tutorial pueden generar cargos en su AWS cuenta. Estos recursos incluyen el tiempo de ejecución, las compilaciones de AWS CodeBuild imágenes y las versiones del modelo Bedrock Managed Agents. Para obtener más información, consulte [Precios de AgentCore ](https://aws.amazon.com/bedrock/agentcore/pricing/). Para detener los cargos, retire los recursos incluidos. [Paso 8: Eliminación](#runtime-get-started-bma-clean-up)
## Requisitos previos
+ **Node.js 20 o más tarde.** La AgentCore CLI se distribuye como un paquete npm. Consulte con`node --version`.
+ **UV.** El cliente de muestra usa [uv](https://docs.astral.sh/uv/) para instalar sus dependencias de Python.
+ **Una AWS cuenta con credenciales configuradas.** Para crear una cuenta, consulte [Cómo empezar a utilizar una AWS cuenta](https://docs.aws.amazon.com/accounts/latest/reference/getting-started.html). Para configurar las credenciales, consulte [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html).
+ **Permisos de IAM**. Su identidad necesita permisos para realizar llamadas a la AgentCore API y asumir las funciones de arranque de la CDK utilizadas durante la implementación. Consulte [Uso de la AgentCore CLI](runtime-permissions.md#runtime-permissions-cli). El cliente de muestra también necesita permisos de IAM. Consulte [El rol de sesión](#runtime-get-started-bma-session-role).
+ **Acceso al modelo.** Su cuenta necesita acceder al modelo `openai.gpt-5.6-luna` de agentes gestionados de Bedrock.
La CLI crea la imagen del contenedor AWS CodeBuild en su cuenta.
## Paso 1: Crea el proyecto
Instale la AgentCore CLI y configure sus credenciales y región:
```
npm install -g @aws/agentcore
agentcore --version
export AWS_PROFILE=your-profile
export AWS_REGION=us-east-1
```
Cree el proyecto con el `BedrockManagedAgents` marco. También puedes correr `agentcore create` sin banderas. Seleccione **Agent** y, a continuación, **Bedrock Managed Agents** como marco.
```
agentcore create --name MyManagedAgent --framework BedrockManagedAgents
cd MyManagedAgent
```
El proyecto tiene la configuración de tiempo de ejecución `agentcore/agentcore.json` y la fuente del contenedor incluida. `app/MyManagedAgent/` Se ejecuta el contenedor`codex exec-server`, que se conecta a Bedrock Managed Agents y ejecuta los comandos del agente.
El proyecto configura el Runtime con los siguientes valores predeterminados:
+ Un tiempo de inactividad de 30 minutos y una vida útil máxima de 8 horas. Consulte [Configurar los ajustes del ciclo de vida.](runtime-lifecycle-settings.md)
+ Un rol de ejecución con los permisos activados`policies/bma-acr-policy.json`.
### Estructura de un proyecto
```
MyManagedAgent/
├── agentcore/
│ ├── agentcore.json
│ └── cdk/
└── app/MyManagedAgent/
├── Dockerfile
├── lifecycle/server.py
├── otel/collector.yaml
├── plugins/acr-report/
├── policies/
│ ├── bma-acr-policy.json
│ ├── bma-session-trust.json
│ └── bma-session-policy.json
├── pyproject.toml
├── client.py
└── README.md
```
Archivos clave:
+ `lifecycle/server.py`- El servidor del ciclo de vida. Bedrock Managed Agents lo llama para que comience `codex exec-server` en su sesión de Runtime. No modifique este archivo.
+ `Dockerfile`- Instala Codex, el CloudWatch agente y Python, y copia `lifecycle/``otel/`, y `plugins/` a. `/opt/bma`
+ `otel/collector.yaml`- Envía los intervalos y registros del servidor ejecutivo a. CloudWatch
+ `plugins/acr-report/`- Un ejemplo de plugin con una habilidad. La habilidad se guarda `acr-report.txt` en el espacio de trabajo.
+ `policies/bma-acr-policy.json`- La política del rol de ejecución en tiempo de ejecución. Permite `bedrock-mantle:RegisterEnvironment` y `bedrock-mantle:ConnectEnvironment`. Para limitarlo a un proyecto, cámbielo `Resource` a`arn:aws:bedrock-mantle:::project/`.
+ `pyproject.toml`- Las dependencias de Python. El `dev` grupo es `client.py` solo para.
+ `policies/bma-session-trust.json`y`policies/bma-session-policy.json`: la política de confianza y los permisos del rol de sesión. Consulte [El rol de sesión](#runtime-get-started-bma-session-role).
+ `client.py`- Un ejemplo de cliente que inicia una sesión. Se ejecuta en el paso 3.
### Implemente el tiempo de ejecución en una VPC
Añada las opciones de red a`agentcore create`:
```
agentcore create --name MyManagedAgent --framework BedrockManagedAgents \
--network-mode VPC --vpc-id --subnets \
--security-groups
```
La VPC debe tener una ruta al punto final de Bedrock Managed Agents, ya que el servidor ejecutivo se conecta a él. La compilación de la imagen descarga Codex y Python, por lo que también necesita una ruta a Internet. Consulte [Configurar AgentCore para VPC](agentcore-vpc.md).
### Ejecute el tiempo de ejecución en las instancias
El mismo proyecto se ejecuta en el tipo de cómputo **Instances**. Añada un proveedor de capacidad al proyecto y, a continuación, añada el agente con el proveedor de capacidad:
```
agentcore create --name MyManagedAgent --no-agent
cd MyManagedAgent
agentcore add capacity-provider --name MyCapacityProvider \
--subnets --security-groups \
--os LINUX_ARM64 --instance-types c7g.large
agentcore add agent --name MyManagedAgent --framework BedrockManagedAgents \
--capacity-provider MyCapacityProvider
```
A continuación, continúe con[Paso 2: Implementar](#runtime-get-started-bma-deploy). `agentcore deploy`también crea el proveedor de capacidad y su función de operador.
+ Utilice `LINUX_ARM64` los tipos de instancia Graviton, ya que la creación de la imagen crea una imagen ARM64.
+ El proveedor de capacidad proporciona la red. Las subredes deben tener una ruta al punto final de Bedrock Managed Agents.
Para adjuntar un proveedor de capacidad que no esté en el proyecto, indique su ARN a. `agentcore create --framework BedrockManagedAgents --capacity-provider ` Consulte las [instancias de ejecución y los proveedores de capacidad](runtime-instances.md).
## Paso 2: Implementar
```
agentcore deploy
agentcore status
```
La CLI crea la imagen AWS CodeBuild en su cuenta e implementa el Runtime y su función de ejecución. Bedrock Managed Agents invoca el tiempo de ejecución por usted.
Guarde el ARN del tiempo de ejecución de la salida de: `agentcore status`
```
arn:aws:bedrock-agentcore:us-east-1::runtime/
```
## Paso 3: ejecutar una sesión
Bedrock Managed Agents utiliza un rol de sesión para llamar al modelo e invocar su tiempo de ejecución. El rol de sesión no es el rol de ejecución en tiempo de ejecución. **Cuando se ejecuta`client.py`, se crea el rol de sesión en su cuenta.** `agentcore deploy`no crea el rol de sesión `agentcore remove` ni lo elimina. Consulte [El rol de sesión](#runtime-get-started-bma-session-role).
Ejecute el cliente desde el directorio de agentes:
```
cd app/MyManagedAgent
uv run client.py --runtime
```
El cliente crea una sesión e imprime el identificador de la sesión, cada comando con su salida y la respuesta del agente. De forma predeterminada, el agente usa la `acr-report` habilidad para guardar `acr-report.txt` en el espacio de trabajo.
En la siguiente sección, se explica cómo el cliente gestiona la función de sesión y qué permisos de IAM se necesitan para ejecutar el cliente.
### El rol de sesión
El rol de sesión no es el rol de ejecución en tiempo de ejecución. `agentcore deploy`crea el rol de ejecución con`policies/bma-acr-policy.json`. El cliente asigna el rol de sesión a Bedrock Managed Agents en el `role_arn` campo cuando crea una sesión.
Cuando inicias una nueva sesión y no la das`--role-arn`, el cliente sigue estos pasos:
1. Si el rol `BmaSessionRole-` no existe, el cliente lo crea.
1. El cliente compara la política de confianza y la política interna `BmaSession` del rol con `policies/bma-session-trust.json` y`policies/bma-session-policy.json`. Si una política no es la misma, el cliente escribe el archivo en el rol. Los archivos se limitan a la cuenta y a la región del tiempo de ejecución.
1. Si el cliente ha cambiado el rol, espera 15 segundos. IAM necesita este tiempo antes de que los agentes gestionados por Bedrock puedan utilizar el cambio.
Para cambiar el rol, cambie los archivos. El cliente no elimina otras políticas que alguien añada al rol. No comprueba el rol cuando lo `--session-id` asignas y no cambia el rol con el que lo asignas`--role-arn`.
En el caso de la producción, asigne al cliente un rol con un Runtime y un gateway`--role-arn`. Para crear la función, utilice los dos archivos que aparecen en`policies/`. Introduce tu partición, región e ID de cuenta, y cámbialos por tu ID de tiempo de ejecución y tu ID de puerta de enlace. ` ` `runtime/` `gateway/*` No cambies los archivos del proyecto, ya que todos los proyectos de la región los comparten`BmaSessionRole-`.
La identidad que ejecuta el cliente necesita los permisos de cliente de Bedrock Managed Agents y `iam:PassRole` el rol de sesión. `bedrock-mantle:CallWithBearerToken` Para permitir que el cliente cree y repare el rol, también asigne`iam:GetRole`,`iam:CreateRole`, `iam:UpdateAssumeRolePolicy``iam:GetRolePolicy`, y así `iam:PutRolePolicy` sucesivamente`arn:aws:iam:::role/BmaSessionRole-*`. Si lo concede`--role-arn`, el cliente no necesitará estos cinco permisos.
Para conocer la política de confianza, los permisos del rol de sesión y los permisos del cliente, consulte los [roles de seguridad e IAM](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-managed-agents-openai-security.html) en la Guía del *usuario de Amazon Bedrock*.
### Cómo funciona el cliente
El cliente usa los `client.beta.agents` recursos del `openai` paquete. Bedrock Managed Agents ejecuta el ciclo de agentes.
Cuando el cliente crea la sesión, establece estos valores en`environment`:
+ `type`-`aws_bedrock_agentcore`, que indica a Bedrock Managed Agents que usen un AgentCore Runtime.
+ `runtime_arn`- Tu tiempo de ejecución. La sesión se ejecuta en la región del tiempo de ejecución.
+ `workspace_directory`- El directorio en el que el agente ejecuta sus comandos. El cliente usa`/home/app/workspace`. El servidor del ciclo de vida crea el directorio.
+ `runtime_qualifier`- El punto final del tiempo de ejecución. El cliente usa`DEFAULT`.
+ `capability_directories`- Los directorios en los que Bedrock Managed Agents encuentra habilidades. El cliente usa`/opt/bma/plugins`.
El cliente también asume `role_arn` `extra_body` el rol de sesión. El `openai` paquete no tiene ningún parámetro para este campo.
El `provide_token` ayudante usa tus AWS credenciales para obtener un token portador de Amazon Bedrock de corta duración para cada solicitud.
Si agrega una puerta de enlace al proyecto, indique su ARN a partir de la salida de `agentcore deploy` with. `--gateway` Usa la marca solo para una sesión nueva. El cliente agrega la puerta de enlace como una `mcp` herramienta con el ARN incorporado. `connector_id` Bedrock Managed Agents llama a la puerta de enlace con la función de sesión. La puerta de enlace debe ser compatible con la versión MCP. `2025-03-26` Si no es así, el agente no recibirá ninguna herramienta de puerta de enlace y Bedrock Managed Agents no mostrará ningún error.
```
"""Send an input to a Bedrock Managed Agents session that uses this project's ACR."""
import argparse
import json
import time
from pathlib import Path
from typing import Any
import boto3
from aws_bedrock_token_generator import provide_token
from botocore.exceptions import ClientError
from openai import NotFoundError, OpenAI
BMA_MODEL_ID = "openai.gpt-5.6-luna"
# The agent runs its commands in this directory. The lifecycle server creates it.
WORKSPACE_DIRECTORY = "/home/app/workspace"
# Plugins and skills that the agent can use. The image has the acr-report plugin
# at this path. Add the path of an S3 Files mount to use the skills in a bucket.
CAPABILITY_DIRECTORIES = ["/opt/bma/plugins"]
TURN_END = ("completed", "failed", "cancelled")
TOOL_CALLS = ("mcp_call", "function_call", "web_search_call")
POLICIES = Path(__file__).parent / "policies"
SESSION_ROLE = "BmaSessionRole-{region}"
SESSION_POLICY = "BmaSession"
def show(data: dict[str, Any]) -> None:
"""Prints the session ID, the commands, the tool calls, and the answer."""
kind = data["type"].removeprefix("agent.session.")
item = data.get("item") or {}
if kind == "created":
print(f"Session {data['session']['id']}")
elif kind == "turn.output_text.delta":
print(data["delta"], end="", flush=True)
elif kind == "turn.item.done" and item.get("type") == "command_execution":
print(f"\n$ {item['command']}\n{item.get('output') or ''}".rstrip())
elif kind == "turn.item.done" and item.get("type") in TOOL_CALLS:
print(f"\nTool {item.get('name') or item['type']} {item.get('status')}")
elif kind == "error" or kind.split(".")[-1] in TURN_END:
source = data.get("turn") or data.get("environment") or data.get("session")
print(f"\n{kind} {(source or data).get('error') or ''}".rstrip())
def load_policy(name: str, partition: str, region: str, account: str) -> str:
"""Reads a policy file and puts in the partition, the Region, and the account."""
text = (POLICIES / name).read_text()
for key, value in (("Partition", partition), ("Region", region), ("AccountId", account)):
text = text.replace("${AWS::" + key + "}", value)
return text
def session_role(runtime_arn: str) -> str:
"""Creates or repairs the session role, and returns its ARN.
If the trust policy or the policy of the role is not the same as the file in `policies/`,
the client writes the file to the role.
"""
_, partition, _, region, account = runtime_arn.split(":")[:5]
name = SESSION_ROLE.format(region=region)
trust = load_policy("bma-session-trust.json", partition, region, account)
policy = load_policy("bma-session-policy.json", partition, region, account)
iam = boto3.client("iam")
changed = False
try:
role = iam.get_role(RoleName=name)["Role"]
except iam.exceptions.NoSuchEntityException:
role = iam.create_role(RoleName=name, AssumeRolePolicyDocument=trust)["Role"]
print(f"Created the session role {name}")
changed = True
else:
if role["AssumeRolePolicyDocument"] != json.loads(trust):
iam.update_assume_role_policy(RoleName=name, PolicyDocument=trust)
print(f"Updated the trust policy of {name}")
changed = True
try:
current = iam.get_role_policy(RoleName=name, PolicyName=SESSION_POLICY)["PolicyDocument"]
except iam.exceptions.NoSuchEntityException:
current = None
if current != json.loads(policy):
iam.put_role_policy(RoleName=name, PolicyName=SESSION_POLICY, PolicyDocument=policy)
if not changed:
print(f"Updated the policy of {name}")
changed = True
if changed:
# IAM needs some seconds before Bedrock Managed Agents can use a new or changed role.
time.sleep(15)
return role["Arn"]
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--runtime", required=True, help="The ACR ARN.")
parser.add_argument(
"--session-id",
help="The BMA session ID. If it does not exist, the client creates a session.",
)
parser.add_argument(
"--input",
default="Use the acr-report skill to save an ACR report in the workspace.",
)
parser.add_argument(
"--gateway",
help="The Gateway ARN from the output of `agentcore deploy`.",
)
parser.add_argument(
"--role-arn",
help="The session role that BMA assumes. If you do not give it, the client creates a role.",
)
parser.add_argument("--delete", action="store_true", help="Delete the session.")
parser.add_argument("--raw", action="store_true", help="Print events as JSON.")
args = parser.parse_args()
# BMA must run in the Region of the ACR.
region = args.runtime.split(":")[3]
with OpenAI(
api_key=lambda: provide_token(region=region),
base_url=f"https://bedrock-mantle.{region}.api.aws/openai/v1",
) as client:
sessions = client.beta.agents.sessions
session_id = args.session_id
if session_id:
try:
session = sessions.retrieve(session_id).model_dump(warnings=False)
except NotFoundError:
print(f"Session {session_id} does not exist.")
session_id = None
else:
if session["environment"].get("runtime_arn") != args.runtime:
raise ValueError(f"Session {session_id} uses another ACR.")
if not session_id and not args.role_arn:
try:
args.role_arn = session_role(args.runtime)
except ClientError as error:
parser.error(
f"The client cannot create or check the session role: {error}. "
"Get the IAM permissions in README.md, or give --role-arn."
)
print(f"Session role {args.role_arn}")
if session_id:
# BMA opens the stream only with stream=true, and the SDK does not send it.
events = sessions.events.stream(session_id, extra_query={"stream": "true"})
message = {
"role": "user",
"content": [{"type": "input_text", "text": args.input}],
}
sessions.events.create(
session_id,
events=[{"type": "agent.session.input.message", "input": [message]}],
)
else:
agent: dict[str, Any] = {
"model": BMA_MODEL_ID,
"instructions": "Use the available tools to complete the task.",
}
if args.gateway:
# Bedrock Managed Agents calls Gateway with the session role from the service side.
agent["tools"] = [
{"type": "mcp", "server_label": "team_tools", "connector_id": args.gateway}
]
args.input += " Then list the tools that the Gateway gives you."
events = sessions.create(
agent=agent,
environment={
"type": "aws_bedrock_agentcore",
"runtime_arn": args.runtime,
"runtime_qualifier": "DEFAULT",
"workspace_directory": WORKSPACE_DIRECTORY,
"capability_directories": CAPABILITY_DIRECTORIES,
},
input=args.input,
stream=True,
# The SDK has no role_arn parameter. BMA assumes this role to call the ACR.
extra_body={"role_arn": args.role_arn},
)
with events:
for event in events:
data = event.model_dump(mode="json", warnings=False)
session_id = session_id or (data.get("session") or {}).get("id")
if args.raw:
print(json.dumps(data), flush=True)
else:
show(data)
if data["type"].removeprefix("agent.session.turn.") in TURN_END:
break
if args.delete:
sessions.delete(session_id)
print(f"\nDeleted session {session_id}")
if __name__ == "__main__":
main()
```
## Paso 4: Continuar la sesión
Para enviar otra entrada a la misma sesión, añada el ID de la sesión. El turno usa el mismo espacio de trabajo. Para conservar el espacio de trabajo después de una parada de inactividad, añada el almacenamiento de la sesión, tal como se indica[Conserve los archivos después de una parada de inactividad](#runtime-get-started-bma-keep-files).
```
uv run client.py --runtime --session-id \
--input "Run cat acr-report.txt and show the output."
```
Si la sesión no existe, el cliente crea una sesión nueva. Añada esta opción `--delete` para eliminar la sesión después del turno o `--raw` para imprimir cada evento como JSON.
### Conserve los archivos después de una parada de inactividad
En un entorno de ejecución de microVM, coloque el directorio principal del servidor ejecutivo en el almacenamiento de la sesión. Luego, el espacio de trabajo, el estado de la conexión y la `CODEX_HOME` estancia después de una inactividad se detienen.
1. En lugar del comando del paso 1, cree el proyecto con el almacenamiento de sesiones:
```
agentcore create --name MyManagedAgent --framework BedrockManagedAgents \
--session-storage-mount-path /mnt/home
cd MyManagedAgent
```
1. En`agentcore/agentcore.json`, añada esta variable a la entrada del tiempo de ejecución:
```
"envVars": [{ "name": "BMA_HOME_DIR", "value": "/mnt/home" }]
```
1. En`client.py`, set`WORKSPACE_DIRECTORY = "/mnt/home/workspace"`.
1. Implemente y ejecute el cliente.
Para obtener más información sobre el almacenamiento de sesiones, consulte [Configuraciones del sistema de archivos para AgentCore Runtime](runtime-filesystem-configurations.md).
## Paso 5: (opcional) Añadir habilidades
Para añadir una habilidad a la imagen, añade un plugin debajo `plugins/` e impleméntalo. Un plugin tiene un `.codex-plugin/plugin.json` archivo y un `skills/` directorio. El `skills/` directorio tiene un subdirectorio para cada habilidad, con un `SKILL.md` archivo en él. La imagen lo copia y el cliente ya lo proporciona a Bedrock Managed Agents. `/opt/bma/plugins`
Para empezar`plugins/acr-report/`, copia y cámbiale el nombre del directorio del plugin `skills/acr-report/` al nombre de tu plugin y a tu habilidad. En`plugin.json`, establece`name`, `version``description`, y`"skills": "./skills/"`. Cada uno `SKILL.md` comienza con materia inicial que tiene `name` y`description`. Tras el despliegue, inicie una nueva sesión con`--input "Use the skill to …"`.
### Comparta las habilidades de un bucket de Amazon S3
Monte un punto de acceso a S3 Files en el entorno de ejecución. Luego, las habilidades cambian cuando el cubo cambia y la imagen permanece igual. Para conocer las reglas del sistema de archivos S3 Files, el punto de acceso y el grupo de seguridad, consulte [Configuraciones del sistema de archivos para AgentCore Runtime](runtime-filesystem-configurations.md).
Un montaje de S3 Files necesita un tiempo de ejecución en modo de red VPC. Cree el proyecto con las opciones de red incluidas. [Implemente el tiempo de ejecución en una VPC](#runtime-get-started-bma-vpc)
En el depósito, coloca cada complemento en su propio directorio, en el directorio raíz del punto de acceso. Usa el mismo diseño que`plugins/acr-report/`: `/.codex-plugin/plugin.json` y`/skills//SKILL.md`.
Añada la montura a la entrada del Runtime en`agentcore/agentcore.json`:
```
{
"filesystemConfigurations": [
{
"s3FilesAccessPoint": {
"accessPointArn": "arn:aws:s3files:us-east-1:111122223333:file-system/fs-0123456789abcdef0/access-point/fsap-0123456789abcdef0",
"mountPath": "/mnt/skills"
}
}
]
}
```
Luego, `CAPABILITY_DIRECTORIES` `client.py` configúrelo `["/opt/bma/plugins", "/mnt/skills"]` en e impleméntelo.
## Paso 6: Ver registros y rastreos
```
agentcore logs --since 15m
```
La primera implementación activa la búsqueda de CloudWatch transacciones en tu cuenta. Las huellas aparecen después de unos 10 minutos. Para ver las trazas, abre la CloudWatch consola y selecciona **GenAI Observability**. Cada llamada de Bedrock Managed Agents al servidor del ciclo de vida tiene un intervalo. `bma.invocation` Para obtener más información, consulte [Ver datos de observabilidad de sus agentes de Amazon Bedrock AgentCore ](observability-view.md).
**La configuración de búsqueda de transacciones se aplica a toda la cuenta**
La búsqueda de transacciones y su indexación por intervalos se aplican a toda la cuenta de la región y pueden aplicarse cargos adicionales. Para conservar la configuración actual, añádala `"disableTransactionSearch": true` `~/.agentcore/config.json` antes de implementarla.
## Paso 7: Actualizar y volver a implementar
Cambie la configuración del tiempo de `agentcore/agentcore.json` ejecución o los archivos de la imagen y vuelva a implementarla. Por ejemplo, esta configuración detiene una sesión inactiva después de 10 minutos. Los valores se expresan en segundos.
```
{
"lifecycleConfiguration": {
"idleRuntimeSessionTimeout": 600,
"maxLifetime": 28800
}
}
```
```
agentcore deploy
```
Los cambios se aplican a las sesiones nuevas.
### Variables de entorno del servidor del ciclo de vida
Añada una variable a `envVars` en la entrada del tiempo de ejecución, por ejemplo`{ "name": "DISABLE_ADOT_OBSERVABILITY", "value": "true" }`.
| Variable | Predeterminado | Description (Descripción) |
| --- | --- | --- |
| `DISABLE_ADOT_OBSERVABILITY` | No configurado | Configúrelo en `true` para desactivar los seguimientos y los registros del servidor ejecutivo. El servidor del ciclo de vida sigue escribiendo sus propios registros en el grupo de registros del Runtime. |
| `BMA_HOME_DIR` | `/home/app` | `HOME`del servidor ejecutivo. |
| `BMA_STATE_DIR` | `.bma` en `BMA_HOME_DIR` | El directorio de`state.json`, que mantiene el estado de conexión de la sesión. |
| `BMA_CODEX_HOME` | `.codex` en `BMA_HOME_DIR` | `CODEX_HOME`del servidor ejecutivo. |
| `BMA_CODEX_BINARY` | `/opt/bma/bin/codex` | El binario del Codex. |
| `BMA_MAX_TURN_LEASE` | `300` | El arrendamiento por turno más largo, en segundos. |
Cada creación de imagen instala la última versión del Codex. El servidor de ciclo de vida necesita Codex 0.154.0 o una versión posterior. Para fijar una versión, añada `CODEX_RELEASE=` junto a`CODEX_NON_INTERACTIVE=1`. `Dockerfile`
## Paso 8: Eliminación
Para eliminar una sesión, agréguela `--delete` a la última ejecución del cliente para esa sesión. A continuación, elimine los recursos del proyecto e impleméntelos para eliminar el Runtime, su función de ejecución y la pila.
```
agentcore remove all
agentcore deploy
```
La implementación no elimina estos recursos:
+ Los CloudWatch registros agrupan el Runtime, el CodeBuild proyecto que crea la imagen y la función Lambda que inicia la compilación.
+ La clave AWS KMS del repositorio de Amazon ECR. La clave permanece en el estado de **pendiente de eliminación** durante 30 días y, a continuación, AWS KMS la elimina.
+ La `CDKToolkit` pila, si la primera implementación arrancó la cuenta y la región. Otras aplicaciones de AWS CDK pueden usar esta pila. Elimínelo solo si ninguna otra aplicación lo usa.
+ La configuración de búsqueda de transacciones del paso 6.
+ El rol de sesión que `client.py` se creó en el paso 3.
Para eliminar el rol de sesión, ejecute estos comandos:
```
aws iam delete-role-policy --role-name BmaSessionRole- --policy-name BmaSession
aws iam delete-role --role-name BmaSessionRole-
```
Para buscar los grupos de registros, ejecute estos comandos. A continuación, elimine cada grupo de registros.
```
aws logs describe-log-groups --log-group-name-prefix /aws/bedrock-agentcore/runtimes/_- --query 'logGroups[].logGroupName'
aws logs describe-log-groups --log-group-name-prefix /aws/codebuild/AgentCore--- --query 'logGroups[].logGroupName'
aws logs describe-log-groups --log-group-name-prefix /aws/lambda/AgentCore- --query 'logGroups[].logGroupName'
aws logs delete-log-group --log-group-name
```
Sustituya estos valores:
+ ``- El nombre del proyecto. En el paso 1, lo es`MyManagedAgent`.
+ ``- El nombre del agente. En el paso 1, también lo es`MyManagedAgent`.
+ ``- El nombre del objetivo de despliegue en`agentcore/aws-targets.json`. El valor predeterminado es `default`. En los CodeBuild nombres, cada subrayado (`_`) del nombre del proyecto y del nombre del objetivo se convierte en un guión ()`-`.
El nombre del grupo de registros Lambda se acorta, como en este ejemplo:
```
/aws/lambda/AgentCore-MyManagedAgent--ApplicationAgentMyManage-
```
El comando muestra los grupos de registros Lambda de todos los proyectos de AgentCore CLI de la región. Elimine solo los grupos de registros de su proyecto.
Si has añadido otros recursos al proyecto, como una puerta de enlace o una memoria, comprueba que la implementación los haya eliminado.
## Recursos relacionados
+ [Utilice la AgentCore CLI](runtime-permissions.md#runtime-permissions-cli)
+ [Configurar los ajustes del ciclo de vida](runtime-lifecycle-settings.md)
+ [Configuraciones del sistema de archivos para AgentCore Runtime](runtime-filesystem-configurations.md)
+ [Configurar AgentCore para VPC](agentcore-vpc.md)
+ [Instancias de tiempo de ejecución y proveedores de capacidad](runtime-instances.md)
+ [Vea los datos de observabilidad de sus agentes de Amazon Bedrock AgentCore ](observability-view.md)