Comece a usar o Amazon Bedrock Managed Agents (com OpenAI) em Runtime AgentCore

nota

O Amazon Bedrock Managed Agents (com OpenAI) está em versão prévia. Os recursos e as APIs podem mudar antes da disponibilidade geral.

O Amazon Bedrock Managed Agents executa o equipamento OpenAI Codex em. AWS O equipamento percorre o ciclo entre o modelo e as ferramentas, mantém a sessão e compacta o contexto à medida que a conversa cresce. Quando o agente precisa executar um comando ou trabalhar com arquivos, o Bedrock Managed Agents envia o trabalho para um ambiente. Você decide onde esse ambiente é executado.

Você pode executar o servidor executivo do Codex em seu próprio computador para desenvolvimento local. Para outras cargas de trabalho, o Bedrock Managed Agents invoca um AgentCore Runtime em sua conta. O Runtime fornece a cada sessão sua própria microVM. A sessão é executada sob uma função de execução que você controla, e o Runtime pode se conectar à sua VPC para que o agente possa acessar recursos privados. As chamadas do modelo permanecem nos Bedrock Managed Agents, então o contêiner executa somente os comandos que o agente envia.

Neste tutorial, você executa as seguintes tarefas:

• Crie e implante o Runtime com a AgentCore CLI.

• Inicie uma sessão com o SDK do OpenAI. O agente usa um exemplo de habilidade em seu Runtime.

• (Opcional) Adicione suas próprias habilidades.

As etapas 1 a 4 levam cerca de 15 minutos.

Os AWS recursos que você criar neste tutorial podem resultar em cobranças em sua AWS conta. Esses recursos incluem o Runtime, as construções de AWS CodeBuild imagens e as chamadas do modelo Bedrock Managed Agents. Para obter mais informações, consulte Preços do AgentCore . Para interromper as cobranças, remova os recursosEtapa 8: Limpeza.

Pré-requisitos

• Node.js 20 ou mais tarde. A AgentCore CLI é distribuída como um pacote npm. Verifique comnode --version.

• UV. O cliente de amostra usa uv para instalar suas dependências do Python.

• Uma AWS conta com credenciais configuradas. Para criar uma conta, consulte Introdução a uma AWS conta. Para configurar as credenciais, consulte Como configurar a CLI AWS.

• Permissões do IAM. Sua identidade precisa de permissões para fazer chamadas de AgentCore API e assumir as funções de bootstrap do CDK usadas durante a implantação. Consulte Usar a AgentCore CLI. O cliente de amostra também precisa de permissões do IAM. Consulte A função da sessão.

• Acesso ao modelo. Sua conta precisa acessar o modelo openai.gpt-5.6-luna Bedrock Managed Agents.

A CLI cria a imagem do contêiner AWS CodeBuild na sua conta.

Etapa 1: criar o projeto

Instale a AgentCore CLI e defina suas credenciais e sua região:

npm install -g @aws/agentcore
agentcore --version

export AWS_PROFILE=your-profile
export AWS_REGION=us-east-1

Crie o projeto com a BedrockManagedAgents estrutura. Você também pode correr agentcore create sem bandeiras. Selecione Agente e, em seguida, selecione Bedrock Managed Agents como estrutura.

agentcore create --name MyManagedAgent --framework BedrockManagedAgents
cd MyManagedAgent

O projeto tem a configuração Runtime em agentcore/agentcore.json e a origem do contêiner emapp/MyManagedAgent/. O contêiner é executadocodex exec-server, conectando-se aos agentes gerenciados da Bedrock e executando os comandos do agente.

O projeto configura o Runtime com esses padrões:

• Tempo limite de inatividade de 30 minutos e vida útil máxima de 8 horas. Consulte Definir as configurações do ciclo de vida.

• Uma função de execução com as permissões empolicies/bma-acr-policy.json.

Estrutura do projeto

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

Arquivos principais:

• lifecycle/server.py- O servidor do ciclo de vida. O Bedrock Managed Agents o chama para começar codex exec-server em sua sessão de Runtime. Não altere esse arquivo.

• Dockerfile- Instala o Codex, o CloudWatch agente e o Pythonlifecycle/, otel/ copia e para. plugins/ /opt/bma

