

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation de Lambda MicroVMS comme sandbox pour les agents Cursor Cloud

Vous pouvez utiliser les AWS Lambda microVM comme machines auto-hébergées pour vos agents Cursor Cloud, en conservant les référentiels, l'exécution des outils et l'accès au réseau dans l'infrastructure que vous contrôlez. Le curseur héberge la boucle et le modèle de l'agent ; la microVM Lambda est l'endroit où le travailleur réclame les demandes de pool et exécute les appels d'outils. Ce modèle vous permet de contrôler l'environnement d'exécution : ce qui est installé dans l'image, quel accès réseau est disponible et quelles AWS ressources le rôle IAM du collaborateur peut atteindre.

Chaque microVM est une machine Firecracker-isolated virtuelle dont le démarrage est basé sur des instantanés. Elle fonctionne pendant 8 heures au maximum et s'arrête à la fin de la session. Les sessions ne partagent jamais l'état. Vous obtenez les limites de sécurité d'une machine virtuelle avec le modèle opérationnel sans serveur : aucun cluster à gérer, aucune capacité de pool inactive à payer. Vous orchestrez les micromachines virtuelles à l'aide d'une fonction Lambda de contrôleur planifiée qui répond aux demandes de pool en attente. Consultez le modèle de [ référence ](https://github.com/anysphere/aws-lambda-workers) Run self-hosted machines for Cursor Cloud Agents on AWS Lambda MicroVMS pour plus de détails.

## Comment ça marche
<a name="microvms-integrations-cursor-self-hosted-machines-how-it-works"></a>

Un contrôleur programmé lance une microVM par demande de pool en attente :

