---
title: Selbst gehostete Sandboxes
url: https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes
description: Führe Claude Managed Agents-Sitzungen in selbst gehosteten Sandboxes aus und behalte Tool-Ausführung, Dateien und ausgehenden Netzwerkverkehr in deiner eigenen Infrastruktur.
featureMetadata:
  topic:
    title: Managed Agents
    url: https://platform.claude.com/docs/en/managed-agents/overview
  status: beta
  betaHeader: managed-agents-2026-04-01
---

Selbst gehostete Sandboxes verlagern die Tool-Ausführung des Agenten aus von Anthropic verwalteten Cloud-Sandboxes in eine Infrastruktur, die du kontrollierst, während Anthropic den Agenten weiterhin ausführt. Um zu erfahren, was das bedeutet, und zu entscheiden, ob es zu deinem Agenten passt, siehe [Eine Agent-Umgebung auswählen](https://platform.claude.com/docs/de/managed-agents/choosing-an-environment).

## Funktionsweise

Eine `self_hosted`-Umgebung fungiert als Arbeitswarteschlange. Du betreibst einen „environment worker" (Umgebungs-Worker), einen Prozess auf deiner eigenen Infrastruktur, der diese Warteschlange bedient:

1. Du erstellst eine [Sitzung](https://platform.claude.com/docs/de/managed-agents/sessions), die auf die Umgebung abzielt. Anthropic reiht die Sitzung als Arbeitselement in die Warteschlange ein.
2. Dein Worker beansprucht das Arbeitselement und lädt die [Skills](https://platform.claude.com/docs/de/managed-agents/skills) des Agenten und die [Memory Stores](https://platform.claude.com/docs/de/managed-agents/memory) der Sitzung herunter.
3. Claude läuft auf der Seite von Anthropic und fordert Tool-Aufrufe an. Dein Worker führt jeden Aufruf lokal aus und sendet das Ergebnis zurück.

Tool-Eingaben und -Ausgaben fließen weiterhin an die Control Plane von Anthropic, damit das Modell die Ergebnisse sehen und entscheiden kann, was als Nächstes zu tun ist. Anthropic speichert Skills und Memory Stores. Deine Sandbox hält eine Kopie für die Sitzung. Unter [Sicherheitsmodell](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-security) findest du die vollständige Datenflussgrenze.

Selbst gehostete Sandboxes unterstützen jedes Claude-Modell, das in Managed Agents verfügbar ist. Das Modell wird am Agenten konfiguriert, nicht an der Umgebung.

Die `ant` CLI sowie die Python-, TypeScript- und Go-SDKs liefern vorgefertigte Worker mit. Sandbox-Anbieter wie Cloudflare, Daytona und Modal veröffentlichen außerdem eigene [Plattformleitfäden](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#platform-guides).

## Schnellstart

Dieser Schnellstart betreibt einen dauerhaft laufenden Worker mit der `ant` CLI, sendet ihm eine Sitzung und bestätigt, dass die Tool-Aufrufe des Agenten auf deinem Host ausgeführt wurden.

### Voraussetzungen

* **Ein Agent:** Falls du noch keinen hast, schließe zuerst [Erste Schritte mit Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/quickstart) ab und notiere dir die Agent-ID.
* **Ein Linux-Host:** Der Host benötigt `/bin/bash` unter genau diesem Pfad. Der Worker benötigt nur ausgehendes HTTPS.
* **Ein Claude-API-Key:** Du verwendest ihn auf deinem eigenen Rechner, um Sitzungen zu erstellen und Warteschlangenstatistiken abzurufen. Halte ihn vom Worker-Host fern, wo Tool-Aufrufe des Agenten ihn lesen könnten.
* **Die `ant` CLI oder das SDK auf deinem eigenen Rechner:** Die Statistik- und Sitzungsschritte in diesem Schnellstart laufen dort, nicht auf dem Worker-Host. Installiere die CLI auf dieselbe Weise wie im [Installationsschritt](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes#run-your-first-session) für den Worker, oder installiere das [SDK](https://platform.claude.com/docs/de/cli-sdks-libraries/overview).

<Note>
  Auf [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) authentifiziert sich der Worker mit AWS IAM (SigV4) oder einem [in der AWS Console generierten API-Key](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#api-key-authentication), nicht mit einem Umgebungsschlüssel. Hänge die verwaltete Richtlinie [`AnthropicSelfHostedEnvironmentAccess`](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#managed-policies) an den IAM-Principal an, unter dem dein Worker läuft. In der Claude Console generierte Umgebungsschlüssel funktionieren nicht mit dem Endpunkt von Claude Platform on AWS.
</Note>

### Deine erste Sitzung ausführen

<Steps>
  <Step title="Eine selbst gehostete Umgebung erstellen">
    Gehe in der Claude Console zur Seite [Environments](https://platform.claude.com/environments) (`platform.claude.com/environments`), klicke auf **Create environment** und wähle unter **Hosting** die Option **Self-hosted**.

    Oder über die API:

    <CodeGroup defaultLanguage="CLI">
      ```bash cURL
      curl -sS --fail-with-body 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": "self-hosted",
          "config": {"type": "self_hosted"}
        }'
      ```

      <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: self-hosted
          config:
            type: self_hosted
          ```
        </File>
      </CodeGroupItem>

      ```python Python
      client = anthropic.Anthropic()

      environment = client.beta.environments.create(
          name="self-hosted", config={"type": "self_hosted"}
      )
      print(environment.id)
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const environment = await client.beta.environments.create({
        name: "self-hosted",
        config: { type: "self_hosted" }
      });
      console.log(environment.id);
      ```

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

      var client = new AnthropicClient();

      var environment = await client.Beta.Environments.Create(
          new EnvironmentCreateParams
          {
              Name = "self-hosted",
              Config = new BetaSelfHostedConfigParams(),
          }
      );
      Console.WriteLine(environment.ID);
      ```

      ```go Go
      client := anthropic.NewClient()

      environment, err := client.Beta.Environments.New(context.Background(), anthropic.BetaEnvironmentNewParams{
      	Name: "self-hosted",
      	Config: anthropic.BetaEnvironmentNewParamsConfigUnion{
      		OfSelfHosted: &anthropic.BetaSelfHostedConfigParams{},
      	},
      })
      if err != nil {
      	panic(err)
      }
      fmt.Println(environment.ID)
      ```

      ```java Java
      import com.anthropic.models.beta.environments.BetaSelfHostedConfigParams;
      import com.anthropic.models.beta.environments.EnvironmentCreateParams;

      void main() {
          var client = AnthropicOkHttpClient.fromEnv();

          var environment = client.beta().environments().create(
              EnvironmentCreateParams.builder()
                  .name("self-hosted")
                  .config(BetaSelfHostedConfigParams.builder().build())
                  .build()
          );
          IO.println(environment.id());
      }
      ```

      ```php PHP
      $client = new \Anthropic\Client();

      $environment = $client->beta->environments->create(
          name: 'self-hosted',
          config: ['type' => 'self_hosted'],
      );
      echo $environment->id, PHP_EOL;
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      environment = client.beta.environments.create(
        name: "self-hosted",
        config: {type: :self_hosted}
      )
      puts environment.id
      ```
    </CodeGroup>
  </Step>

  <Step title="Einen Umgebungsschlüssel generieren">
    Öffne in der Console die Umgebung und klicke auf **Generate environment key**. Der Umgebungsschlüssel authentifiziert den Worker gegenüber seiner Warteschlange. Du kannst ihn nur in der Console generieren, auch für eine Umgebung, die du über die API erstellt hast.

    Exportiere die Umgebungs-ID und den Schlüssel auf dem Worker-Host:

    ```bash
    export ANTHROPIC_ENVIRONMENT_KEY="sk-ant-oat01-..."
    export ANTHROPIC_ENVIRONMENT_ID="env_..."
    ```
  </Step>

  <Step title="Die ant CLI installieren">
    Führe dies auf dem Worker-Host aus.

    <Tabs>
      <Tab title="curl (Linux/WSL)">
        Lade für Linux-Umgebungen die Release-Binärdatei direkt herunter.

        ```bash
        VERSION=1.42.0
        OS=$(uname -s | tr '[:upper:]' '[:lower:]')
        case $(uname -m) in
          x86_64) ARCH=amd64 ;;
          aarch64) ARCH=arm64 ;;
        esac
        curl -fsSL "https://github.com/anthropics/anthropic-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
          | sudo tar -xz -C /usr/local/bin ant
        ```

        Alle Releases findest du auf der [GitHub-Releases-Seite](https://github.com/anthropics/anthropic-cli/releases).
      </Tab>

      <Tab title="Homebrew (macOS)">
        ```bash
        brew install anthropics/tap/ant
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Den Worker starten">
    Erstelle das Arbeitsverzeichnis und starte dann den Worker. `--workdir` ist standardmäßig das aktuelle Verzeichnis, übergib also `/workspace`, um dem Systemstandard zu entsprechen.

    ```bash
    sudo mkdir -p /workspace && sudo chown "$USER" /workspace
    ant beta:worker poll --workdir /workspace
    ```

    Der Worker liest die beiden exportierten Variablen und fragt die Warteschlange ab, bis du ihn stoppst.
  </Step>

  <Step title="Prüfen, ob der Worker verbunden ist">
    Setze auf deinem eigenen Rechner `ANTHROPIC_API_KEY` auf deinen Claude-API-Key (nicht den Umgebungsschlüssel) und `ANTHROPIC_ENVIRONMENT_ID` (python, ruby: `environment_id`; typescript, java, csharp: `environmentId`; go: `environmentID`; php: `$environmentId`) auf die Umgebungs-ID. Bestätige, dass `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) mindestens 1 ist:

    <CodeGroup>
      ```bash cURL
      curl -sS --fail-with-body "https://api.anthropic.com/v1/environments/$ANTHROPIC_ENVIRONMENT_ID/work/stats" \
        -H "x-api-key: $ANTHROPIC_API_KEY" \
        -H "anthropic-version: 2023-06-01" \
        -H "anthropic-beta: managed-agents-2026-04-01"
      ```

      ```bash CLI
      ant beta:environments:work stats --environment-id "$ANTHROPIC_ENVIRONMENT_ID"
      ```

      ```python Python
      client = anthropic.Anthropic()

      stats = client.beta.environments.work.stats(environment_id)
      print(f"workers_polling={stats.workers_polling}")
      ```

      ```typescript TypeScript
      const client = new Anthropic();

      const stats = await client.beta.environments.work.stats(environmentId);

      console.log(`workers_polling=${stats.workers_polling}`);
      ```

      ```csharp C#
      var client = new AnthropicClient();

      var stats = await client.Beta.Environments.Work.Stats(environmentId);

      Console.WriteLine($"workers_polling={stats.WorkersPolling}");
      ```

      ```go Go
      client := anthropic.NewClient()

      stats, err := client.Beta.Environments.Work.Stats(
      	context.Background(),
      	environmentID,
      	anthropic.BetaEnvironmentWorkStatsParams{},
      )
      if err != nil {
      	panic(err)
      }

      fmt.Printf("workers_polling=%d\n", stats.WorkersPolling)
      ```

      ```java Java
      var client = AnthropicOkHttpClient.fromEnv();

      var stats = client.beta().environments().work().stats(environmentId);

      IO.println("workers_polling=" + stats.workersPolling().orElse(null));
      ```

      ```php PHP
      $client = new Client();

      $stats = $client->beta->environments->work->stats($environmentId);

      printf("workers_polling=%d\n", $stats->workersPolling);
      ```

      ```ruby Ruby
      client = Anthropic::Client.new

      stats = client.beta.environments.work.stats(environment_id)

      puts "workers_polling=#{stats.workers_polling}"
      ```
    </CodeGroup>

    Wenn `workers_polling` (java, php: `workersPolling`; csharp, go: `WorkersPolling`) bei 0 bleibt, siehe [Fehlerbehebung](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-operations#troubleshooting).
  </Step>

  <Step title="Eine Sitzung starten">
    Setze `AGENT_ID` (python, ruby: `agent_id`; typescript, java, csharp: `agentId`; go: `agentID`; php: `$agentId`) auf die ID deines Agenten. Erstelle eine Sitzung, die auf die Umgebung abzielt, und sende ihr dann eine Aufgabe:

    <CodeGroup>
      ```bash cURL
      SESSION_ID=$(curl -sS --fail-with-body 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" \
        -d '{
          "agent": "'"$AGENT_ID"'",
          "environment_id": "'"$ANTHROPIC_ENVIRONMENT_ID"'"
        }' | jq -er '.id'
      )

      curl -sS --fail-with-body "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
        -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 '{
          "events": [
            {
              "type": "user.message",
              "content": [
                {
                  "type": "text",
                  "text": "Write the output of \"uname -a\" to hello.txt in your working directory."
                }
              ]
            }
          ]
        }'
      ```

      ```bash CLI
      SESSION_ID=$(ant beta:sessions create \
        --agent "$AGENT_ID" \
        --environment-id "$ANTHROPIC_ENVIRONMENT_ID" \
        --transform id --raw-output)

      ant beta:sessions:events send --session-id "$SESSION_ID" <<'YAML'
      events:
        - type: user.message
          content:
            - type: text
              text: Write the output of "uname -a" to hello.txt in your working directory.
      YAML
      ```

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

      client.beta.sessions.events.send(
          session.id,
          events=[
              {
                  "type": "user.message",
                  "content": [
                      {
                          "type": "text",
                          "text": 'Write the output of "uname -a" to hello.txt in your working directory.',
                      },
                  ],
              },
          ],
      )
      ```

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

      await client.beta.sessions.events.send(session.id, {
        events: [
          {
            type: "user.message",
            content: [
              {
                type: "text",
                text: 'Write the output of "uname -a" to hello.txt in your working directory.'
              }
            ]
          }
        ]
      });
      ```

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

      await client.Beta.Sessions.Events.Send(session.ID, new()
      {
          Events =
          [
              new BetaManagedAgentsUserMessageEventParams
              {
                  Type = BetaManagedAgentsUserMessageEventParamsType.UserMessage,
                  Content =
                  [
                      new BetaManagedAgentsTextBlock
                      {
                          Type = BetaManagedAgentsTextBlockType.Text,
                          Text = "Write the output of \"uname -a\" to hello.txt in your working directory.",
                      },
                  ],
              },
          ],
      });
      ```

      ```go Go
      session, err := client.Beta.Sessions.New(context.Background(), anthropic.BetaSessionNewParams{
      	Agent:         anthropic.BetaSessionNewParamsAgentUnion{OfString: anthropic.String(agentID)},
      	EnvironmentID: environmentID,
      })
      if err != nil {
      	panic(err)
      }

      _, err = client.Beta.Sessions.Events.Send(context.Background(), session.ID, anthropic.BetaSessionEventSendParams{
      	Events: []anthropic.BetaManagedAgentsEventParamsUnion{{
      		OfUserMessage: &anthropic.BetaManagedAgentsUserMessageEventParams{
      			Type: anthropic.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
      			Content: []anthropic.BetaManagedAgentsUserMessageEventParamsContentUnion{{
      				OfText: &anthropic.BetaManagedAgentsTextBlockParam{
      					Type: anthropic.BetaManagedAgentsTextBlockTypeText,
      					Text: "Write the output of \"uname -a\" to hello.txt in your working directory.",
      				},
      			}},
      		},
      	}},
      })
      if err != nil {
      	panic(err)
      }
      ```

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

      client.beta().sessions().events().send(
          session.id(),
          EventSendParams.builder()
              .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
                  .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
                  .addTextContent("Write the output of \"uname -a\" to hello.txt in your working directory.")
                  .build())
              .build());
      ```

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

      $client->beta->sessions->events->send(
          $session->id,
          events: [
              [
                  'type' => 'user.message',
                  'content' => [['type' => 'text', 'text' => 'Write the output of "uname -a" to hello.txt in your working directory.']],
              ],
          ],
      );
      ```

      ```ruby Ruby
      session = client.beta.sessions.create(
        agent: agent_id,
        environment_id: environment_id
      )

      client.beta.sessions.events.send_(
        session.id,
        events: [
          {
            type: :"user.message",
            content: [{type: :text, text: 'Write the output of "uname -a" to hello.txt in your working directory.'}]
          }
        ]
      )
      ```
    </CodeGroup>

    Die Sitzung wartet in der Warteschlange der Umgebung, bis ein Worker sie beansprucht. Wenn kein Worker verbunden ist, bleibt die Sitzung in der Warteschlange, statt fehlzuschlagen.
  </Step>

  <Step title="Bestätigen, dass die Tools auf deinem Host ausgeführt wurden">
    Lies auf dem Worker-Host die Datei, die der Agent geschrieben hat:

    ```bash
    cat /workspace/hello.txt
    ```

    Die Datei beschreibt den Kernel deines eigenen Hosts, die Tool-Aufrufe des Agenten wurden also dort ausgeführt. Um die Arbeit des Agenten in Echtzeit zu verfolgen, siehe [Sitzungs-Event-Stream](https://platform.claude.com/docs/de/managed-agents/events-and-streaming).
  </Step>
</Steps>

## Sitzungsressourcen

Selbst gehostete Sandboxes unterstützen nur `memory_store`-Ressourcen. Eine Sitzung in einer selbst gehosteten Umgebung, die eine `file`- oder `github_repository`-Ressource enthält, wird mit einem 400-Fehler abgelehnt:

```text wrap
Environment env_... is a self-hosted environment. `resources` are not supported with self-hosted environments.
```

Für [Deployments](https://platform.claude.com/docs/de/managed-agents/scheduled-deployments), die auf eine selbst gehostete Umgebung abzielen, gilt dieselbe Regel. Um einer Sitzung eigene Eingabedateien bereitzustellen, siehe [Dateien für eine Sitzung bereitstellen](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers#stage-files-for-a-session).

## Selbst gehostete Sandboxes und MCP-Tunnel

Self-Hosting steuert, *wo der Code des Agenten ausgeführt wird*. [MCP-Tunnel](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview) steuern, *wie Anthropic MCP-Server in deinem Netzwerk erreicht*. Beides ist unabhängig voneinander:

* Eine Sitzung in den Cloud-Sandboxes von Anthropic kann private MCP-Server über einen Tunnel erreichen. Ein privater MCP-Server könnte beispielsweise vor einer Datenbank oder einer internen API hinter deiner Firewall stehen.
* Eine selbst gehostete Sitzung kann entweder getunnelte oder öffentliche MCP-Server verwenden.

Verwende beides, wenn Ausführung und Tool-Zugriff innerhalb deiner Grenze bleiben sollen. Um den Tunnel zu umgehen, [kapsle den MCP-Server als benutzerdefinierte Tools](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-custom-tools#wrap-an-mcp-server-as-custom-tools), die dein Worker bereitstellt.

## Plattformleitfäden

Diese Seiten beschreiben, wie du einen Worker auf einer beliebigen Sandboxing-Plattform erstellst. Es gibt außerdem plattformspezifische Leitfäden:

* [AWS Lambda MicroVMs](https://docs.aws.amazon.com/lambda/latest/dg/microvms-integrations-claude-managed-agents.html)
* [Blaxel](https://docs.blaxel.ai/Tutorials/Claude-Managed-Agents)
* [Cloudflare](https://developers.cloudflare.com/sandbox/claude-managed-agents/)
* [Daytona](https://www.daytona.io/docs/en/guides/claude/claude-managed-agents)
* [E2B](https://e2b.dev/docs/agents/claude-managed-agents)
* [Fly.io](https://docs.sprites.dev/integrations/claude-managed-agents/)
* [GKE Agent Sandbox](https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/tree/main/ai-ml/anthropic-agent-sandbox)
* [Modal](https://github.com/modal-labs/claude-managed-agents-modal-sandbox)
* [Namespace](https://namespace.so/docs/integrations/claude)
* [Superserve](https://docs.superserve.ai/integrations/managed-agents/claude-managed-agents)
* [Vercel](https://vercel.com/kb/guide/run-claude-managed-agent-tools-with-vercel-sandbox)

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Worker bereitstellen" icon="play" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-workers">
    Betreibe den SDK-Worker, löse Worker über Webhooks aus oder gib jeder Sitzung ihre eigene Sandbox.
  </Card>

  <Card title="Memory Stores" icon="brain" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-memory">
    Bereite den Host vor, konfiguriere die Synchronisierung und gehe mit schreibgeschützten Stores und Konflikten um.
  </Card>

  <Card title="Benutzerdefinierte Tools und MCP-Server" icon="tool" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-custom-tools">
    Stelle deine eigenen Tools über den Worker bereit, einschließlich Tools von einem MCP-Server in deinem Netzwerk.
  </Card>

  <Card title="Überwachung und Fehlerbehebung" icon="lightning" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-operations">
    Lies die Warteschlangentiefe aus, stoppe Sitzungen und Worker sauber und behebe häufige Fehler.
  </Card>

  <Card title="Worker-Referenz" icon="book" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-reference">
    CLI-Flags, Umgebungsvariablen, Dateisystempfade und Optionen der SDK-Hilfsfunktionen.
  </Card>

  <Card title="Sicherheitsmodell" icon="lock" href="https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes-security">
    Modell der geteilten Verantwortung für selbst gehostete Sandbox-Umgebungen.
  </Card>
</CardGroup>