• otel/collector.yaml- Envia os intervalos e registros do servidor de execução para o. CloudWatch

• plugins/acr-report/- Um exemplo de plugin com uma habilidade. A habilidade salva acr-report.txt no espaço de trabalho.

• policies/bma-acr-policy.json- A política da função de execução do Runtime. Permite bedrock-mantle:RegisterEnvironment e bedrock-mantle:ConnectEnvironment. Para limitá-lo a um projeto, mude Resource paraarn:aws:bedrock-mantle:<region>:<account-id>:project/<project-id>.

• pyproject.toml- As dependências do Python. O dev grupo é client.py só para.

• policies/bma-session-trust.jsone policies/bma-session-policy.json - A política de confiança e as permissões da função da sessão. Consulte A função da sessão.

• client.py- Um exemplo de cliente que inicia uma sessão. Você o executa na Etapa 3.

Implante o Runtime em uma VPC

Adicione as opções de rede aagentcore create:

agentcore create --name MyManagedAgent --framework BedrockManagedAgents \
  --network-mode VPC --vpc-id <vpc-id> --subnets <subnet-ids> \
  --security-groups <security-group-ids>

A VPC deve ter uma rota para o endpoint do Bedrock Managed Agents, porque o servidor executivo se conecta a ela. A compilação da imagem baixa Codex e Python, então ela também precisa de uma rota para a Internet. Consulte Configurar AgentCore para VPC.

Execute o Runtime em instâncias

O mesmo projeto é executado no tipo de computação Instances. Adicione um provedor de capacidade ao projeto e, em seguida, adicione o agente com o provedor de capacidade:

agentcore create --name MyManagedAgent --no-agent
cd MyManagedAgent
agentcore add capacity-provider --name MyCapacityProvider \
  --subnets <subnet-ids> --security-groups <security-group-ids> \
  --os LINUX_ARM64 --instance-types c7g.large
agentcore add agent --name MyManagedAgent --framework BedrockManagedAgents \
  --capacity-provider MyCapacityProvider

Em seguida, continue comEtapa 2: implantar. agentcore deploytambém cria o provedor de capacidade e sua função de operador.

• Use LINUX_ARM64 os tipos de instância Graviton e Graviton, porque a construção da imagem cria uma imagem ARM64.

• O provedor de capacidade fornece a rede. As sub-redes devem ter uma rota para o endpoint do Bedrock Managed Agents.

Para anexar um provedor de capacidade que não esteja no projeto, forneça seu ARN a. agentcore create --framework BedrockManagedAgents --capacity-provider <capacity-provider-arn> Consulte Instâncias de tempo de execução e provedores de capacidade.

Etapa 2: implantar

agentcore deploy
agentcore status

A CLI cria a imagem AWS CodeBuild em sua conta e implanta o Runtime e sua função de execução. O Bedrock Managed Agents invoca o Runtime para você.

Salve o ARN do tempo de execução da saída de: agentcore status

arn:aws:bedrock-agentcore:us-east-1:<account-id>:runtime/<runtime-id>

Etapa 3: Executar uma sessão

O Bedrock Managed Agents usa uma função de sessão para chamar o modelo e invocar seu Runtime. A função de sessão não é a função de execução do Runtime. Quando você executaclient.py, ele cria a função da sessão na sua conta. agentcore deploynão cria a função da sessão e agentcore remove não a exclui. Consulte A função da sessão.

Execute o cliente a partir do diretório do agente:

cd app/MyManagedAgent
uv run client.py --runtime <runtime-arn>

O cliente cria uma sessão e imprime o ID da sessão, cada comando com sua saída e a resposta do agente. Por padrão, o agente usa a acr-report habilidade para salvar acr-report.txt no espaço de trabalho.

A próxima seção mostra como o cliente gerencia a função da sessão e quais permissões do IAM você precisa para executar o cliente.

A função da sessão

A função de sessão não é a função de execução do Runtime. agentcore deploycria a função de execução compolicies/bma-acr-policy.json. O cliente atribui a função de sessão aos agentes gerenciados da Bedrock no role_arn campo ao criar uma sessão.

