Composants clés Versions de plateforme Authentification et sécurité Fonctionnalités supplémentaires Aperçu de l'implémentation

MicroVM

Amazon Bedrock AgentCore Runtime gère l'évolutivité, la gestion des sessions, l'isolation de sécurité et la gestion de l'infrastructure, ce qui vous permet de vous concentrer sur la création d'expériences intelligentes pour les agents plutôt que sur la complexité opérationnelle. En tirant parti des fonctionnalités et capacités décrites ici, vous pouvez créer, déployer et gérer des agents d'IA sophistiqués qui apportent de la valeur à vos utilisateurs tout en contribuant à maintenir une sécurité et une fiabilité de niveau professionnel.

Composants clés

AgentCore Temps d'exécution

Un AgentCore Runtime est le composant fondamental qui héberge le code de votre agent ou outil d'IA. Il s'agit d'une application conteneurisée qui traite les entrées des utilisateurs, gère le contexte et exécute des actions à l'aide des fonctionnalités de l'IA. Lorsque vous créez un agent, vous définissez son comportement, ses fonctionnalités et les outils auxquels il peut accéder. Par exemple, un agent du service client peut répondre à des questions sur les produits, traiter les retours et transmettre des problèmes complexes à des représentants humains.

Vous pouvez créer et déployer des agents sur AgentCore Runtime à l'aide de la AgentCore CLI, du SDK AgentCore Python ou directement via des AWS SDK. Avec le SDK AgentCore Python, vous pouvez définir votre agent à l'aide de frameworks populaires tels que LangGraph CrewAI ou Strands Agents. Le SDK gère les complexités de l'infrastructure, vous permettant de vous concentrer sur la logique et les fonctionnalités de l'agent.

À chaque AgentCore exécution :

Possède une identité unique
Est versionné pour permettre un déploiement contrôlé et des mises à jour

Versions

Chaque AgentCore environnement d'exécution gère des versions immuables qui capturent un instantané complet de la configuration à un moment précis :

Lorsque vous créez un AgentCore Runtime, la version 1 (V1) est automatiquement créée
Chaque mise à jour de la configuration (image du conteneur, paramètres de protocole, paramètres réseau) crée une nouvelle version
Chaque version contient toutes les configurations nécessaires à l'exécution

Ce système de gestion des versions fournit un historique de déploiement fiable et des fonctionnalités de restauration.

Points de terminaison

Les points de terminaison fournissent des points d'accès adressables à des versions spécifiques de votre AgentCore environnement d'exécution. Chaque point de terminaison :

Possède un ARN unique pour l'invocation
Fait référence à une version spécifique de votre agent Runtime
Fournit un accès stable à votre agent même lorsque vous mettez à jour les implémentations

Informations clés sur les terminaux :

Le point de terminaison « DEFAULT » est automatiquement créé lorsque vous appelez CreateAgentRuntime et pointe vers la dernière version
Lorsque vous mettez à jour votre AgentCore Runtime, une nouvelle version est créée mais le DEFAULT point de terminaison est automatiquement mis à jour pour y faire référence
Vous pouvez créer des points de terminaison personnalisés avec l'CreateAgentRuntimeEndpointopération pour différents environnements (dev, test, prod)
Lorsqu'un utilisateur adresse une demande à un point de terminaison, la demande est résolue selon la version d'agent spécifique référencée par ce point de terminaison

Les terminaux ont des états de cycle de vie distincts :

CREATING- État initial lors de la création du terminal
CREATE_FAILED- Indique un échec de création dû à des autorisations ou à d'autres problèmes
READY- Le point de terminaison est opérationnel et accepte les demandes
UPDATING- Le point de terminaison est en cours de modification pour faire référence à une nouvelle version
UPDATE_FAILED- Indique l'échec de la mise à jour

Vous pouvez mettre à jour les points de terminaison sans interruption, ce qui permet des transitions de version et des annulations fluides.

Séances

Les sessions représentent des contextes d'interaction individuels entre les utilisateurs et votre AgentCore environnement d'exécution. À chaque session :

