---
title: Configuration de l'environnement cloud
url: https://platform.claude.com/docs/fr/managed-agents/environments
description: Personnalisez les sandboxes cloud pour vos sessions.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Les environnements définissent la configuration du « sandbox » (bac à sable) dans lequel votre agent s'exécute. Vous créez un environnement une seule fois, puis vous référencez son ID chaque fois que vous démarrez une session. Plusieurs sessions peuvent partager le même environnement, mais chaque session obtient son propre sandbox isolé (un conteneur Linux neuf).

Cette page couvre les environnements `type: cloud`. Pour exécuter des sandboxes sur votre propre infrastructure, consultez [Sandboxes auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes). Pour choisir entre les deux, consultez [Choisir un environnement d'agent](https://platform.claude.com/docs/fr/managed-agents/choosing-an-environment).

## Créer un environnement

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "name": "python-dev",
      "config": {
        "type": "cloud",
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: python-dev
      config:
        type: cloud
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>

    [`ant apply`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/apply) crée l'environnement à partir de `environment.yaml`, affiche son ID et l'enregistre dans `claude-lock.json`. Validez (commit) `claude-lock.json` afin que le prochain `ant apply` mette à jour cet environnement au lieu d'essayer de le créer à nouveau.
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="python-dev",
      config={
          "type": "cloud",
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )

  print(f"Environment ID: {environment.id}")
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "python-dev",
    config: {
      type: "cloud",
      networking: { type: "limited", allow_package_managers: true }
    }
  });

  console.log(`Environment ID: ${environment.id}`);
  ```

  ```csharp C#
  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "python-dev",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });

  Console.WriteLine($"Environment ID: {environment.ID}");
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "python-dev",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("Environment ID: %s\n", environment.ID)
  ```

  ```java Java
  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("python-dev")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  IO.println("Environment ID: " + environment.id());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'python-dev',
      config: [
          'type' => 'cloud',
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  echo "Environment ID: {$environment->id}\n";
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "python-dev",
    config: {
      type: "cloud",
      networking: {type: "limited", allow_package_managers: true}
    }
  )

  puts "Environment ID: #{environment.id}"
  ```
</CodeGroup>

Utilisez un `name` (csharp, go: `Name`) unique et descriptif afin de pouvoir distinguer les environnements. Cet exemple utilise une [mise en réseau](https://platform.claude.com/docs/fr/managed-agents/environments#networking) `limited` avec les gestionnaires de paquets autorisés, afin que le sandbox puisse atteindre les registres de paquets et les hébergeurs de code. Pour lui permettre d'atteindre d'autres hôtes, ajoutez-les à `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

## Utiliser l'environnement dans une session

