Deutsch
Menü der Doku

Doku zu Agent Sandboxes · Aufgaben

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

Aktualisiert · 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 [email protected] -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 [email protected] -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 [email protected] -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 [email protected]:data/
sftp -P 2222 [email protected]
ssh -N -L 5173:localhost:5173 [email protected] -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).

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.

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