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 con AgentCore Gateway
En esta guía de inicio rápido, aprenderá a configurar una puerta de enlace e integrarla en sus agentes mediante la AgentCore CLI. Para obtener guías y ejemplos más completos, consulte el GitHub repositorio [ de ](https://github.com/awslabs/amazon-bedrock-agentcore-samples/tree/main/01-features/07-centralize-and-govern-your-ai-infrastructure/01-gateway) Amazon Bedrock AgentCore Gateway.
**nota**
La AgentCore CLI proporciona tanto comandos como un asistente de TUI interactivo para administrar los recursos de AgentCore Gateway. Para ver la referencia completa de la API del AWS SDK, consulta las operaciones del plano [ AgentCore de control. ](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock-agentcore-control.html)
**Topics**
+ [Requisitos previos](#gateway-quick-start-prereqs)
+ [Paso 1: Configurar e instalar](#gateway-quick-start-setup)
+ [Paso 2: Crear una puerta de enlace](#gateway-quick-start-create-gateway-setup)
+ [Paso 3: Ejecute la configuración](#gateway-quick-start-run-setup)
+ [Paso 4: Utilice la puerta de enlace con un agente](#gateway-quick-start-use-gateway-with-agents)
+ [¿Qué has construido](#gateway-quick-start-what-youve-built)
+ [Resolución de problemas](#gateway-quick-start-troubleshooting)
+ [Validación rápida](#gateway-quick-start-quick-validation)
+ [Limpieza](#gateway-quick-start-cleanup)
+ [Siguientes pasos](#gateway-quick-start-next-steps)
## Requisitos previos
Antes de empezar, asegúrate de tener lo siguiente:
+ ** AWS Cuenta ** con credenciales configuradas. Para configurar las credenciales, puede instalar y usar la interfaz de línea de AWS comandos siguiendo los pasos que se indican en [ Primeros pasos con la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
+ **Node.js Más de 20 ** instalados (para la AgentCore CLI).
+ **Python 3.10\+ ** instalado (para el script del agente).
+ **Permisos de IAM ** para crear roles, funciones de Lambda y usar Amazon Bedrock. AgentCore
+ **Acceso modelo. ** Amazon Bedrock permite el acceso a los modelos básicos de forma predeterminada. Para usar un modelo que no sea básico, siga los pasos de acceso al [ modelo. ](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-sdk-step4)
## Paso 1: Configurar e instalar
Instale la AgentCore CLI de forma global:
```
npm install -g @aws/agentcore
```
Cree un nuevo AgentCore proyecto con un agente y una puerta de enlace:
**Example**
1.
```
agentcore create --project-name MyGatewayProject --name MyGatewayAgent \
--language Python --framework Strands --model-provider Bedrock --memory none
cd MyGatewayProject
```
Estas opciones crean un agente de Python Strands que utiliza Amazon Bedrock y no tiene memoria. También puede ejecutar `agentcore create` sin opciones y seleccionar ** Agente ** en el asistente interactivo.
1. También puede ejecutar `agentcore create` sin marcas para utilizar el asistente interactivo. El asistente lo guía para seleccionar el nombre del proyecto, el marco del agente, el proveedor de modelos y otras opciones.
## Paso 2: Crear una puerta de enlace
Agregue una puerta de enlace y un destino a su proyecto mediante la AgentCore CLI:
**Example**
1.
```
# Add a gateway with no inbound auth (simplest for getting started)
agentcore add gateway --name TestGateway --authorizer-type NONE --runtimes MyGatewayAgent
# Add a Lambda function target
agentcore add gateway-target --name TestLambdaTarget --type lambda-function-arn \
--lambda-arn \
--tool-schema-file tools.json \
--gateway TestGateway
```
1. Ejecute `agentcore` para abrir la TUI y, a continuación, seleccione ** agregar ** y elija ** Gateway**:
1. Introduzca el nombre de la puerta de enlace:
1. Seleccione el tipo de autorizador. Para este inicio rápido, elige ** NINGUNO: **
1. Configure las opciones avanzadas o acepte las predeterminadas:
1. Revise la configuración y pulse ** Entrar ** para confirmar:
A continuación, seleccione ** agregar de ** nuevo y elija ** Gateway Target ** para agregar un objetivo de función Lambda:
1. Introduzca el nombre del objetivo.
1. Seleccione la función ** Lambda ** como tipo de objetivo:
1. Introduzca el ARN de Lambda y la ruta del archivo del esquema de la herramienta y, a continuación, confirme.
Para usar la JWT-based autorización en su lugar, especifique `--authorizer-type CUSTOM_JWT` con la URL de detección de OAuth:
**Example**
1.
```
agentcore add gateway --name TestGateway \
--authorizer-type CUSTOM_JWT \
--discovery-url https://cognito-idp.us-east-1.amazonaws.com//.well-known/openid-configuration \
--allowed-audience \
--runtimes MyGatewayAgent
```
1. Ejecuta `agentcore` para abrir la TUI y, a continuación, selecciona ** Agregar ** y elige Gateway. ** ** Cuando se te pida el tipo de autorizador, selecciona JWT ** personalizado: **
1. Introduzca el nombre de la puerta de enlace:
1. Seleccione JWT ** personalizado ** como tipo de autorizador:
1. Introduzca la URL de detección de OAuth y el público permitido cuando se le solicite.
1. Configure las opciones avanzadas o acepte las opciones predeterminadas:
1. Revise la configuración y pulse ** Entrar ** para confirmar:
## Paso 3: Ejecute la configuración
Implemente su proyecto para AWS:
```
agentcore deploy
```
La CLI sintetiza una pila de AWS CDK e implementa la puerta de enlace, los objetivos y el agente en Amazon Bedrock. AgentCore Este proceso tarda entre 2 y 3 minutos.
## Paso 4: Utilice la puerta de enlace con un agente
Recupere la URL de su puerta de enlace mediante la AgentCore CLI:
```
agentcore status
```
Cree un nuevo archivo llamado `run_agent.py` e inserte el siguiente código. Instale primero las dependencias de Python:
```
pip install strands-agents mcp
```
```
"""
Agent script to test the Gateway
Run this after setup: python run_agent.py
"""
from strands import Agent
from strands.models import BedrockModel
from strands.tools.mcp.mcp_client import MCPClient
from mcp.client.streamable_http import streamablehttp_client
import json
import sys
def create_streamable_http_transport(mcp_url: str):
return streamablehttp_client(mcp_url)
def get_full_tools_list(client):
"""Get all tools with pagination support"""
more_tools = True
tools = []
pagination_token = None
while more_tools:
tmp_tools = client.list_tools_sync(pagination_token=pagination_token)
tools.extend(tmp_tools)
if tmp_tools.pagination_token is None:
more_tools = False
else:
more_tools = True
pagination_token = tmp_tools.pagination_token
return tools
def run_agent():
# Get the gateway URL from agentcore status
gateway_url = "" # Replace with URL from 'agentcore status'
# Model configuration - change if needed
model_id = "anthropic.claude-3-7-sonnet-20250219-v1:0"
print("Starting AgentCore Gateway Test Agent")
print(f"Gateway URL: {gateway_url}")
print(f"Model: {model_id}")
print("-" * 60)
# Setup Bedrock model
bedrockmodel = BedrockModel(
model_id=model_id,
streaming=True,
)
# Setup MCP client (no auth token needed for NONE authorizer)
mcp_client = MCPClient(lambda: create_streamable_http_transport(gateway_url))
with mcp_client:
# List available tools
tools = get_full_tools_list(mcp_client)
print(f"\nAvailable tools: {[tool.tool_name for tool in tools]}")
print("-" * 60)
# Create agent
agent = Agent(model=bedrockmodel, tools=tools)
# Interactive loop
print("\nInteractive Agent Ready!")
print("Try asking: 'What's the weather in Seattle?'")
print("Type 'exit', 'quit', or 'bye' to end.\n")
while True:
user_input = input("You: ")
if user_input.lower() in ["exit", "quit", "bye"]:
print("Goodbye!")
break
print("\nThinking...\n")
response = agent(user_input)
print(f"\nAgent: {response.message.get('content', response)}\n")
if __name__ == "__main__":
run_agent()
```
### Ejecute su agente
Pruebe su puerta de enlace ejecutando el agente e interactuando con las herramientas.
```
python run_agent.py
```
¡Eso es\! El agente empezará y podrás hacer preguntas como:
+ «¿Qué tiempo hace en Seattle?»
+ «¿Qué hora es en Nueva York?»
## ¿Qué has construido
Mediante este tutorial de introducción, ha creado los siguientes recursos:
+ **Servidor MCP (puerta de enlace)**: un punto final administrado en `https://gateway-id.gateway.bedrock-agentcore.region.amazonaws.com/mcp`
+ **Herramientas Lambda**: funciones simuladas que devuelven datos de prueba (clima: «72 °F, soleado», hora: «2:30 p.m.»)
+ **Agente de IA**: Claude-powered asistente que puede descubrir y usar tus herramientas
## Resolución de problemas
La siguiente tabla muestra algunos problemas posibles y sus soluciones:
| Problema | Solución |
| --- | --- |
| «No hay ningún módulo llamado 'strands'» | Ejecute: `pip install strands-agents` |
| «Acceso al modelo denegado» | Amazon Bedrock permite el acceso a los modelos básicos de forma predeterminada. Para un modelo que no sea básico, siga los pasos de acceso al [ modelo. ](https://docs.aws.amazon.com/bedrock/latest/userguide/model-access.html#model-access-sdk-step4) |
| "AccessDeniedException" | Compruebe los permisos de IAM para bedrock-agentcore: \* |
| Gateway no responde | Espere entre 30 y 60 segundos después de la creación para que se propague el DNS |
## Validación rápida
Ejecute los siguientes comandos en una terminal para comprobar que la puerta de enlace funciona.
```
# Check your Gateway is working
curl -X POST YOUR_GATEWAY_URL \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
# Watch live logs
aws logs tail /aws/bedrock-agentcore/gateways/YOUR_GATEWAY_ID --follow
```
## Limpieza
Para eliminar la puerta de enlace y sus objetivos de tu proyecto:
```
agentcore remove gateway --name TestGateway
```
Para eliminar todos los recursos y volver a distribuirlos:
```
agentcore remove all
agentcore deploy
```
## Siguientes pasos
+ **Herramientas Lambda personalizadas**: cree funciones de Lambda con su lógica empresarial
+ **Agregue sus propias API**: amplíe su puerta de enlace con las especificaciones de OpenAPI para servicios reales
+ **Configuración de producción**: configure los puntos finales, los dominios personalizados y la supervisión de la VPC