Transmettez l'ID de l'environnement sous forme de chaîne de caractères lors de la [création d'une session](https://platform.claude.com/docs/fr/managed-agents/sessions).

<CodeGroup>
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$AGENT_ID"'",
      "environment_id": "'"$ENVIRONMENT_ID"'"
    }'
  ```

  ```bash CLI
  ant beta:sessions create --agent "$AGENT_ID" --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
  )
  ```

  ```typescript TypeScript
  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id
  });
  ```

  ```csharp C#
  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
  });
  ```

  ```go Go
  session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  	Agent: anthropic.BetaSessionNewParamsAgentUnion{
  		OfString: anthropic.String(agent.ID),
  	},
  	EnvironmentID: environment.ID,
  })
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .build());
  ```

  ```php PHP
  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
  );
  ```

  ```ruby Ruby
  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id
  )
  ```
</CodeGroup>

## Options de configuration

### Paquets

Le champ `packages` (csharp, go: `Packages`) préinstalle des paquets dans le sandbox avant le démarrage de l'agent. Les paquets sont installés par leurs gestionnaires de paquets respectifs et mis en cache entre les sessions qui partagent le même environnement. Lorsque plusieurs gestionnaires de paquets sont spécifiés, ils s'exécutent par ordre alphabétique (apt, cargo, gem, go, npm, pip). Vous pouvez éventuellement épingler des versions spécifiques. Les paquets non épinglés installent la dernière version. Si l'environnement utilise une [mise en réseau](https://platform.claude.com/docs/fr/managed-agents/environments#networking) `limited`, définissez également `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) dans `networking` (csharp, go: `Networking`) sur `true` ; sinon, la requête est rejetée avec une erreur 400.

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "name": "data-analysis",
      "config": {
        "type": "cloud",
        "packages": {
          "pip": ["pandas", "numpy", "scikit-learn"],
          "npm": ["express"]
        },
        "networking": {"type": "limited", "allow_package_managers": true}
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: data-analysis
      config:
        type: cloud
        packages:
          pip:
            - pandas
            - numpy
            - scikit-learn
          npm:
            - express
        networking:
          type: limited
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="data-analysis",
      config={
          "type": "cloud",
          "packages": {
              "pip": ["pandas", "numpy", "scikit-learn"],
              "npm": ["express"],
          },
          "networking": {"type": "limited", "allow_package_managers": True},
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: ["pandas", "numpy", "scikit-learn"],
        npm: ["express"]
      },
      networking: { type: "limited", allow_package_managers: true }
    }
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Environments;

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "data-analysis",
      Config = new BetaCloudConfigParams
      {
          Packages = new()
          {
              Pip = ["pandas", "numpy", "scikit-learn"],
              Npm = ["express"],
          },
          Networking = new BetaLimitedNetworkParams
          {
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "data-analysis",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Packages: anthropic.BetaPackagesParams{
  				Pip: []string{"pandas", "numpy", "scikit-learn"},
  				Npm: []string{"express"},
  			},
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("data-analysis")
      .config(BetaCloudConfigParams.builder()
          .packages(BetaPackagesParams.builder()
              .pip(List.of("pandas", "numpy", "scikit-learn"))
              .npm(List.of("express"))
              .build())
          .networking(BetaLimitedNetworkParams.builder()
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'data-analysis',
      config: [
          'type' => 'cloud',
          'packages' => [
              'pip' => ['pandas', 'numpy', 'scikit-learn'],
              'npm' => ['express'],
          ],
          'networking' => ['type' => 'limited', 'allow_package_managers' => true],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "data-analysis",
    config: {
      type: "cloud",
      packages: {
        pip: %w[pandas numpy scikit-learn],
        npm: %w[express]
      },
      networking: {type: "limited", allow_package_managers: true}
    }
  )
  ```
</CodeGroup>

Gestionnaires de paquets pris en charge :

| Champ   | Gestionnaire de paquets   | Exemple                                     |
| ------- | ------------------------- | ------------------------------------------- |
| `apt`   | Paquets système (apt-get) | `"graphviz"`                                |
| `cargo` | Rust (cargo)              | `"hyperfine@1.18.0"`                        |
| `gem`   | Ruby (gem)                | `"rails:7.1.0"`                             |
| `go`    | Modules Go                | `"golang.org/x/tools/cmd/goimports@latest"` |
| `npm`   | Node.js (npm)             | `"express@4.18.0"`                          |
| `pip`   | Python (pip)              | `"sqlalchemy==2.0.30"`                      |

### Réseau

Le champ `networking` (csharp, go: `Networking`) contrôle l'accès réseau sortant du sandbox.

Avec la mise en réseau `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) s'applique également aux outils `web_search` et `web_fetch`, qui s'exécutent sur les serveurs d'Anthropic. Un appel `web_fetch` pour une URL sur un hôte auquel `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) ne correspond pas renvoie un résultat d'erreur à l'agent. `web_search` omet les résultats provenant d'hôtes auxquels `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) ne correspond pas. `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) et `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) n'ajoutent aucun hôte pour ces outils. Lorsque `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) ne répertorie aucun hôte, aucun appel `web_fetch` ou `web_search` ne renvoie de page ni de résultat de recherche. Un hôte que vous ajoutez à `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) pour ces outils est également ouvert au sandbox. La mise en réseau `unrestricted` et les environnements auto-hébergés ne limitent pas ces outils. Pour les restreindre davantage, définissez `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) ou `blocked_domains` (java, php: `blockedDomains`; csharp, go: `BlockedDomains`) sur l'entrée de l'outil dans l'ensemble d'outils de l'agent. Consultez [Restreindre les domaines de recherche web et de récupération web](https://platform.claude.com/docs/fr/managed-agents/tools-web-restrictions).