Quando você inicia uma nova sessão e não dá--role-arn, o cliente executa estas etapas:

1. Se a função BmaSessionRole-<region> não existir, o cliente a cria.

2. O cliente compara a política de confiança e a política embutida BmaSession da função com e. policies/bma-session-trust.json policies/bma-session-policy.json Se a política não for a mesma, o cliente grava o arquivo na função. Os arquivos são limitados à conta e à região do tempo de execução.

3. Se o cliente alterou a função, ele aguardará 15 segundos. O IAM precisa desse tempo antes que os agentes gerenciados da Bedrock possam usar a mudança.

Para alterar a função, altere os arquivos. O cliente não remove outras políticas que alguém adiciona à função. Ele não verifica a função quando você dá --session-id e não muda a função com a qual você dá--role-arn.

Para produção, atribua ao cliente uma função para um Runtime e um gateway com--role-arn. Para criar a função, use os dois arquivos empolicies/. Insira sua partição, região e ID da conta e altere o ID de entrada runtime/ e gateway/* para seu ID de tempo de execução e ID do gateway. Não altere os arquivos no projeto, pois todos os projetos na região são compartilhadosBmaSessionRole-<region>.

A identidade que executa o cliente precisa das permissões do cliente dos Bedrock Managed Agents e iam:PassRole da função da sessão. bedrock-mantle:CallWithBearerToken Para permitir que o cliente crie e repare a função, forneça tambémiam:GetRole,iam:CreateRole, iam:UpdateAssumeRolePolicyiam:GetRolePolicy, e assim iam:PutRolePolicy por diantearn:aws:iam::<account-id>:role/BmaSessionRole-*. Se você ceder--role-arn, o cliente não precisará dessas cinco permissões.

Para a política de confiança, as permissões da função de sessão e as permissões do cliente, consulte Funções de segurança e IAM no Guia do usuário do Amazon Bedrock.

Como o cliente trabalha

O cliente usa os client.beta.agents recursos do openai pacote. O Bedrock Managed Agents executa o ciclo de agentes.

Quando o cliente cria a sessão, ele define esses valores emenvironment:

• type-aws_bedrock_agentcore, que instrui os agentes gerenciados da Bedrock a usarem um AgentCore Runtime.

• runtime_arn- Seu tempo de execução. A sessão é executada na região do tempo de execução.

• workspace_directory- O diretório em que o agente executa seus comandos. O cliente usa/home/app/workspace. O servidor de ciclo de vida cria o diretório.

• runtime_qualifier- O endpoint do Runtime. O cliente usaDEFAULT.

• capability_directories- Os diretórios onde o Bedrock Managed Agents encontra habilidades. O cliente usa/opt/bma/plugins.

O cliente também define role_arn extra_body a função da sessão. O openai pacote não tem um parâmetro para esse campo.

O provide_token ajudante usa suas AWS credenciais para obter um token de portador Amazon Bedrock de curta duração para cada solicitação.

Se você adicionar um gateway ao projeto, forneça seu ARN a partir da saída de agentcore deploy with. --gateway Use o sinalizador somente para uma nova sessão. O cliente adiciona o gateway como uma mcp ferramenta com o ARN. connector_id Os agentes gerenciados da Bedrock chamam o gateway com a função de sessão. O gateway deve suportar a versão 2025-03-26 MCP. Caso contrário, o agente não recebe ferramentas de gateway e o Bedrock Managed Agents não mostra um erro.

"""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()

Etapa 4: continuar a sessão

Para enviar outra entrada para a mesma sessão, adicione o ID da sessão. O turno usa o mesmo espaço de trabalho. Para manter o espaço de trabalho após uma parada inativa, adicione o armazenamento da sessão como em. Mantenha os arquivos após uma parada inativa

uv run client.py --runtime <runtime-arn> --session-id <session-id> \
  --input "Run cat acr-report.txt and show the output."

Se a sessão não existir, o cliente cria uma nova sessão. Adicione --delete para excluir a sessão após o turno ou --raw para imprimir cada evento como JSON.

Mantenha os arquivos após uma parada inativa

Em um microVM Runtime, coloque o diretório inicial do servidor de execução no armazenamento da sessão. Em seguida, o espaço de trabalho, o estado da conexão e a CODEX_HOME permanência após uma parada ociosa.

1. Em vez do comando na Etapa 1, crie o projeto com o armazenamento da sessão:

   agentcore create --name MyManagedAgent --framework BedrockManagedAgents \
     --session-storage-mount-path /mnt/home
   cd MyManagedAgent

2. Emagentcore/agentcore.json, adicione essa variável à entrada do Runtime:

   "envVars": [{ "name": "BMA_HOME_DIR", "value": "/mnt/home" }]

3. Dentroclient.py, prontoWORKSPACE_DIRECTORY = "/mnt/home/workspace".

4. Implante e execute o cliente.

Para obter mais informações sobre armazenamento de sessões, consulte Configurações do sistema de arquivos para o AgentCore Runtime.

Etapa 5: (opcional) adicionar habilidades

Para adicionar uma habilidade à imagem, adicione um plug-in plugins/ e implante. Um plugin tem um .codex-plugin/plugin.json arquivo e um skills/ diretório. O skills/ diretório tem um subdiretório para cada habilidade, com um SKILL.md arquivo nele. A imagem é copiada para/opt/bma/plugins, que o cliente já fornece aos agentes gerenciados da Bedrock.

Para começarplugins/acr-report/, copie e renomeie o diretório do plug-in e skills/acr-report/ o nome do seu plug-in e sua habilidade. Em plugin.jsonname, defina versiondescription,, "skills": "./skills/" e. Cada um SKILL.md começa com um conteúdo inicial que tem name description e. Após a implantação, inicie uma nova sessão com--input "Use the <skill-name> skill to …​".

Compartilhe habilidades de um bucket do Amazon S3

Monte um ponto de acesso do S3 Files no Runtime. Então, as habilidades mudam quando o bucket muda e a imagem permanece a mesma. Para o sistema de arquivos do S3 Files, o ponto de acesso e as regras do grupo de segurança, consulte Configurações do sistema de arquivos para AgentCore o Runtime.

Uma montagem de arquivos S3 precisa de um Runtime no modo de rede VPC. Crie o projeto com as opções de rede emImplante o Runtime em uma VPC.

No bucket, coloque cada plug-in em seu próprio diretório sob o diretório raiz do ponto de acesso. Use o mesmo layout deplugins/acr-report/: <plugin>/.codex-plugin/plugin.json <plugin>/skills/<skill>/SKILL.md e.

Adicione a montagem à entrada do Runtime emagentcore/agentcore.json:

{
  "filesystemConfigurations": [
    {
      "s3FilesAccessPoint": {
        "accessPointArn": "arn:aws:s3files:us-east-1:111122223333:file-system/fs-0123456789abcdef0/access-point/fsap-0123456789abcdef0",
        "mountPath": "/mnt/skills"
      }
    }
  ]
}

Em seguida["/opt/bma/plugins", "/mnt/skills"], client.py configure CAPABILITY_DIRECTORIES e implante.

Etapa 6: Exibir registros e rastreamentos

agentcore logs --since 15m

A primeira implantação ativa a Pesquisa de CloudWatch Transações em sua conta. Os traços aparecem após cerca de 10 minutos. Para ver os traços, abra o CloudWatch console e escolha GenAI Observability. Cada chamada dos agentes gerenciados da Bedrock para o servidor de ciclo de vida tem um período. bma.invocation Para obter mais informações, consulte Visualizar dados de observabilidade para seus agentes do Amazon Bedrock AgentCore .

As configurações de pesquisa de transações se aplicam a toda a conta

A Pesquisa de Transações e sua indexação de abrangência se aplicam a toda a conta na região, e cobranças adicionais podem ser aplicadas. Para manter suas configurações atuais, "disableTransactionSearch": true adicione-as ~/.agentcore/config.json antes de implantar.

Etapa 7: atualizar e reimplantar

Altere as configurações de agentcore/agentcore.json tempo de execução ou os arquivos da imagem e implante novamente. Por exemplo, essa configuração interrompe uma sessão ociosa após 10 minutos. Os valores estão em segundos.

{
  "lifecycleConfiguration": {
    "idleRuntimeSessionTimeout": 600,
    "maxLifetime": 28800
  }
}

agentcore deploy

As alterações se aplicam às novas sessões.

Variáveis de ambiente do servidor de ciclo de vida

Adicione uma variável envVars na entrada do Runtime, por exemplo{ "name": "DISABLE_ADOT_OBSERVABILITY", "value": "true" }.

Variável	Padrão	Description
DISABLE_ADOT_OBSERVABILITY	Não definido	Defina como true para desativar os rastreamentos e os registros do servidor executivo. O servidor de ciclo de vida ainda grava seus próprios registros no grupo de registros do Runtime.
BMA_HOME_DIR	/home/app	HOMEdo servidor de execução.
BMA_STATE_DIR	.bma no BMA_HOME_DIR	O diretório destate.json, que mantém o estado da conexão da sessão.
BMA_CODEX_HOME	.codex no BMA_HOME_DIR	CODEX_HOMEdo servidor de execução.
BMA_CODEX_BINARY	/opt/bma/bin/codex	O binário do Codex.
BMA_MAX_TURN_LEASE	300	O contrato de locação mais longo, em segundos.

Cada compilação de imagem instala a versão mais recente do Codex. O servidor de ciclo de vida precisa do Codex 0.154.0 ou posterior. Para fixar uma liberação, adicione ao CODEX_RELEASE=<version> CODEX_NON_INTERACTIVE=1 lado doDockerfile.

Etapa 8: Limpeza

Para excluir uma sessão, adicione-a --delete à última execução do cliente para essa sessão. Em seguida, remova os recursos do projeto e implante para excluir o Runtime, sua função de execução e a pilha.

agentcore remove all
agentcore deploy

A implantação não exclui esses recursos:

• Os CloudWatch registros registram grupos do Runtime, do CodeBuild projeto que cria a imagem e da função Lambda que inicia a construção.

• A chave AWS KMS do repositório Amazon ECR. A chave permanece no estado Exclusão pendente por 30 dias e, em seguida, o AWS KMS a exclui.

• A CDKToolkit pilha, se a primeira implantação inicializasse a conta e a região. Outros aplicativos AWS CDK podem usar essa pilha. Exclua-o somente se nenhum outro aplicativo o usar.

• As configurações da Pesquisa de Transações da Etapa 6.

• A função da sessão client.py criada na Etapa 3.

Para excluir a função da sessão, execute estes comandos:

aws iam delete-role-policy --role-name BmaSessionRole-<region> --policy-name BmaSession
aws iam delete-role --role-name BmaSessionRole-<region>

Para encontrar os grupos de registros, execute esses comandos. Em seguida, exclua cada grupo de registros.

aws logs describe-log-groups --log-group-name-prefix /aws/bedrock-agentcore/runtimes/<project-name>_<agent-name>- --query 'logGroups[].logGroupName'
aws logs describe-log-groups --log-group-name-prefix /aws/codebuild/AgentCore-<project-name>-<target-name>- --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 <log-group-name>

Substitua esses valores:

• <project-name>- O nome do projeto. Na Etapa 1, éMyManagedAgent.

• <agent-name>- O nome do agente. Na Etapa 1, também éMyManagedAgent.

• <target-name>- O nome do alvo de implantação emagentcore/aws-targets.json. O padrão é default. Nos CodeBuild nomes, cada sublinhado (_) no nome do projeto e no nome do destino muda para um hífen ()-.

O nome do grupo de registros do Lambda é abreviado, como neste exemplo:

/aws/lambda/AgentCore-MyManagedAgent--ApplicationAgentMyManage-<suffix>

O comando lista os grupos de log do Lambda de todos os projetos de AgentCore CLI na região. Exclua somente os grupos de registros do seu projeto.

Se você adicionou outros recursos ao projeto, como um gateway ou uma memória, verifique se a implantação os excluiu.

Recursos relacionados

• Use a AgentCore CLI

• Definir as configurações do ciclo de vida

• Configurações do sistema de arquivos para AgentCore Runtime

• Configurar AgentCore para VPC

• Instâncias de tempo de execução e provedores de capacidade

• Visualize dados de observabilidade para seus agentes do Amazon Bedrock AgentCore