Doku zu Agent Sandboxes · Aufgaben
Per SSH in eine Sandbox: Shell, scp, SFTP und Tunnel
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.
Sandbox.ssh_commandist der Befehl: die ID der Sandbox als Benutzername, ihr Server, Port 2222.- Keys:
SetSshKeysgibt dem Workspace seine Public Keys, die bei jeder Sandbox anmelden; einen zu entfernen beendet seine Sitzungen. - Oder ein Token: Das Token von
ConnectSandboxist 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“.
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']
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));
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))
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.
print(sandboxes.get_sandbox(sandbox_id).ssh_command)
# ssh [email protected] -p 2222
console.log((await sandboxes.getSandbox({ sandboxId })).sshCommand);
record, err := client.GetSandbox(ctx, &sandboxes.GetSandboxRequest{SandboxID: id})
if err != nil {
log.Fatal(err)
}
fmt.Println(record.SSHCommand)
let record = sandboxes
.get_sandbox(GetSandboxRequest { sandbox_id: id.clone(), ..Default::default() })
.await?;
println!("{}", record.ssh_command);
$ 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
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_stoppedauf; sonst wird der Login mit „stopped: resume it“ abgelehnt, undResumeSandboxstartet 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
SetSshKeyshinzu, oder hol dir vonConnectSandboxein frisches Token. - „stopped: resume it“: Die Sandbox ist gestoppt.
ResumeSandboxstartet 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.