| Mode           | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `limited`      | Restreint l'accès réseau du sandbox aux hôtes figurant dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Définissez `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) et `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) sur `true` pour autoriser un accès supplémentaire. Utilisez ce mode, sauf si l'agent doit atteindre des sites que vous ne pouvez pas répertorier à l'avance. |
| `unrestricted` | Accès réseau sortant complet, à l'exception d'une liste de blocage de sécurité générale. Avant de l'utiliser, lisez [Risques de la mise en réseau non restreinte](https://platform.claude.com/docs/fr/managed-agents/environments#risks-of-unrestricted-networking).                                                                                                                                                                                                                                                                     |

<Note>
  Définissez `networking` (csharp, go: `Networking`) explicitement dans les requêtes API ; une requête de création qui l'omet obtient `unrestricted`. Le formulaire de création d'environnement de la Claude Console s'ouvre avec **Limited** sélectionné et aucun autre accès autorisé.
</Note>

L'exemple suivant crée un environnement avec le réseau `limited` :

<CodeGroup defaultLanguage="CLI">
  ```bash cURL
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "api-access",
      "config": {
        "type": "cloud",
        "networking": {
          "type": "limited",
          "allowed_hosts": ["api.example.com"],
          "allow_mcp_servers": true,
          "allow_package_managers": true
        }
      }
    }'
  ```

  <CodeGroupItem>
    ```bash CLI
    ant apply environment.yaml
    ```

    <File filename="environment.yaml">
      ```yaml
      # yaml-language-server: $schema=https://platform.claude.com/schemas/ant/beta/environment.json
      name: api-access
      config:
        type: cloud
        networking:
          type: limited
          allowed_hosts:
            - api.example.com
          allow_mcp_servers: true
          allow_package_managers: true
      ```
    </File>
  </CodeGroupItem>

  ```python Python
  environment = client.beta.environments.create(
      name="api-access",
      config={
          "type": "cloud",
          "networking": {
              "type": "limited",
              "allowed_hosts": ["api.example.com"],
              "allow_mcp_servers": True,
              "allow_package_managers": True,
          },
      },
  )
  ```

  ```typescript TypeScript
  const environment = await client.beta.environments.create({
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: ["api.example.com"],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  });
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Environments;

  var environment = await client.Beta.Environments.Create(new()
  {
      Name = "api-access",
      Config = new BetaCloudConfigParams
      {
          Networking = new BetaLimitedNetworkParams
          {
              AllowedHosts = ["api.example.com"],
              AllowMcpServers = true,
              AllowPackageManagers = true,
          },
      },
  });
  ```

  ```go Go
  environment, err := client.Beta.Environments.New(ctx, anthropic.BetaEnvironmentNewParams{
  	Name: "api-access",
  	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
  		OfCloud: &anthropic.BetaCloudConfigParams{
  			Networking: anthropic.BetaCloudConfigParamsNetworkingUnion{
  				OfLimited: &anthropic.BetaLimitedNetworkParams{
  					AllowedHosts:         []string{"api.example.com"},
  					AllowMCPServers:      anthropic.Bool(true),
  					AllowPackageManagers: anthropic.Bool(true),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	panic(err)
  }
  _ = environment
  ```

  ```java Java
  import com.anthropic.models.beta.environments.*;
  import java.util.List;

  var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
      .name("api-access")
      .config(BetaCloudConfigParams.builder()
          .networking(BetaLimitedNetworkParams.builder()
              .allowedHosts(List.of("api.example.com"))
              .allowMcpServers(true)
              .allowPackageManagers(true)
              .build())
          .build())
      .build());
  ```

  ```php PHP
  $environment = $client->beta->environments->create(
      name: 'api-access',
      config: [
          'type' => 'cloud',
          'networking' => [
              'type' => 'limited',
              'allowed_hosts' => ['api.example.com'],
              'allow_mcp_servers' => true,
              'allow_package_managers' => true,
          ],
      ],
  );
  ```

  ```ruby Ruby
  environment = client.beta.environments.create(
    name: "api-access",
    config: {
      type: "cloud",
      networking: {
        type: "limited",
        allowed_hosts: %w[api.example.com],
        allow_mcp_servers: true,
        allow_package_managers: true
      }
    }
  )
  ```