Est identifié par un numéro unique runtimeSessionId fourni par votre application, ou par le Runtime lui-même lors du premier appel si le champ runtimeSessionId est laissé vide
S'exécute dans une microVM dédiée avec des ressources de processeur, de mémoire et de système de fichiers complètement isolées
Préserve le contexte de plusieurs interactions au sein d'une même conversation
Peut persister jusqu'à 8 heures d'autonomie totale

Les états de session incluent :

Actif : traitement d'une demande ou exécution de tâches en arrière-plan
Inactif : ne traite aucune demande mais conserve le contexte en attendant la prochaine interaction
Terminée : session terminée en raison d'une inactivité (15 minutes), d'une durée de vie maximale atteinte (8 heures) ou d'une mauvaise santé

Caractéristiques importantes de la session :

Après la fin de la session, l'intégralité de la microVM est arrêtée et la mémoire est nettoyée
Une demande ultérieure portant le même résultat runtimeSessionId après la résiliation créera un nouvel environnement d'exécution.
L'isolation des sessions empêche la contamination des données entre les sessions et garantit la sécurité
L'état de session est éphémère et ne doit pas être utilisé pour une durabilité à long terme (utilisez la AgentCore mémoire pour la durabilité du contexte)

Cette isolation complète entre les sessions est cruciale pour la sécurité de l'entreprise, en particulier lorsqu'il s'agit de processus d'IA non déterministes.

Versions de plateforme

Une version de plateforme contrôle la façon dont AgentCore Runtime démarre votre agent. Vous le définissez à l'aide du platformVersion champ (V1ouV2) sur chaque exécution de l'agent. V1 est la valeur par défaut. La version de la plateforme s'applique à l'environnement d'exécution de l'agent lui-même ; elle est distincte des versions d'exécution qui capturent l'historique de votre configuration.

Amazon Bedrock AgentCore Runtime V2 démarre votre agent à partir d'un instantané, ce qui permet des démarrages à froid rapides et cohérents, indépendamment de la simultanéité ou de la taille de l'image. AgentCore Runtime prépare votre environnement une seule fois et en prend un instantané, puis restaure cet instantané pour chaque nouvelle instance au lieu d'initialiser votre environnement à chaque démarrage.

Démarrages à froid réguliers: La V2 garantit une latence de démarrage à froid constante indépendamment de la simultanéité ou de la taille de l'image, car chaque instance restaure un instantané préparé au lieu d'initialiser votre environnement. Cela est particulièrement important pour les images de conteneurs de grande taille, qui sont par ailleurs lentes à charger à chaque démarrage à froid.
Réduction des coûts pour les agents actifs en permanence ou en cas d'urgence: La V2 facture en fonction de ce que votre agent utilise activement. AgentCore Runtime récupère de la mémoire au fur et à mesure que votre agent la libère, et réduit la charge de la plateforme.

Note

La restauration à partir d'un instantané modifie la façon dont vous structurez le code de votre agent. Pour savoir comment optimiser votre agent et tirer le meilleur parti de la version V2 de la plateforme, consultez Optimiser votre agent pour AgentCore Runtime V2.

Régions prises en charge

La V2 est disponible dans les AWS régions suivantes :

USA Est (Virginie du Nord), us-east-1
Est des États-Unis (Ohio), us-east-2
Ouest des États-Unis (Oregon), us-west-2
Europe (Irlande), eu-west-1
Asie-Pacifique (Tokyo), ap-northeast-1

Activer la V2

Vous définissez la version de la plateforme pour chaque environnement d'exécution de l'agent. Configurez-le lorsque vous créez un environnement d'exécution ou mettez à jour un environnement d'exécution existant pour le déplacer entre les versions de la plateforme. Si vous omettez platformVersion lors de la création d'un environnement d'exécution, celui-ci utilise la version V1. Si vous l'omettez lorsque vous mettez à jour un environnement d'exécution, celui-ci conserve sa version de plate-forme actuelle.

Exemple

AWS Management Console

