Dokumentacja Agent Sandboxes · Zadania
SSH do sandboxa: powłoka, scp, SFTP i tunele
Każdy sandbox przyjmuje zwykłe ssh, scp, sftp i ssh -L: ssh <sandbox id>@<server> -p 2222, z logowaniem kluczem SSH przestrzeni roboczej albo tokenem jako hasłem. Logowanie budzi wstrzymany sandbox, a w środku nie trzeba niczego instalować.
Sandbox.ssh_commandto polecenie: id sandboxa jako nazwa użytkownika, jego serwer, port 2222.- Klucze:
SetSshKeysdaje przestrzeni roboczej jej klucze publiczne, które logują do każdego sandboxa; usunięcie klucza kończy jego sesje. - Albo token: token z
ConnectSandboxjest hasłem, dla programu albo sandboxa, do którego wchodzisz raz. - Powłoka, SFTP i tunele
-L, tylko do sandboxa, nigdy do jego serwera.
Step 1: Daj przestrzeni roboczej swój klucz publiczny
SetSshKeys zastępuje klucze przestrzeni roboczej podaną listą, więc wyślij te, które już ma, razem ze swoim. To samo robią ustawienia przestrzeni roboczej w panelu, w sekcji Klucze SSH.
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: Weź polecenie SSH sandboxa
Zapis sandboxa ma jego ssh_command. Zmienia się tylko wtedy, gdy zatrzymany sandbox wystartuje na innym serwerze, więc czytaj je z zapisu, zamiast je przechowywać.
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: Zaloguj się
$ ssh [email protected] -p 2222
user@e9bprbw1hovj6sw5:~$
Powłoka działa jako user w /home/user, z sudo. Wstrzymany sandbox budzi się, gdy się logujesz, i nie śpi, dopóki sesja jest otwarta.
Bez klucza: token jako hasło
ConnectSandbox zwraca token dla jednego sandboxa, ważny godzinę, chyba że ttl_seconds mówi inaczej, do 86 400 s, i to samo ssh_command: token jest jego hasłem. Pasuje do programu albo do człowieka, który wchodzi do sandboxa raz. Token daje roota w tym sandboxie: trzymaj go z dala od logów i wiadomości. UpdateSandbox z revoke_tokens sprawia, że każdy token i link utworzony dla sandboxa przestaje działać.
pethost sandbox shell <id> robi to wszystko za ciebie: prosi o token i otwiera powłokę w twoim terminalu, bez żadnej konfiguracji, a polecenie po -- też uruchamia w terminalu.
$ pethost sandbox shell api-dev -- uptime
00:25:49 up 6 min, 0 user, load average: 0.04, 0.04, 0.00
Pliki i tunele
Ten sam adres i port obsługują scp i sftp oraz przekierowują porty przez -L:
scp -P 2222 ./data.csv [email protected]:data/
sftp -P 2222 [email protected]
ssh -N -L 5173:localhost:5173 [email protected] -p 2222
Tunel sięga do dowolnego portu w sandboxie, także portów przypiętych do localhost, więc otwiera prywatny port w twojej własnej przeglądarce pod http://localhost:5173 bez tokena (porty i podglądy).
Jak to działa
W sandboxie nie działa żaden serwer SSH. Na porcie 2222 odpowiada serwer, na którym działa sandbox: sprawdza klucz albo token, zanim cokolwiek się obudzi, a potem uruchamia twoją powłokę jako proces na terminalu sandboxa, SFTP jako program w nim, a tunel prosto do portu. Sięga tylko do tego jednego sandboxa i do niczego z samego serwera. Polecenie uruchomione przez SSH jest wymieniane przez ListCommands, dopóki działa, a jego koniec jest zdarzeniem z oznaczeniem, że uruchomiono je przez SSH.
- Logowanie budzi wstrzymany sandbox, w ok. 0,1 s. Zatrzymany budzi się tak tylko z
wake_when_stopped; inaczej logowanie jest odrzucane z „stopped: resume it”, a uruchamia goResumeSandbox. - Otwarta sesja nie pozwala sandboxowi zasnąć i liczy się jako RUNNING. Zamknij ją, a ruszą liczniki bezczynności.
- Usunięcie klucza kończy jego sesje w każdym sandboxie przestrzeni roboczej.
- Sesja przyjmuje najwyżej 64 zmiennych od twojego klienta.
Gdy to nie działa
- „Permission denied (publickey,password)”: klucz nie należy do przestrzeni roboczej albo token wygasł. Dodaj klucz przez
SetSshKeysalbo poprośConnectSandboxo świeży token. - „stopped: resume it”: sandbox jest zatrzymany.
ResumeSandboxgo uruchamia, z plikami takimi, jakie zostawił. - Połączenie przekracza czas: firewall po twojej stronie blokuje port 2222. Spróbuj z innej sieci albo użyj
pethost sandbox shell, który potrzebuje tego samego portu. - Adres już nie odpowiada za sandbox: zatrzymany sandbox wystartował na innym serwerze, z nowym
ssh_command. Odczytaj je ponownie z zapisu. - Sesja sama się zakończyła: jej klucz usunięto albo tokeny sandboxa unieważniono.
Pytania
Jak połączyć się z sandboxem przez SSH?
Dodaj swój klucz publiczny do przestrzeni roboczej, a potem uruchom ssh_command sandboxa: ssh <sandbox id>@<server> -p 2222.
Czy mogę używać scp i SFTP?
Tak, pod tym samym adresem z -P 2222, a ssh -L przekierowuje jego porty.
Czy SSH budzi wstrzymany sandbox?
Tak, przy logowaniu, w ok. 0,1 s, a otwarta sesja nie pozwala mu zasnąć.
Czy mogę zalogować się przez SSH na serwer, na którym działa sandbox?
Nie. Logowanie sięga tylko do jego sandboxa.
Czy muszę instalować serwer SSH w sandboxie?
Nie. Na SSH odpowiada serwer sandboxa i to on uruchamia twoją powłokę w sandboxie.
Wypróbuj Pethost Agent Sandboxes
Okres próbny na 7 dni z 1 $ zużycia i 4 vCPU, z kartą. Potem plan od 20 $ miesięcznie, który zawiera tyle samo zużycia.