</CodeGroup>

<Info>
  Utilisez la mise en réseau `limited` avec une liste `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) explicite. Suivez le principe du moindre privilège en n'accordant que l'accès réseau minimal dont votre agent a besoin, et auditez régulièrement vos domaines autorisés.
</Info>

Avec une mise en réseau `limited` et aucun autre champ défini, aucun hôte n'est autorisé. Les fichiers, les magasins de mémoire et les dépôts GitHub que vous attachez à la session restent disponibles. Lorsqu'une requête provenant du sandbox sur le port 80 ou 443 est refusée parce que son hôte n'est pas autorisé, la réponse est une erreur 403 qui nomme l'hôte bloqué.

Lors de l'utilisation d'une mise en réseau `limited` :

* `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) spécifie les domaines que le sandbox peut atteindre. Spécifiez des noms d'hôte simples ou des motifs génériques (tels que `*.example.com`). N'incluez pas de schéma d'URL, de port ni de chemin. Un nom d'hôte simple correspond exactement à cet hôte : `example.com` ne correspond pas à `www.example.com`. `*.example.com` correspond à tous les sous-domaines de `example.com`, mais pas à `example.com` lui-même.
* `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) autorise l'accès sortant aux points de terminaison des serveurs MCP configurés sur l'agent, au-delà de ceux répertoriés dans le tableau `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). La valeur par défaut est `false`. Tant qu'il vaut `false`, la création de session échoue avec une erreur 400 si l'agent déclare un serveur MCP dont l'hôte ne figure pas dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Il en va de même pour [un agent auquel il peut déléguer](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration). Pour corriger cela, ajoutez l'hôte à `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) ou définissez `allow_mcp_servers` (java: `allowMcpServers`; php: `allowMCPServers`; csharp: `AllowMcpServers`; go: `AllowMCPServers`) sur `true`.
* `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) autorise l'accès sortant à un ensemble de registres de paquets publics et d'hébergeurs de code au-delà de ceux répertoriés dans le tableau `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Consultez [Hôtes des gestionnaires de paquets](https://platform.claude.com/docs/fr/managed-agents/environments#package-manager-hosts) pour la liste. La valeur par défaut est `false`. Définissez-le sur `true` chaque fois que l'environnement spécifie `packages` (csharp, go: `Packages`) ; sinon, la requête est rejetée avec une erreur 400, même si les hôtes des registres sont répertoriés dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).

#### Hôtes des gestionnaires de paquets

Lorsque `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) vaut `true`, le sandbox peut atteindre les hôtes suivants en plus de ceux figurant dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Anthropic maintient cette liste et peut la modifier.