Ouvrez la AgentCore console Amazon Bedrock et choisissez Runtime.
Sur la page Runtime, choisissez Create runtime.
Entrez le nom de l'agent ou de l'outil.
Pour Type de calcul, choisissez MicroVMS.
Sous Agent/tool source, choisissez votre type de source et indiquez l'artefact, tel qu'un URI d'image de conteneur ou votre code.
Pour la version Platform, choisissez V2.
(Facultatif) Configurez l'authentification entrante, les configurations avancées et les autorisations , telles que le rôle d'exécution IAM et la clé de chiffrement KMS.
Choisissez Créer un environnement d'exécution. AgentCore crée la version 1 de l'exécution de l'agent et un DEFAULT point de terminaison qui pointe vers celle-ci.

AWS CLI

Réglez --platform-version V2 sur la create-agent-runtime commande.


aws bedrock-agentcore-control create-agent-runtime \
  --agent-runtime-name "my-agent" \
  --role-arn "arn:aws:iam::111122223333:role/AgentExecutionRole" \
  --agent-runtime-artifact '{
    "containerConfiguration": {
      "containerUri": "111122223333.dkr.ecr.us-west-2.amazonaws.com/my-agent:latest"
    }
  }' \
  --network-configuration '{"networkMode": "PUBLIC"}' \
  --platform-version V2

Pour confirmer la version de la plateforme, appelezget-agent-runtime.


aws bedrock-agentcore-control get-agent-runtime \
  --agent-runtime-id my-agent-ABCDE12345 \
  --query platformVersion

AWS SDK

L'exemple suivant utilise boto3 pour créer un environnement d'exécution d'agent sur la V2.


import boto3

client = boto3.client("bedrock-agentcore-control", region_name="us-west-2")

client.create_agent_runtime(
    agentRuntimeName="my-agent",
    roleArn="arn:aws:iam::111122223333:role/AgentExecutionRole",
    agentRuntimeArtifact={
        "containerConfiguration": {
            "containerUri": "111122223333.dkr.ecr.us-west-2.amazonaws.com/my-agent:latest"
        }
    },
    networkConfiguration={"networkMode": "PUBLIC"},
    platformVersion="V2",
)

La create_agent_runtime réponse n'est pas renvoyéeplatformVersion. Appelez get_agent_runtime pour le confirmer.

À quoi s'attendre

Une opération de création ou de mise à jour V2 prépare et capture un instantané de votre environnement, de sorte qu'il se comporte différemment de la V1.

La création et la mise à jour prennent quelques minutes

Sur la V1, le temps d'exécution atteint READY en quelques secondes. Sur la V2, la préparation de l'instantané entraîne un coût unique, et la création et la mise à jour s'exécutent pendant plusieurs minutes avant la fin de l'exécutionREADY.

Votre contenant doit être déclaré en bon état dans les 120 secondes

AgentCore Runtime prend un instantané de la première /ping réponse saine. Ne signalez l'état de santé /ping qu'une fois l'initialisation terminée, afin que le snapshot capture un agent entièrement initialisé. Si le moteur d'exécution n'indique pas qu'il est en bon état dans les 120 secondes suivant le démarrage, la création échoue et une erreur de vérification de l'état s'affiche.

Sondage pour l'état d'un terminal

Les update opérations create et sont renvoyées pendant que l'exécution est immobile CREATING ouUPDATING. Si vous appelez update ou delete avant que le moteur d'exécution n'atteigne un état terminal, l'opération est renvoyéeConflictException. Effectuez un sondage get_agent_runtime jusqu'à ce que le statut soit atteint READY ou qu'il soit terminéFAILED, et attendez quelques minutes pour qu'une version V2 atteigne son objectifREADY.


import time

def wait_until_ready(client, agent_runtime_id):
    while True:
        status = client.get_agent_runtime(agentRuntimeId=agent_runtime_id)["status"]
        if status == "READY" or status.endswith("FAILED"):
            return status
        time.sleep(5)

Note

