Polski
Menu dokumentacji

Dokumentacja Agent Sandboxes · Zadania

SSH do sandboxa: powłoka, scp, SFTP i tunele

Zaktualizowano · 4 min czytania

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ć.

W skrócie
  • Sandbox.ssh_command to polecenie: id sandboxa jako nazwa użytkownika, jego serwer, port 2222.
  • Klucze: SetSshKeys daje przestrzeni roboczej jej klucze publiczne, które logują do każdego sandboxa; usunięcie klucza kończy jego sesje.
  • Albo token: token z ConnectSandbox jest 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.

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: 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ć.

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: 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 go ResumeSandbox.
  • 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 SetSshKeys albo poproś ConnectSandbox o świeży token.
  • „stopped: resume it”: sandbox jest zatrzymany. ResumeSandbox go 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.

Zacznij okres próbny