| Écosystème          | Hôtes                                                                                                                                                                                      |
| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Hébergement de code | `github.com`, `api.github.com`, `codeload.github.com`, `raw.githubusercontent.com`, `objects.githubusercontent.com`, `release-assets.githubusercontent.com`, `gitlab.com`, `bitbucket.org` |
| Node.js             | `registry.npmjs.org`, `registry.yarnpkg.com`, `nodejs.org`                                                                                                                                 |
| Python              | `pypi.org`, `files.pythonhosted.org`                                                                                                                                                       |
| Rust                | `crates.io`, `index.crates.io`, `static.crates.io`, `static.rust-lang.org`                                                                                                                 |
| Go                  | `proxy.golang.org`, `sum.golang.org`                                                                                                                                                       |
| Java                | `repo1.maven.org`, `repo.maven.apache.org`, `services.gradle.org`, `plugins.gradle.org`, `plugins-artifacts.gradle.org`                                                                    |
| Ruby                | `rubygems.org`, `index.rubygems.org`                                                                                                                                                       |
| PHP                 | `packagist.org`, `repo.packagist.org`                                                                                                                                                      |
| Ubuntu (apt)        | `archive.ubuntu.com`, `security.ubuntu.com`, `ppa.launchpad.net`                                                                                                                           |
| Conteneurs          | `registry-1.docker.io`, `auth.docker.io`, `production.cloudflare.docker.com`, `download.docker.com`, `ghcr.io`                                                                             |

<Warning>
  L'accès réseau est accordé par hôte, et non par opération. Le sandbox peut envoyer n'importe quelle requête à un hôte autorisé, y compris des envois tels que `git push` et la publication de paquets, avec n'importe quel identifiant fourni par la commande. Si l'agent traite des entrées non fiables (fichiers de dépôt, contenu web récupéré ou sortie d'outils tiers), une « prompt injection » (injection de prompt) réussie pourrait utiliser un hôte autorisé pour copier des fichiers hors du sandbox. Pour réduire ce risque, définissez la [politique d'autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies) de l'outil `bash` sur `always_ask` ou `auto`. Si l'environnement ne spécifie pas `packages` (csharp, go: `Packages`), vous pouvez plutôt laisser `allow_package_managers` (java, php: `allowPackageManagers`; csharp, go: `AllowPackageManagers`) défini sur `false` et répertorier uniquement les hôtes dont votre agent a besoin dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`).
</Warning>

#### Risques de la mise en réseau non restreinte

Avec une mise en réseau `unrestricted`, le code du sandbox peut envoyer des requêtes à n'importe quel hôte sur Internet, à l'exception des hôtes figurant sur une liste de blocage de sécurité générale. Avant de choisir ce mode, réfléchissez à ce que l'agent peut faire avec cet accès :

* **L'agent peut modifier des éléments sur des sites externes, et pas seulement les lire :** L'outil `bash` peut envoyer n'importe quelle requête. L'agent peut publier des données, soumettre des formulaires, appeler des API et exécuter des scripts qui modifient des données sur des sites externes. Même une requête qui ne fait que récupérer une URL peut modifier des données sur certains sites.
* **Rien ne met ces requêtes en pause par défaut :** La [politique d'autorisation](https://platform.claude.com/docs/fr/managed-agents/permission-policies) par défaut de l'ensemble d'outils de l'agent est `always_allow`, de sorte que les commandes `bash` s'exécutent sans approbation.
* **Tout ce qui se trouve dans le sandbox peut en sortir :** Cela inclut les fichiers, les sorties d'outils et tous les identifiants ou secrets que vous placez dans le sandbox.
* **Le contenu récupéré peut orienter l'agent :** Les pages web, les réponses d'API et tout autre contenu que l'agent lit peuvent contenir des instructions (injection de prompt) qui modifient ce qu'il fait ensuite.
* **L'agent agit en votre nom :** Ses actions peuvent enfreindre les conditions d'utilisation d'un site, ou y créer des comptes et des enregistrements.
* **Le comportement du modèle n'est pas un contrôle de sécurité :** L'agent peut agir sur des sites externes d'une manière que vous n'avez pas demandée, notamment en réessayant d'une autre manière après qu'un site a bloqué une requête. Utilisez les paramètres réseau et les politiques d'autorisation pour limiter ce qu'il peut faire.
* **La liste de blocage de sécurité n'est pas une liste d'autorisation :** Elle ne limite pas les autres sites que l'agent atteint, ni ce que l'agent y fait.

Pour réduire ces risques, utilisez une mise en réseau `limited` avec une liste explicite d'hôtes. La valeur `networking` suivante autorise `api.example.com`, ainsi que les [hôtes des gestionnaires de paquets](https://platform.claude.com/docs/fr/managed-agents/environments#package-manager-hosts) pour un agent qui installe des paquets :

```json
{
  "type": "limited",
  "allowed_hosts": ["api.example.com"],
  "allow_package_managers": true
}
```

Un agent qui utilise uniquement les outils `web_search` et `web_fetch` n'a pas besoin de la mise en réseau `unrestricted` si vous pouvez répertorier les sites dont il a besoin. Avec la mise en réseau `limited`, `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) s'applique également à ces outils (consultez [Réseau](https://platform.claude.com/docs/fr/managed-agents/environments#networking)) ; répertoriez donc ces sites dans `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`). Les répertorier également dans le `allowed_domains` (java, php: `allowedDomains`; csharp, go: `AllowedDomains`) de `web_search` lui fait effectuer ses recherches sur ces sites. Un hôte que vous ajoutez à `allowed_hosts` (java, php: `allowedHosts`; csharp, go: `AllowedHosts`) est également ouvert au sandbox. Pour restreindre davantage les outils, consultez [Restreindre les domaines de recherche web et de récupération web](https://platform.claude.com/docs/fr/managed-agents/tools-web-restrictions).