La V2 limite actuellement la taille totale des variables d'environnement de votre agent à 1,5 Ko pour les déploiements de code directs et à 2,5 Ko pour les agents de conteneur, contre 4 Ko sur la V1. Si votre configuration dépasse cette limite, la demande échoue avec unValidationException. AgentCore Runtime augmentera cette limite pour correspondre à la V1.

Cycle de vie du snapshot

Sur la V2, AgentCore Runtime gère un instantané pour chaque version d'exécution vers laquelle pointe un endpoint. Vous ne créez ni ne supprimez des instantanés directement. Ils suivent les modifications apportées à votre environnement d'exécution et à vos terminaux.

Créé: AgentCore Runtime prépare un instantané lorsqu'un point de terminaison pointe vers une version. Lorsque vous créez un environnement d'exécution, AgentCore Runtime héberge votre version sur le terminal par défaut et prépare son instantané. Un environnement d'exécution peut avoir plusieurs points de terminaison pointant vers différentes versions, de sorte qu'un environnement d'exécution peut avoir plusieurs instantanés à la fois.
Mis à jour: Lorsque vous mettez à jour un environnement d' AgentCore exécution, Runtime héberge la nouvelle version sur le terminal par défaut et prépare un nouveau snapshot. La version précédemment hébergée n'étant plus référencée, AgentCore Runtime marque son instantané pour suppression et le supprime à la fin des sessions existantes.
Supprimé: AgentCore Runtime supprime un instantané lorsqu'aucun point de terminaison ne pointe vers celui-ci. Cela se produit lorsque vous mettez à jour un environnement d'exécution, supprimez la référence d'un point de terminaison à une version ou supprimez le moteur d'exécution ou un point de terminaison d'exécution. La suppression peut prendre jusqu'à 8 heures, soit la durée de vie maximale de la session, car les sessions déjà en cours d'exécution sur le snapshot se poursuivent jusqu'à leur fin.

Infrastructure en tant que code

AWS CloudFormation et le AWS CDK ne prennent pas en charge le réglage platformVersion actuellement.

Authentification et sécurité

L'authentification entrante contrôle qui peut accéder à vos agents via la gestion des AWS identités et des accès ou OAuth 2.0, en validant les jetons du porteur auprès des fournisseurs d'identité avant d'autoriser le traitement des demandes. L'authentification sortante permet à vos agents d'accéder en toute sécurité à des services tiers à l'aide de clés OAuth ou API, l' AgentCore identité gérant les informations d'identification en mode délégué par l'utilisateur ou autonome. Pour plus d'informations, consultez Authentification et autorisation avec Inbound Auth et Outbound Auth.

Authentification entrante

L'authentification entrante, optimisée par AgentCore Identity, contrôle qui peut accéder à vos agents ou outils et les invoquer dans Runtime. AgentCore

Méthodes d’authentification

AWS IAM (Sigv4) : utilise des AWS informations d'identification pour la vérification d'identité
OAuth 2.0 : s'intègre aux fournisseurs d'identité externes

Options de configuration OAuth

URL de découverte : point de terminaison de découverte OpenID Connect de votre fournisseur d'identité
Audiences autorisées : liste des valeurs d'audience valides que vos jetons doivent contenir
Clients autorisés : liste des identifiants clients pouvant accéder à cet agent

Flux d'authentification

Les utilisateurs finaux s'authentifient auprès de votre fournisseur d'identité (Amazon Cognito, Okta, Microsoft Entra ID)
Votre application cliente reçoit un jeton porteur après une authentification réussie
Le client transmet ce jeton dans l'en-tête d'autorisation lors de l'appel de l'agent
AgentCore Runtime valide le jeton auprès du serveur d'autorisation
Si elle est valide, la demande est traitée ; si elle n'est pas valide, elle est rejetée

Cela garantit que seuls les utilisateurs authentifiés disposant des autorisations appropriées peuvent accéder à vos agents.

Authentification sortante

Outbound Auth, optimisé par Amazon Bedrock AgentCore Identity, permet à vos agents hébergés sur AgentCore Runtime d'accéder en toute sécurité à des services tiers :

