---
title: "SSH do sandboxa: powłoka, scp, SFTP i tunele | Pethost Agent Sandboxes"
description: "Loguj się do sandboxa zwykłym ssh, kopiuj pliki przez scp i SFTP, przekierowuj porty przez ssh -L, z kluczem przestrzeni roboczej albo tokenem jako hasłem."
---

[Dokumentacja Agent Sandboxes](https://pethost.dev/pl/docs/sandboxes/) · Zadania

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

Zaktualizowano 22 listopada 2026 · 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 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: Zaloguj się

```
$ ssh e9bprbw1hovj6sw5@sbx1.sandboxes.pethost.network -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 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
```

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](https://pethost.dev/pl/docs/sandboxes/ports-and-previews/)).

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

[PoprzedniaWolumeny: dysk, który przeżywa sandboxy](https://pethost.dev/pl/docs/sandboxes/volumes/) [NastępnaObserwowalność: metryki, zdarzenia i zużycie sandboxa](https://pethost.dev/pl/docs/sandboxes/observability/)

## 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](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Szablony](https://pethost.dev/pl/templates/)
- [O nas](https://pethost.dev/about/)
- [Dokumentacja](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/pl/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Regulamin](https://pethost.dev/terms/)
- [Prywatność](https://pethost.dev/privacy/)
- [Zwroty](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bazy danych

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

Agent Sandboxes

- [Sandboxy](https://pethost.dev/pl/sandboxes/)
- [Cennik](https://pethost.dev/pl/sandboxes/#pricing)
- [Dokumentacja](https://pethost.dev/pl/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Porównania

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/pl/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/pl/blog/coolify-cloud-vs-dokploy-cloud/)
- [Cennik Railway vs Render vs Fly.io](https://pethost.dev/pl/blog/railway-vs-render-vs-fly-io-pricing/)
- [Zarządzany hosting Docker Compose](https://pethost.dev/pl/blog/managed-docker-compose-hosting/)

Alternatywy

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