N'utilisez `unrestricted` que lorsque l'agent doit atteindre des sites que vous ne pouvez pas répertorier à l'avance. Dans ce cas, gardez les secrets et les fichiers sensibles hors du sandbox, et ne donnez à l'agent que les identifiants dont la tâche a besoin. Envisagez de définir la politique d'autorisation de l'outil `bash` sur `always_ask` ou `auto`, et [surveillez les événements de la session](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming).

## Cycle de vie de l'environnement

* Les environnements persistent jusqu'à ce qu'ils soient explicitement archivés ou supprimés.
* Chaque session obtient sa propre instance de sandbox, même lorsque plusieurs sessions référencent le même environnement. Les sessions ne partagent pas l'état du système de fichiers.
* Les environnements ne sont pas versionnés. Si vous mettez fréquemment à jour un environnement, conservez votre propre registre des modifications afin de pouvoir déterminer quelle configuration chaque session a utilisée.

## Gérer les environnements

<CodeGroup>
  ```bash cURL
  # Lister les environnements
  curl -fsS https://api.anthropic.com/v1/environments \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Récupérer un environnement spécifique
  curl -fsS "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Archiver un environnement (lecture seule, les sessions existantes continuent)
  curl -fsS -X POST "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"

  # Supprimer un environnement (uniquement si aucune session n'y fait référence)
  curl -fsS -X DELETE "https://api.anthropic.com/v1/environments/$ENVIRONMENT_ID" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01"
  ```

  ```bash CLI
  # Lister les environnements
  ant beta:environments list

  # Récupérer un environnement spécifique
  ant beta:environments retrieve --environment-id "$ENVIRONMENT_ID"

  # Archiver un environnement (lecture seule, les sessions existantes continuent)
  ant beta:environments archive --environment-id "$ENVIRONMENT_ID"

  # Supprimer un environnement (uniquement si aucune session n'y fait référence)
  ant beta:environments delete --environment-id "$ENVIRONMENT_ID"
  ```

  ```python Python
  # Lister les environnements
  environments = client.beta.environments.list()

  # Récupérer un environnement spécifique
  env = client.beta.environments.retrieve(environment.id)

  # Archiver un environnement (lecture seule, les sessions existantes continuent)
  client.beta.environments.archive(environment.id)

  # Supprimer un environnement (uniquement si aucune session n'y fait référence)
  client.beta.environments.delete(environment.id)
  ```

  ```typescript TypeScript
  // Lister les environnements
  const environments = await client.beta.environments.list();

  // Récupérer un environnement spécifique
  const env = await client.beta.environments.retrieve(environment.id);

  // Archiver un environnement (lecture seule, les sessions existantes continuent)
  await client.beta.environments.archive(environment.id);

  // Supprimer un environnement (uniquement si aucune session n'y fait référence)
  await client.beta.environments.delete(environment.id);
  ```

  ```csharp C#
  // Lister les environnements
  var environments = await client.Beta.Environments.List();

  // Récupérer un environnement spécifique
  var env = await client.Beta.Environments.Retrieve(environment.ID);

  // Archiver un environnement (lecture seule, les sessions existantes continuent)
  await client.Beta.Environments.Archive(environment.ID);

  // Supprimer un environnement (uniquement si aucune session n'y fait référence)
  await client.Beta.Environments.Delete(environment.ID);
  ```

  ```go Go
  // Lister les environnements
  environments, err := client.Beta.Environments.List(ctx, anthropic.BetaEnvironmentListParams{})
  // ...

  // Récupérer un environnement spécifique
  env, err := client.Beta.Environments.Get(ctx, environment.ID, anthropic.BetaEnvironmentGetParams{})
  // ...

  // Archiver un environnement (lecture seule, les sessions existantes continuent)
  _, err = client.Beta.Environments.Archive(ctx, environment.ID, anthropic.BetaEnvironmentArchiveParams{})
  // ...

  // Supprimer un environnement (uniquement si aucune session n'y fait référence)
  _, err = client.Beta.Environments.Delete(ctx, environment.ID, anthropic.BetaEnvironmentDeleteParams{})
  ```

  ```java Java
  // Lister les environnements
  var environments = client.beta().environments().list();
  // Récupérer un environnement spécifique
  var env = client.beta().environments().retrieve(environment.id());
  // Archiver un environnement (lecture seule, les sessions existantes continuent)
  client.beta().environments().archive(environment.id());
  // Supprimer un environnement (uniquement si aucune session n'y fait référence)
  client.beta().environments().delete(environment.id());
  ```

  ```php PHP
  // Lister les environnements
  $environments = $client->beta->environments->list();
  // Récupérer un environnement spécifique
  $env = $client->beta->environments->retrieve($environment->id);
  // Archiver un environnement (lecture seule, les sessions existantes continuent)
  $client->beta->environments->archive($environment->id);
  // Supprimer un environnement (uniquement si aucune session n'y fait référence)
  $client->beta->environments->delete($environment->id);
  ```

  ```ruby Ruby
  # Lister les environnements
  environments = client.beta.environments.list

  # Récupérer un environnement spécifique
  env = client.beta.environments.retrieve(environment.id)

  # Archiver un environnement (lecture seule, les sessions existantes continuent)
  client.beta.environments.archive(environment.id)

  # Supprimer un environnement (uniquement si aucune session n'y fait référence)
  client.beta.environments.delete(environment.id)
  ```
</CodeGroup>

## Runtimes préinstallés

Les sandboxes cloud incluent d'emblée des « runtimes » (environnements d'exécution) de langages courants, des bases de données et des outils en ligne de commande. Consultez la [Référence des sandboxes cloud](https://platform.claude.com/docs/fr/managed-agents/cloud-sandboxes-reference) pour la liste complète.

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Référence des sandboxes cloud" icon="book" href="https://platform.claude.com/docs/fr/managed-agents/cloud-sandboxes-reference">
    Paquets, bases de données et utilitaires préinstallés disponibles dans les sandboxes cloud.
  </Card>

  <Card title="Démarrer une session" icon="play" href="https://platform.claude.com/docs/fr/managed-agents/sessions">
    Créez une session pour exécuter votre agent et commencer à exécuter des tâches.
  </Card>
</CardGroup>