1. Vous démarrez un agent cloud au [ curseur. com/agents](https://cursor.com/agents)contre une machine auto-hébergée. La demande reste en suspens jusqu'à ce qu'un travailleur la réclame.

1. La fonction Lambda du contrôleur s'exécute `agent worker controller --spawn ./spawn.sh` pendant une fenêtre de sondage Server-Sent Events (SSE) de cinq minutes. Lorsqu'il voit une demande correspondante, il s'exécute`spawn.sh`.

1. `spawn.sh`appelle `RunMicrovm` (`aws lambda-microvms run-microvm`) et revient sans attendre. Il transmet l'`CURSOR_*`environnement de la réclamation au client par le biais`--run-hook-payload`.

1. Le `/run` hook microVM (`hook.py`) applique cette charge utile et démarre`entrypoint.sh`, qui s'exécute. `cursor-agent worker --pool … start` Le travailleur exécute des appels d'outils sur votre compte.

1. Lorsque la session est inactive après l'expiration du délai de publication, le worker se libère et la microVM s'arrête.

La clé d'API de votre compte de service Cursor est stockée dans le magasin de paramètres de AWS Systems Manager en tant que fichier. `SecureString` Le contrôleur et la microVM le lisent lors de l'exécution `ssm:GetParameter` ; la clé n'est jamais intégrée à l'image.

## Principales propriétés
<a name="microvms-integrations-cursor-self-hosted-machines-properties"></a>


| Propriété | Avantage | 
| --- | --- | 
| Isolation des pétards | Hardware-virtualized limite par session | 
| Démarrage instantané | Lambda restaure l'invité à partir d'une capture d'écran Firecracker de votre image | 
| L'IAM via le rôle d'exécution | L'invité utilise des informations d'identification de courte durée provenant de MicroVmExecutionRoleArn | 
| Durée avec indication | Chaque microVM peut fonctionner jusqu'à 8 heures () --maximum-duration-in-seconds 28800 | 
| Pay-per-session | Vous payez pour le temps d'exécution d'une microVM, et non pour la capacité du pool inactif | 

## Conditions préalables
<a name="microvms-integrations-cursor-self-hosted-machines-prereqs"></a>
+ Un AWS compte sur lequel Lambda MicroVMS est activé et l'autorisation d'utiliser Amazon S3, IAM et Systems Manager CloudFormation Parameter Store
+ Un compte Cursor Enterprise
+ Une équipe Cursor avec des machines auto-hébergées activées
+ Une clé d'API de compte de [ service ](https://cursor.com/docs/account/enterprise/service-accounts) pour les employés du pool
+ La [AWS CLI a été ](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) mise à jour vers la dernière version stable et Docker (le script de déploiement crée l'image du contrôleur)

## Déploiement de l'implémentation de référence
<a name="microvms-integrations-cursor-self-hosted-machines-deploy"></a>

![Schéma d'architecture montrant les Self-hosted machines Cursor sur des microVM Lambda](https://docs.aws.amazon.com/fr_fr/lambda/latest/dg/images/microvms-cursor-cloud-agents-architecture.png)


Le [ référentiel ](https://github.com/anysphere/aws-lambda-workers) anysphere/aws -lambda-workers fournit un déploiement fonctionnel minimal. Elle comprend les éléments suivants :
+ Une CloudFormation pile (`cloudformation.yaml`) : une fonction Lambda du contrôleur planifié, une EventBridge `rate(1 minute)` règle, un compartiment d'artefacts Amazon S3, une file d'attente de lettres mortes et les rôles IAM (,,,) `MicroVmExecutionRole` `BuildRole` `SpawnRole` `ControllerRole`
+ Une image de contrôleur (`controller/Dockerfile`,`controller/handler.py`) qui exécute une fenêtre de sondage SSE par appel
+ Une image microVM (`microvm-image/`:`Dockerfile`,`hook.py`,`entrypoint.sh`)
+ Un spawn hook (`spawn.sh`) et un script de déploiement () `deploy.sh`

Étapes de déploiement :

1. **Enregistrez la clé d'API du compte de service dans SSM. **

   ```bash
   aws ssm put-parameter --type SecureString \
     --name /cursor-lambda-workers/cursor-api-key \
     --value "YOUR_SERVICE_ACCOUNT_KEY"
   ```

1. **Déployez la pile. **`deploy.sh`crée l'image du contrôleur et s'exécute`aws cloudformation deploy`.

   ```bash
   POOL_NAMES=default ./deploy.sh
   # POOL_NAMES=gpu,default ./deploy.sh
   # ALL_POOLS=true ./deploy.sh
   ```

1. **Créez l'image microVM à l'`microvm-image/`aide ** des sorties de la pile. Activez les crochets `validate` d'image `ready` et et le crochet `run` microVM afin qu'ils soient capturés dans le chemin du snapshot.

   ```bash
   BUCKET=$(aws cloudformation describe-stacks --stack-name cursor-lambda-workers \
     --query "Stacks[0].Outputs[?OutputKey=='ArtifactBucketName'].OutputValue" --output text)
   BUILD_ROLE=$(aws cloudformation describe-stacks --stack-name cursor-lambda-workers \
     --query "Stacks[0].Outputs[?OutputKey=='BuildRoleArn'].OutputValue" --output text)
   BASE=$(aws lambda-microvms list-managed-microvm-images --query "items[0].imageArn" --output text)
   ( cd microvm-image && zip -r /tmp/app.zip . )
   aws s3 cp /tmp/app.zip "s3://${BUCKET}/app.zip"
   aws lambda-microvms create-microvm-image \
     --code-artifact "uri=s3://${BUCKET}/app.zip" \
     --name cursor-pool-worker \
     --base-image-arn "${BASE}" \
     --build-role-arn "${BUILD_ROLE}" \
     --environment-variables "POOL_NAME=default,CURSOR_API_KEY_PARAM_NAME=/cursor-lambda-workers/cursor-api-key" \
     --hooks '{"port":9000,"microvmImageHooks":{"ready":"ENABLED","readyTimeoutInSeconds":60,"validate":"ENABLED","validateTimeoutInSeconds":60},"microvmHooks":{"run":"ENABLED","runTimeoutInSeconds":60}}'
   ```

1. **Démarrez un agent cloud ** à partir du [ curseur. com/agents](https://cursor.com/agents)contre le pool (ou contre un référentiel en mode repo-bound) pour vérifier.

Pour des instructions détaillées, consultez le [ référentiel README. ](https://github.com/anysphere/aws-lambda-workers/blob/main/README.md)

## Modes pool et repo
<a name="microvms-integrations-cursor-self-hosted-machines-modes"></a>

Gardez la pile `PoolNames` et l'image `POOL_NAME` alignées de manière à ce que la manette et l'invité servent le même pool.
+ **Any-repo mode ** — Le routage se fait par nom de pool, pas par git remote. L'invité démarre le travailleur à partir d'un espace de travail sans git remote, de sorte que le travailleur omet `repo=` les étiquettes. Les utilisateurs choisissent le nom du ** groupe et du pool ** Any repo lorsqu'ils démarrent un agent.
+ **Repo-bound mode ** — Le worker sert une ou plusieurs télécommandes Git spécifiques. Intégrez le clone dans l'image de la microVM ou configurez-le `CURSOR_REPO_URL` pour qu'il soit `entrypoint.sh` cloné au démarrage. Le worker obtient l'`repo=`étiquette à partir de la télécommande git. Les référentiels privés nécessitent des informations d'identification git sur le worker.

## Mise en réseau
<a name="microvms-integrations-cursor-self-hosted-machines-networking"></a>

La référence `spawn.sh` attache le `INTERNET_EGRESS` connecteur géré afin que le travailleur puisse atteindre le plan de contrôle du curseur et `ALL_INGRESS` pour les crochets d'image. Outbound-only les travailleurs ne reçoivent jamais le protocole HTTPS entrant après le démarrage.

Pour accéder à des ressources privées (par exemple, une base de données Amazon Aurora ou un ElastiCache cluster Amazon) ou pour appliquer vos propres restrictions, connectez un connecteur de sortie VPC au moment du lancement à la place de. `INTERNET_EGRESS` Consultez [Utilisation de connecteurs réseau de sortie](microvms-networking.md#microvms-networking-connectors).

## Contrôle
<a name="microvms-integrations-cursor-self-hosted-machines-monitoring"></a>

**Journaux des invités ** : les journaux de MicroVM vont dans CloudWatch Logs :

```bash
aws logs tail /aws/lambda/microvms/cursor-pool-worker --follow
```

**Journaux du contrôleur ** : la fonction Lambda du contrôleur se connecte à`/aws/lambda/cursor-lambda-workers-controller`.

**MicroVM en cours d'exécution ** — Répertoriez les micromachines virtuelles en cours d'exécution pour l'image :

```bash
aws lambda-microvms list-microvms --image-identifier cursor-pool-worker
```

## Résolution des problèmes
<a name="microvms-integrations-cursor-self-hosted-machines-troubleshooting"></a>


| Symptôme | Cause | 
| --- | --- | 
| La génération de l'image échoue (S3 ou IAM) | Vérifiez les sorties de la pile ArtifactBucketName et BuildRoleArn ; le zip doit atterrir dans ce compartiment et le rôle de construction doit être capable de le lire | 
| Aucun lancement de microVM | Le contrôleur ne fonctionne pas ou ne peut pas appeler RunMicrovm ; confirmez que l'cursor-pool-workerimage existe et (pour un contrôleur local) qu'elle SpawnRoleArn est supposée | 
| Le travailleur sort immédiatement | L'invité est absent CURSOR\_API\_KEY (SSM/cursor-lambda-workers/cursor-api-key) ou le /run hook n'a pas démarré cursor-agent worker … start | 
| Exec format error sur node | L'image a installé la mauvaise architecture CLI ; les micromachines virtuelles ici sont aarch64 () arm64 | 
| Service-account clé signalée comme non valide | CURSOR\_API\_ENDPOINT/CURSOR\_API\_URLont été transmis à l'invité ; ceux-ci ne doivent pas être définis et worker start utilisent donc l'hôte d'authentification par défaut | 
| Image créée avant l'activation des hooks | Reconstruisez l'image de la microVM de manière ready à ce que les run hooks se trouvent dans le chemin du snapshot validate | 

## Ressources connexes
<a name="microvms-integrations-cursor-self-hosted-machines-related"></a>
+ [AWS MicroVM Lambda ](https://docs.aws.amazon.com/lambda/latest/dg/lambda-microvms-guide.html)
+ [RunMicrovmRéférence CLI ](https://docs.aws.amazon.com/cli/latest/reference/lambda-microvms/run-microvm.html)
+ [Démarrage rapide des machines auto-hébergées par Cursor ](https://cursor.com/docs/cloud-agent/bring-your-own-machine)
+ Modèle de référence : [ anysphere/aws -lambda-workers ](https://github.com/anysphere/aws-lambda-workers)