Méthodes d’authentification

OAuth : pour les services prenant en charge les flux OAuth
Clés d'API : pour les services utilisant l'authentification par clé

Modes d'authentification

User-delegated: Agir au nom de l'utilisateur final avec ses informations d'identification
Autonome : agir de manière indépendante avec des informations d'identification relatives au niveau de service

Services pris en charge

Systèmes d'entreprise tels que Slack, Zoom et GitHub
AWS services
API et sources de données personnalisées

AgentCore Identity gère ces informations d'identification en toute sécurité, empêchant ainsi leur exposition dans le code ou les journaux de votre agent.

Fonctionnalités supplémentaires

Traitement asynchrone

AgentCore Runtime prend en charge les charges de travail de longue durée grâce à :

Gestion des tâches en arrière-plan pour les opérations dépassant les request/response cycles
Suivi automatique de l'état via le /ping terminal
Assistance pour les opérations d'une durée maximale de 8 heures

Pour plus d'informations, consultez Gérer les agents asynchrones et de longue durée avec Amazon AgentCore Bedrock Runtime.

Réponses en streaming

Les agents peuvent diffuser des résultats partiels dès qu'ils sont disponibles, plutôt que d'attendre la fin du traitement. Cela vous permet de proposer une expérience utilisateur plus réactive, en particulier pour les opérations qui génèrent de grandes quantités de contenu ou qui prennent beaucoup de temps. Pour plus d'informations, consultez la section Réponses des agents de diffusion.

WebSocket API

Le AgentCore Runtime WebSocket prend en charge les connexions de streaming bidirectionnelles en temps réel pour la communication interactive des agents. Cela permet aux agents de bénéficier d'expériences plus réactives et interactives. Pour plus d'informations, voir Commencer à utiliser le streaming bidirectionnel à l'aide WebSocket de.

Support du protocole

AgentCore Runtime prend en charge plusieurs protocoles de communication :

HTTP : points de terminaison directs de l'API REST pour les request/response modèles traditionnels. Pour plus d'informations, consultez la section Commencer à utiliser l' AgentCore interface de ligne de commande.
MCP : Model Context Protocol pour les outils et les serveurs d'agents. Pour plus d'informations, voir Déployer des serveurs MCP dans AgentCore Runtime.
A2A : Agent-to-Agent protocole de communication et de découverte multi-agents. Pour plus d'informations, voir Déployer des serveurs A2A dans AgentCore Runtime.

Aperçu de l'implémentation

Voici comment démarrer avec le AgentCore Runtime. Pour l'exemple complet, voir Commencer à utiliser l' AgentCore interface de ligne de commande.

Préparez le code de votre agent ou de votre outil

Définissez la logique de votre agent à l'aide de n'importe quel framework d'IA ou code personnalisé
Ajoutez les points de terminaison HTTP requis à l'aide du AgentCore SDK ou d'une implémentation personnalisée
Dépendances des packages dans un fichier requirements.txt

Déployez votre agent ou votre outil

Créez et transférez une image de conteneur vers Amazon ECR directement ou via le SDK AgentCore
Création d'un AgentCore environnement d'exécution à l'aide de l'image du conteneur
La version initiale (V1) et le point de terminaison DEFAULT sont créés automatiquement

Invoquez votre agent ou votre outil

Générez un identifiant de session unique pour chaque conversation utilisateur
Appelez l'InvokeAgentRuntimeWithWebSocketStreamopération InvokeAgentRuntime or à l'aide de l'ARN et de l'ID de session de votre agent
Transmettre les données saisies par l'utilisateur dans la charge utile de la demande

Gérez et observez les sessions, et effectuez des mises à jour

Utilisez le même identifiant de session pour les interactions de suivi afin de maintenir le contexte
Passez en revue les journaux, les traces et les mesures d'observabilité
Déployez les mises à jour en modifiant votre AgentCore environnement d'exécution (crée de nouvelles versions)
Contrôlez le déploiement en mettant à jour les points de terminaison pour indiquer les nouvelles versions

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Comment ça marche

instances