---
title: "Per SSH in eine Sandbox: Shell, scp, SFTP und Tunnel | Pethost Agent Sandboxes"
description: "Melde dich mit einfachem ssh bei jeder Sandbox an, kopier Dateien mit scp und SFTP, leite Ports mit ssh -L weiter, mit einem Key oder Token als Passwort."
---

[Doku zu Agent Sandboxes](https://pethost.dev/de/docs/sandboxes/) · Aufgaben

# Per SSH in eine Sandbox: Shell, scp, SFTP und Tunnel

Aktualisiert 22. November 2026 · 5 Min. Lesezeit

Jede Sandbox nimmt einfaches `ssh`, `scp`, `sftp` und `ssh -L`: `ssh <sandbox id>@<server> -p 2222`, angemeldet mit einem SSH-Key des Workspace oder einem Token als Passwort. Ein Login weckt eine pausierte Sandbox, und darin muss nichts installiert werden.

**Kurz gesagt**

- **`Sandbox.ssh_command`** ist der Befehl: die ID der Sandbox als Benutzername, ihr Server, Port 2222.
- **Keys:** `SetSshKeys` gibt dem Workspace seine Public Keys, die bei jeder Sandbox anmelden; einen zu entfernen beendet seine Sitzungen.
- **Oder ein Token:** Das Token von `ConnectSandbox` ist das Passwort, für ein Programm oder eine Sandbox, die du einmal erreichst.
- **Eine Shell, SFTP und `-L`-Tunnel,** nur in die Sandbox, nie in ihren Server.

### Step 1: Dem Workspace deinen Public Key geben

`SetSshKeys` ersetzt die Keys des Workspace durch die Liste, die es bekommt, also schick die, die er hat, mit deinem. Die Workspace-Einstellungen der Konsole tun dasselbe, unter „SSH-Keys“.

Python

```
from pathlib import Path

mine = (Path.home() / ".ssh" / "id_ed25519.pub").read_text().strip()
kept = [key.public_key for key in sandboxes.get_workspace().ssh_keys]
workspace = sandboxes.set_ssh_keys(ssh_keys=[*kept, mine])
print([key.fingerprint for key in workspace.ssh_keys])
# ['SHA256:EqzSrW++0DTmPtQLG+r1oKBoKzfKQRilcUFxx/p/Eyw']
```

TypeScript

```
import { readFile } from "node:fs/promises";
import { homedir } from "node:os";

const mine = (await readFile(`${homedir()}/.ssh/id_ed25519.pub`, "utf8")).trim();
const kept = (await sandboxes.getWorkspace()).sshKeys.map((key) => key.publicKey);
const workspace = await sandboxes.setSshKeys({ sshKeys: [...kept, mine] });
console.log(workspace.sshKeys.map((key) => key.fingerprint));
```

Go

```
home, _ := os.UserHomeDir()
mine, err := os.ReadFile(home + "/.ssh/id_ed25519.pub")
if err != nil {
	log.Fatal(err)
}
current, err := client.GetWorkspace(ctx, &sandboxes.GetWorkspaceRequest{})
if err != nil {
	log.Fatal(err)
}
keys := []string{strings.TrimSpace(string(mine))}
for _, key := range current.SSHKeys {
	keys = append(keys, key.PublicKey)
}
workspace, err := client.SetSSHKeys(ctx, &sandboxes.SetSSHKeysRequest{SSHKeys: keys})
if err != nil {
	log.Fatal(err)
}
fmt.Println(len(workspace.SSHKeys))
```

Rust

```
let mine = std::fs::read_to_string(format!("{}/.ssh/id_ed25519.pub", std::env::var("HOME")?))?;
let current = sandboxes.get_workspace(GetWorkspaceRequest::default()).await?;
let mut keys: Vec<String> = current.ssh_keys.into_iter().map(|key| key.public_key).collect();
keys.push(mine.trim().to_string());
let workspace = sandboxes
    .set_ssh_keys(SetSshKeysRequest { ssh_keys: keys, ..Default::default() })
    .await?;
println!("{}", workspace.ssh_keys.len());
```

### Step 2: SSH-Befehl der Sandbox nehmen

Der Eintrag einer Sandbox hat ihr `ssh_command`. Es ändert sich nur, wenn eine gestoppte Sandbox auf einem anderen Server startet, also lies es aus dem Eintrag, statt es aufzubewahren.

Python

```
print(sandboxes.get_sandbox(sandbox_id).ssh_command)
# ssh e9bprbw1hovj6sw5@sbx1.sandboxes.pethost.network -p 2222
```

TypeScript

```
console.log((await sandboxes.getSandbox({ sandboxId })).sshCommand);
```

Go

```
record, err := client.GetSandbox(ctx, &sandboxes.GetSandboxRequest{SandboxID: id})
if err != nil {
	log.Fatal(err)
}
fmt.Println(record.SSHCommand)
```

Rust

```
let record = sandboxes
    .get_sandbox(GetSandboxRequest { sandbox_id: id.clone(), ..Default::default() })
    .await?;
println!("{}", record.ssh_command);
```

CLI

```
$ pethost sandbox show api-dev
id          e9bprbw1hovj6sw5
name        api-dev
state       running since 01:19
next        paused today at 01:29, unless something happens in it
size        default, disk 20 GiB
template    base@17
port 5173   https://5173-e9bprbw1hovj6sw5.sbx1.sandboxes.pethost.network
ssh         ssh e9bprbw1hovj6sw5@sbx1.sandboxes.pethost.network -p 2222
panel       https://console.pethost.dev/w/af6hvmyk/sandboxes/e9bprbw1hovj6sw5
used        running 6 min 17 s
created     today at 01:19
```

MCP

```
GetSandbox {"sandbox_id": "…"}
```

### Step 3: Anmelden

```
$ ssh e9bprbw1hovj6sw5@sbx1.sandboxes.pethost.network -p 2222
user@e9bprbw1hovj6sw5:~$
```

Die Shell läuft als `user` in `/home/user`, mit sudo. Eine pausierte Sandbox wacht auf, während du dich anmeldest, und bleibt wach, solange die Sitzung offen ist.

## Ohne Key: ein Token als Passwort

`ConnectSandbox` antwortet mit einem Token für eine Sandbox, eine Stunde gültig, außer `ttl_seconds` sagt etwas anderes, bis zu 86.400 s, und demselben `ssh_command`: Das Token ist sein Passwort. Das passt zu einem Programm oder einer Person, die eine Sandbox einmal erreicht. Das Token ist root in dieser Sandbox: Halte es aus Logs und Nachrichten heraus. `UpdateSandbox` mit `revoke_tokens` macht jedes Token und jeden Link, der für die Sandbox erstellt wurde, ungültig.

`pethost sandbox shell <id>` erledigt all das für dich: Es holt ein Token und öffnet die Shell in deinem Terminal, ohne etwas einzurichten, und führt einen Befehl nach `--` ebenfalls auf einem Terminal aus.

```
$ pethost sandbox shell api-dev -- uptime
 00:25:49 up 6 min,  0 user,  load average: 0.04, 0.04, 0.00
```

## Dateien und Tunnel

Dieselbe Adresse und derselbe Port bedienen `scp` und `sftp` und leiten Ports mit `-L` weiter:

```
scp -P 2222 ./data.csv k7f3q2xy0a1b2c3d@sbx1.sandboxes.pethost.network:data/
sftp -P 2222 k7f3q2xy0a1b2c3d@sbx1.sandboxes.pethost.network
ssh -N -L 5173:localhost:5173 k7f3q2xy0a1b2c3d@sbx1.sandboxes.pethost.network -p 2222
```

Ein Tunnel erreicht jeden Port in der Sandbox, auch Ports, die an `localhost` gebunden sind, also öffnet er einen privaten Port in deinem eigenen Browser unter `http://localhost:5173`, ohne Token ([Ports und Vorschauen](https://pethost.dev/de/docs/sandboxes/ports-and-previews/)).

## So funktioniert es

In der Sandbox läuft kein SSH-Server. Der Server, auf dem sie läuft, antwortet auf Port 2222: Er prüft den Key oder das Token, bevor irgendetwas aufwacht, und führt dann deine Shell als Prozess auf einem Terminal der Sandbox aus, SFTP als Programm darin und einen Tunnel direkt zum Port. Er erreicht diese eine Sandbox und nichts vom Server selbst. Ein Befehl, den du über SSH ausführst, steht in `ListCommands`, solange er läuft, und sein Ende ist ein Event, gestartet über SSH.

- **Ein Login weckt eine pausierte Sandbox,** in etwa 0,1 s. Eine gestoppte wacht so nur mit `wake_when_stopped` auf; sonst wird der Login mit „stopped: resume it“ abgelehnt, und `ResumeSandbox` startet sie.
- **Eine offene Sitzung hält die Sandbox wach** und zählt als RUNNING. Schließ sie, und die Leerlauf-Timer beginnen.
- **Einen Key zu entfernen beendet seine Sitzungen** in jeder Sandbox des Workspace.
- **Eine Sitzung nimmt höchstens 64 Variablen** von deinem Client.

## Wenn es nicht funktioniert

- **„Permission denied (publickey,password)“:** Der Key gehört nicht zum Workspace, oder das Token ist abgelaufen. Füg den Key mit `SetSshKeys` hinzu, oder hol dir von `ConnectSandbox` ein frisches Token.
- **„stopped: resume it“:** Die Sandbox ist gestoppt. `ResumeSandbox` startet sie, ihre Dateien, wie sie sie verlassen hat.
- **Die Verbindung läuft in einen Timeout:** Eine Firewall auf deiner Seite blockiert Port 2222. Versuch es aus einem anderen Netz, oder nimm `pethost sandbox shell`, das denselben Port braucht.
- **Die Adresse antwortet nicht mehr für die Sandbox:** Eine gestoppte Sandbox ist auf einem anderen Server gestartet, mit neuem `ssh_command`. Lies es neu aus dem Eintrag.
- **Eine Sitzung hat sich von selbst beendet:** Der Key wurde entfernt, oder die Tokens der Sandbox wurden widerrufen.

## Fragen

### Wie komme ich per SSH in eine Sandbox?

Füg deinen Public Key zum Workspace hinzu, dann führ das `ssh_command` der Sandbox aus: `ssh <sandbox id>@<server> -p 2222`.

### Kann ich scp und SFTP nutzen?

Ja, unter derselben Adresse mit `-P 2222`, und `ssh -L` leitet ihre Ports weiter.

### Weckt SSH eine pausierte Sandbox?

Ja, beim Login, in etwa 0,1 s, und die offene Sitzung hält sie wach.

### Kann ich per SSH auf den Server, auf dem eine Sandbox läuft?

Nein. Ein Login erreicht nur seine Sandbox.

### Muss ich einen SSH-Server in der Sandbox installieren?

Nein. Der Server der Sandbox beantwortet SSH und führt deine Shell in der Sandbox aus.

[ZurückVolumes: eine Disk, die Sandboxes überdauert](https://pethost.dev/de/docs/sandboxes/volumes/) [WeiterObservability: Metriken, Events und Verbrauch einer Sandbox](https://pethost.dev/de/docs/sandboxes/observability/)

## Pethost Agent Sandboxes ausprobieren

Eine Testphase von 7 Tagen mit 1 $ Verbrauch und 4 vCPUs, mit Karte. Danach ein Tarif ab 20 $ im Monat, der genauso viel Verbrauch enthält.

[Testphase starten](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Vorlagen](https://pethost.dev/de/templates/)
- [Über uns](https://pethost.dev/about/)
- [Doku](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/de/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [AGB](https://pethost.dev/terms/)
- [Datenschutz](https://pethost.dev/privacy/)
- [Erstattung](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Datenbanken

- [Postgres](https://pethost.dev/de/postgres/)
- [Valkey](https://pethost.dev/de/valkey/)

Agent Sandboxes

- [Sandboxes](https://pethost.dev/de/sandboxes/)
- [Preise](https://pethost.dev/de/sandboxes/#pricing)
- [Doku](https://pethost.dev/de/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Vergleiche

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/de/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/de/blog/coolify-cloud-vs-dokploy-cloud/)
- [Railway vs Render vs Fly.io Preise](https://pethost.dev/de/blog/railway-vs-render-vs-fly-io-pricing/)
- [Managed Hosting für Docker Compose](https://pethost.dev/de/blog/managed-docker-compose-hosting/)

Alternativen

- [Railway-Alternativen](https://pethost.dev/de/blog/railway-alternatives/)
- [Heroku-Alternativen](https://pethost.dev/de/blog/heroku-alternatives/)
- [Dokploy-Alternativen](https://pethost.dev/de/blog/dokploy-alternatives/)
- [Coolify-Alternativen](https://pethost.dev/de/blog/coolify-alternatives/)
- [Render-Alternativen](https://pethost.dev/de/blog/render-alternatives/)
- [Sliplane-Alternativen](https://pethost.dev/de/blog/sliplane-alternatives/)
