{"meta":{"title":"Cloud-Sitzungen","intro":"Cloud-Sitzungen führen Copilot-Aufgaben über Mission Control auf von GitHub gehosteten Computeressourcen aus. Verwenden Sie sie, wenn Ihre App eine Remotesitzung erstellen soll, die remote ausgeführt wird, anstatt eine lokale Copilot-CLI-Sitzung auf dem Computer des Benutzers oder Ihrem Server zu starten.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos","title":"Vorgehensweisen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk","title":"Copilot SDK"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features","title":"Funktionen"},{"href":"/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/cloud-sessions","title":"Cloud-Sitzungen"}],"documentType":"article"},"body":"# Cloud-Sitzungen\n\nCloud-Sitzungen führen Copilot-Aufgaben über Mission Control auf von GitHub gehosteten Computeressourcen aus. Verwenden Sie sie, wenn Ihre App eine Remotesitzung erstellen soll, die remote ausgeführt wird, anstatt eine lokale Copilot-CLI-Sitzung auf dem Computer des Benutzers oder Ihrem Server zu starten.\n\n\n\n\n\n## Voraussetzungen\n\nStellen Sie vor dem Erstellen einer Cloudsitzung folgendes sicher:\n\n* Der Benutzer hat Zugriff auf Copilot mit Cloud-Agent-Berechtigung.\n* Die Sitzung kann sich bei GitHub authentifizieren, entweder mit einem Benutzertoken oder einer angemeldeten Copilot CLI-Identität.\n* Sie können die Sitzung einem GitHub Repository zuordnen. Dies ist im SDK-Typ optional, wird jedoch empfohlen, sodass Mission Control und der Cloud-Agent Repositorykontext haben.\n* Organisationsrichtlinien ermöglichen die Remotesteuerung und Anzeige von Sitzungen über Cloudoberflächen.\n\n## Erstellen einer Cloudsitzung\n\nLegen Sie die Option create-session `cloud` fest, um eine Cloud-Sitzung zu erstellen. Sie können Repositorymetadaten einschließen, um die Cloudsitzung einem GitHub Repository zuzuordnen.\n\n\n\n### Typescript\n\n```typescript\nimport { CopilotClient } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient();\nawait client.start();\n\nconst session = await client.createSession({\n onPermissionRequest: async () => ({ kind: \"approve-once\" }),\n cloud: {\n repository: {\n owner: \"github\",\n name: \"copilot-sdk\",\n branch: \"main\",\n },\n },\n});\n```\n\n### Python\n\n```python\nfrom copilot import (\n CloudSessionOptions,\n CloudSessionRepository,\n CopilotClient,\n PermissionHandler,\n)\n\nclient = CopilotClient()\nawait client.start()\n\nsession = await client.create_session(\n on_permission_request=PermissionHandler.approve_all,\n cloud=CloudSessionOptions(\n repository=CloudSessionRepository(\n owner=\"github\",\n name=\"copilot-sdk\",\n branch=\"main\",\n )\n ),\n)\n```\n\n### Go\n\n```golang\nclient := copilot.NewClient(nil)\nif err := client.Start(ctx); err != nil {\n return err\n}\n\nsession, err := client.CreateSession(ctx, &copilot.SessionConfig{\n Cloud: &copilot.CloudSessionOptions{\n Repository: &copilot.CloudSessionRepository{\n Owner: \"github\",\n Name: \"copilot-sdk\",\n Branch: \"main\",\n },\n },\n OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {\n return &rpc.PermissionDecisionApproveOnce{}, nil\n },\n})\n_ = session\n```\n\n### .NET\n\n```csharp\nawait using var client = new CopilotClient();\n\nvar session = await client.CreateSessionAsync(new SessionConfig\n{\n Cloud = new CloudSessionOptions\n {\n Repository = new CloudSessionRepository\n {\n Owner = \"github\",\n Name = \"copilot-sdk\",\n Branch = \"main\",\n },\n },\n OnPermissionRequest = (req, inv) =>\n Task.FromResult(PermissionDecision.ApproveOnce()),\n});\n```\n\n### Java\n\n```java\nimport com.github.copilot.CopilotClient;\nimport com.github.copilot.rpc.*;\n\ntry (var client = new CopilotClient()) {\n client.start().get();\n\n var session = client.createSession(\n new SessionConfig()\n .setCloud(new CloudSessionOptions()\n .setRepository(new CloudSessionRepository()\n .setOwner(\"github\")\n .setName(\"copilot-sdk\")\n .setBranch(\"main\")))\n .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)\n ).get();\n}\n```\n\n### Rust\n\n```rust\nuse std::sync::Arc;\nuse github_copilot_sdk::{CloudSessionOptions, CloudSessionRepository, SessionConfig};\nuse github_copilot_sdk::handler::ApproveAllHandler;\n\nlet session = client.create_session(\n SessionConfig::default()\n .with_cloud(CloudSessionOptions::with_repository(\n CloudSessionRepository::new(\"github\", \"copilot-sdk\").with_branch(\"main\"),\n ))\n .with_permission_handler(Arc::new(ApproveAllHandler)),\n).await?;\n```\n\n\n\n## Senden des ersten Prompts\n\nCloud-Sitzungen werden in zwei Phasen initialisiert: `createSession` erfolgt, sobald Mission Control eine Aufgabe reserviert hat, aber der Remote-`copilot-agent`-Worker benötigt noch ein oder zwei Sekunden, um sich zu verbinden und `session.start` auszugeben. Wenn Sie `session.send` davor aufrufen, löst `RemoteSession.send` der Laufzeit `\"Remote session is still starting\"` aus — aber der Schema-Wrapper arbeitet nach dem Fire-and-Forget-Prinzip und **verschluckt den Fehler stillschweigend**, während an Ihren Code trotzdem ein neues `messageId` zurückgegeben wird. Die Eingabeaufforderung wird auf dem Server abgelegt und erreicht nie den Worker.\n\nUm zuverlässig zu senden, abonnieren Sie die Ereignisse **vor** dem Senden und warten Sie auf das erste `session.start` Ereignis, dessen `producer``\"copilot-agent\"` ist:\n\n\n\n```typescript\nimport { CopilotClient, type CopilotSession } from \"@github/copilot-sdk\";\n\nconst client = new CopilotClient();\nawait client.start();\n\nconst session: CopilotSession = await client.createSession({\n streaming: true, // required for assistant.message_delta to fire\n cloud: { repository: { owner: \"github\", name: \"copilot-sdk\" } },\n onPermissionRequest: async () => ({ kind: \"approve-once\" }),\n});\n\n// Subscribe BEFORE sending so you don't miss the start event.\nconst ready = new Promise((resolve) => {\n const off = session.on(\"session.start\", (event) => {\n if (event.data?.producer === \"copilot-agent\") {\n off();\n resolve();\n }\n });\n});\n\nawait ready;\nawait session.send({ prompt: \"Summarize the README\" });\n```\n\nEinige Hinweise:\n\n* Legen Sie `streaming: true` in `createSession` fest, sodass die Laufzeit `assistant.message_delta`-Ereignisse ausgibt. Ohne sie ist das einzige Assistentensignal, das Sie erhalten, das abschließende `assistant.message` – für die Batch-Verarbeitung in Ordnung, aber der Chat wirkt eingefroren, wenn Sie eine Live-UI rendern. Siehe [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events).\n* Nur das **erste**`session.send` ist für dieses Rennen sensibel. Nachfolgende Sendevorgänge in derselben Sitzung funktionieren normal, weil die Laufzeit `hasSessionStarted` für die Dauer der Sitzung gesetzt hält.\n* Legen Sie für das `ready`-Promise eine Zeitüberschreitung (z. B. 60 Sekunden) fest, damit Ihre App nicht auf unbestimmte Zeit hängen bleibt, falls die Bereitstellung über Mission Control ins Stocken gerät.\n* Dasselbe Muster funktioniert in jeder SDK-Sprache — `session.start` abonnieren, `producer === \"copilot-agent\"` prüfen und dann `send` aufrufen.\n\n## Zugreifen auf die Mission Control-URL\n\nCloud-Sitzungen sind von Natur aus remote: Sobald sich der Worker verbindet, veröffentlicht Mission Control die Sitzung unter `https://github.com/copilot/tasks/{sessionId}`, und die Laufzeit löst ein `session.info`-Ereignis mit der URL aus. Sie müssen **nicht**`remote.enable()` aufrufen – diese API dient nur dazu, eine lokale Sitzung in Mission Control hochzustufen.\n\nErfassen Sie die URL, indem Sie `session.info` abonnieren und nach `infoType: \"remote\"` filtern:\n\n\n\n```typescript\nsession.on(\"session.info\", (event) => {\n if (event.data?.infoType === \"remote\" && event.data.url) {\n console.log(\"Open from web or mobile:\", event.data.url);\n // For example, surface in your UI as a shareable link or QR code.\n }\n});\n```\n\nDas Ereignis wird kurz nach `session.start` ausgelöst. Wenn Ihr Renderer erst eingebunden wird, nachdem das Ereignis bereits ausgelöst wurde, speichern Sie die URL zusammen mit dem Sitzungsdatensatz im State Ihrer App und aktivieren Sie sie beim erneuten Einbinden wieder – die Runtime sendet `session.info` nicht von selbst erneut aus.\n\nInformationen zur gleichen Verkabelung bei lokalen Sitzungen, die über `remote: true` beworben werden, finden Sie unter [Remotesitzungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/remote-sessions).\n\n## Repositoryzuordnung\n\nDas `cloud.repository`-Objekt ordnet die Cloudsitzung einem GitHub Repository zu:\n\n| Feld | Required | Description |\n| -------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `owner` | Yes | Repositorybesitzer oder -organisation. |\n| `name` | Yes | Repositoryname. |\n| `branch` | No | Zu verwendender Branch für den Repository-Kontext. Lassen Sie den Wert weg, damit die Laufzeit den Standard-Branch oder den aktuellen Repository-Kontext auswählen kann. |\n\nDie Repositoryzuordnung ist im SDK-Typ optional. Fügen Sie sie jedoch ein, wenn Ihre App das Ziel-Repository kennt. Es hilft Mission Control, die Sitzung im richtigen Kontext anzuzeigen und dem Cloud-Agent einen klareren Ausgangspunkt zu verleihen.\n\nVerwenden Sie `branch`, wenn die Arbeit von einem bestimmten Branch aus beginnen soll. Wenn Ihre App Sitzungen aus Pullanforderungen, Problem-Triage-Abläufen oder Bereitstellungsworkflows erstellt, übergeben Sie die Verzweigung, die der für den Benutzer sichtbaren Aufgabe entspricht.\n\n## Fortsetzen einer Cloudsitzung\n\nDie `cloud` Option gilt nur beim Erstellen einer neuen Sitzung. Verwenden Sie die standardmäßige Wiederaufnahme-API für die SDK-Sprache, um eine vorhandene Cloudsitzung fortzusetzen:\n\n```typescript\nconst session = await client.resumeSession(\"session-id\", {\n onPermissionRequest: async () => ({ kind: \"approve-once\" }),\n});\n```\n\nÜbergeben Sie `cloud` beim Fortfahren nicht erneut. Die gespeicherten Sitzungsmetadaten weisen darauf hin, dass die Sitzung cloudgestützt ist, und die Wiederaufnahme erfolgt über den normalen Pfad zur Sitzungswiederaufnahme.\n\n## Organisationsrichtlinien und -berechtigungen\n\nDie Erstellung von Cloud-Sitzungen kann fehlschlagen, wenn der Benutzer oder die Organisation nicht zur Ausführung von Cloud-Agents berechtigt ist oder wenn Richtlinien auf Organisationsebene den Ablauf blockieren. Insbesondere können Richtlinien für Cloud-Sandbox verhindern, dass Clients die Cloudaufgabe erstellen.\n\nIn diesem Fall meldet die Laufzeit einen Fehlergrund `\"policy_blocked\"` für die Erstellung von Cloudaufgaben. Behandeln Sie dies als Autorisierungs- oder Richtlinienergebnis, nicht als vorübergehender Infrastrukturfehler.\n\nPrüfen Sie in TypeScript den Grund, bevor Sie es erneut versuchen:\n\n```typescript\ntry {\n await client.createSession({ cloud: { repository } });\n} catch (error) {\n if ((error as { reason?: string }).reason === \"policy_blocked\") {\n // Show an admin-facing message or link to org policy settings.\n }\n throw error;\n}\n```\n\nÜberprüfen Sie in Sprachen, in denen SDK-Fehler unterschiedlich dargestellt werden, den ausgegebenen Fehlergrund oder -code und behandeln Sie `\"policy_blocked\"` explizit. Es wird nicht erwartet, dass ein Erneutes Wiederholen ohne Eine Richtlinienänderung erfolgreich ist.\n\n## Integrations-ID und Routing\n\nCloud-Sitzungen werden mit einem `Copilot-Integration-Id`-Header versehen, der von der Umgebungsvariable `GITHUB_COPILOT_INTEGRATION_ID` abgeleitet wird. Diese Integrations-ID wird von Mission Control für Routing, Attribution und integrationsspezifisches Verhalten verwendet.\n\nAusführliche Informationen zu Mehrbenutzerservern und vollständigen Integrations-ID-Details finden Sie unter [Mandantenfähigkeit und Serverbereitstellungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy).\n\nMission Control leitet mit dem SDK erstellte Cloudsitzungen an den `copilot-developer-sandbox`-Agent-Slug weiter. Der Name ist eine interne Routing-Slug für den Cloud-Agent und bedeutet nicht, dass die Sitzung die lokale Windows Sandbox verwendet.\n\n## Erweitert: `COPILOT_MC_BASE_URL`\n\nStandardmäßig leitet die Laufzeit die Basis-URL der Mission Control von der konfigurierten Copilot-API-URL ab. Legen Sie `COPILOT_MC_BASE_URL` nur fest, wenn Sie diesen Mission Control-Endpunkt außer Kraft setzen müssen.\n\nDies kann für GitHub Enterprise Server-Bereitstellungen erforderlich sein. Bestätigen Sie den richtigen Wert und den Supportstatus mit Ihrem GitHub Vertreter, bevor Sie sich auf ihn in der Produktion verlassen.\n\n```shell\nCOPILOT_MC_BASE_URL=\"https://example.com/agents\"\n```\n\n## Cloudsitzungen im Vergleich zu Remotesitzungen\n\n| Fähigkeit | Remotesitzungen | Cloud-Sitzungen |\n| -------------------------------------------------- | ----------------------------------------------- | ----------------------------------------------------- |\n| Ausführungsstandort | Lokaler Computer oder Ihr Server | GitHub-gehostete Rechenleistung |\n| Rolle \"Mission Control\" | Teilt eine lokale Sitzung für GitHub Web/Mobile | Erstellt die gehostete Sitzung und leitet sie weiter. |\n| SDK-Option | | |\n| `remote: true` auf Clientseite oder in der Sitzung | | |\n| `cloud: { ... }` beim Erstellen einer Sitzung | | |\n| Fortsetzungspfad | Standard-Lebenslauf | Standard-Lebenslauf |\n| Windows-Sandbox-Beziehung | Nicht verwandt | Nicht verwandt |\n\nVerwenden Sie Remote-Sitzungen, wenn die Sitzung dort ausgeführt werden soll, wo die SDK-Laufzeit bereits läuft, aber auch von Mission Control aus zugänglich sein soll. Verwenden Sie Cloudsitzungen, wenn die Sitzung auf GitHub gehosteten Compute ausgeführt werden soll.\n\n## Troubleshooting\n\n| Symptom | Wahrscheinliche Ursache | Was soll überprüft werden? |\n| ----------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Die Erstellung von Cloudsitzungen gibt `\"policy_blocked\"` zurück | Die Organisationsrichtlinie verhindert die Remotesteuerung oder die Remoteansicht durch Cloud-Flows | Überprüfen von Organisations-Copilot Richtlinien und Benutzerberechtigungen |\n| Sitzung wird ohne Repositorykontext erstellt | | |\n| `cloud.repository` wurde nicht angegeben. | Übergeben Sie `owner`, `name` und optional `branch` | |\n| „Fortsetzen“ ignoriert eine neue `cloud`Option | | |\n| `cloud` gilt nur für neue Sitzungen | Bestehende Sitzung normal fortsetzen | |\n| Verwirrung mit Sandkasteneinstellungen | Windows Sandbox und Cloud-Sitzungen sind getrennt | Nicht für die Cloudausführung verwenden `SANDBOX=true` |\n| `session.send` wird mit einem `messageId` aufgelöst, aber keine `assistant.*`-Ereignisse werden ausgelöst, und Mission Control zeigt keinen Prompt an | Das session.send kam dem `session.start` vom Remote-Worker zuvor; die Laufzeitumgebung verschluckte den Prompt. | Warten Sie vor dem Senden, bis das erste `session.start``producer === \"copilot-agent\"`-Ereignis eintritt. Siehe [Senden der ersten Eingabeaufforderung](#sending-the-first-prompt) |\n| Live-UI wird nie aktualisiert, obwohl der Cloud-Worker verarbeitet. | | |\n| `streaming` wurde auf `createSession` nicht festgelegt, sodass nur das endgültige `assistant.message` ausgegeben wird. | Aktivieren Sie `streaming: true` in `createSession` und starten Sie es erneut | |\n| Die Cloudsitzung funktioniert, aber in Ihrer Benutzeroberfläche wird keine freigabefähige URL angezeigt. | Die App hat `session.info` für die URL nie abonniert. | |\n| `session.info` abonnieren und `infoType === \"remote\"` filtern. Siehe [Zugriff auf die Mission Control-URL](#accessing-the-mission-control-url) | | |\n\n## Siehe auch\n\n* [Remotesitzungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/remote-sessions): Lokal gehostete Sitzungen über Mission Control freigeben\n* [Ereignisse einer Streaming-Sitzung](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events): Abonnieren von `assistant.*` Deltas für das Live-UI-Rendering\n* [Mandantenfähigkeit und Serverbereitstellungen](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/setup/multi-tenancy): Integrations-IDs und Serverbereitstellungsmuster\n* [Authentication](/de/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/auth): Konfigurieren GitHub Authentifizierung für SDK-Sitzungen"}