---
title: "SSH a un sandbox: shell, scp, SFTP y túneles | Pethost Agent Sandboxes"
description: "Inicia sesión en cualquier sandbox con ssh normal, copia archivos con scp y SFTP y redirige sus puertos con ssh -L, con una clave o un token como contraseña."
---

[Documentación de Agent Sandboxes](https://pethost.dev/es/docs/sandboxes/) · Tareas

# SSH a un sandbox: shell, scp, SFTP y túneles

Actualizado 22 de noviembre de 2026 · 5 min de lectura

Cada sandbox acepta `ssh`, `scp`, `sftp` y `ssh -L` normales: `ssh <sandbox id>@<server> -p 2222`, con una clave SSH del espacio de trabajo o un token como contraseña. Un inicio de sesión despierta un sandbox en pausa, y no hay que instalar nada en él.

**En resumen**

- **`Sandbox.ssh_command`** es el comando: el id del sandbox como nombre de usuario, su servidor, puerto 2222.
- **Claves:** `SetSshKeys` le da al espacio de trabajo sus claves públicas, que inician sesión en cada sandbox; quitar una termina sus sesiones.
- **O un token:** el token de `ConnectSandbox` es la contraseña, para un programa o un sandbox al que entras una vez.
- **Una shell, SFTP y túneles `-L`,** solo dentro del sandbox, nunca en su servidor.

### Step 1: Dale tu clave pública al espacio de trabajo

`SetSshKeys` reemplaza las claves del espacio de trabajo por la lista que recibe, así que envía las que ya tiene junto con la tuya. Los ajustes del espacio de trabajo en el panel hacen lo mismo, en Claves 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: Toma el comando SSH del sandbox

El registro de un sandbox tiene su `ssh_command`. Solo cambia cuando un sandbox detenido se inicia en otro servidor, así que léelo del registro en vez de guardarlo.

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: Inicia sesión

```
$ ssh e9bprbw1hovj6sw5@sbx1.sandboxes.pethost.network -p 2222
user@e9bprbw1hovj6sw5:~$
```

La shell se ejecuta como `user` en `/home/user`, con sudo. Un sandbox en pausa despierta al iniciar sesión, y sigue despierto mientras la sesión esté abierta.

## Sin clave: un token como contraseña

`ConnectSandbox` responde un token para un sandbox, válido una hora salvo que `ttl_seconds` diga otra cosa, hasta 86.400 s, y el mismo `ssh_command`: el token es su contraseña. Conviene a un programa, o a una persona que entra una vez en un sandbox. El token es root en ese sandbox: déjalo fuera de logs y mensajes. `UpdateSandbox` con `revoke_tokens` hace que dejen de funcionar todos los tokens y enlaces creados para el sandbox.

`pethost sandbox shell <id>` hace todo esto por ti: pide un token y abre la shell en tu terminal, sin nada que configurar, y también ejecuta en una terminal un comando escrito tras `--`.

```
$ pethost sandbox shell api-dev -- uptime
 00:25:49 up 6 min,  0 user,  load average: 0.04, 0.04, 0.00
```

## Archivos y túneles

La misma dirección y el mismo puerto sirven `scp` y `sftp`, y redirigen puertos con `-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
```

Un túnel llega a cualquier puerto del sandbox, incluidos los puertos ligados a `localhost`, así que abre un puerto privado en tu propio navegador en `http://localhost:5173` sin token ([puertos y previsualizaciones](https://pethost.dev/es/docs/sandboxes/ports-and-previews/)).

## Cómo funciona

En el sandbox no se ejecuta ningún servidor SSH. El servidor en el que se ejecuta responde en el puerto 2222: comprueba la clave o el token antes de que nada despierte, y después ejecuta tu shell como un proceso en una terminal del sandbox, SFTP como un programa dentro de él, y un túnel directo al puerto. Llega a ese sandbox y a nada del propio servidor. Un comando que ejecutas por SSH aparece en `ListCommands` mientras se ejecuta, y su final es un evento, iniciado por SSH.

- **Un inicio de sesión despierta un sandbox en pausa,** en unos 0,1 s. Uno detenido solo despierta así con `wake_when_stopped`; si no, el inicio de sesión se rechaza con “stopped: resume it”, y `ResumeSandbox` lo inicia.
- **Una sesión abierta mantiene despierto el sandbox,** y cuenta como RUNNING. Ciérrala, y empiezan los temporizadores de inactividad.
- **Quitar una clave termina sus sesiones** en todos los sandboxes del espacio de trabajo.
- **Una sesión toma como máximo 64 variables** de tu cliente.

## Cuando no funciona

- **“Permission denied (publickey,password)”:** la clave no es una de las del espacio de trabajo, o el token caducó. Agrega la clave con `SetSshKeys`, o pide a `ConnectSandbox` un token nuevo.
- **“stopped: resume it”:** el sandbox está detenido. `ResumeSandbox` lo inicia, con sus archivos como los dejó.
- **La conexión agota el tiempo de espera:** un firewall de tu lado bloquea el puerto 2222. Prueba desde otra red, o usa `pethost sandbox shell`, que necesita el mismo puerto.
- **La dirección ya no responde por el sandbox:** un sandbox detenido se inició en otro servidor, con un `ssh_command` nuevo. Vuelve a leerlo del registro.
- **Una sesión terminó sola:** se quitó su clave, o se revocaron los tokens del sandbox.

## Preguntas

### ¿Cómo entro por SSH en un sandbox?

Agrega tu clave pública al espacio de trabajo y ejecuta el `ssh_command` del sandbox: `ssh <sandbox id>@<server> -p 2222`.

### ¿Puedo usar scp y SFTP?

Sí, en la misma dirección con `-P 2222`, y `ssh -L` redirige sus puertos.

### ¿SSH despierta un sandbox en pausa?

Sí, al iniciar sesión, en unos 0,1 s, y la sesión abierta lo mantiene despierto.

### ¿Puedo entrar por SSH en el servidor en el que se ejecuta un sandbox?

No. Un inicio de sesión solo llega a su sandbox.

### ¿Tengo que instalar un servidor SSH en el sandbox?

No. El servidor del sandbox responde a SSH y ejecuta tu shell dentro del sandbox.

[AnteriorVolúmenes: un disco que sobrevive a los sandboxes](https://pethost.dev/es/docs/sandboxes/volumes/) [SiguienteObservabilidad: métricas, eventos y uso de un sandbox](https://pethost.dev/es/docs/sandboxes/observability/)

## Prueba Pethost Agent Sandboxes

Una prueba gratis de 7 días con 1 US$ de uso y 4 vCPU, con tarjeta. Después, un plan desde 20 US$ al mes, que incluye ese mismo importe en uso.

[Empezar la prueba gratis](https://console.pethost.dev/)

Pethost · Stephan Gomer · NIP 1133096755

Pethost

- [Plantillas](https://pethost.dev/es/templates/)
- [Sobre nosotros](https://pethost.dev/about/)
- [Docs](https://pethost.dev/docs/)
- [Blog](https://pethost.dev/es/blog/)
- [API](https://pethost.dev/docs/api/)
- [CLI](https://pethost.dev/docs/cli/)
- [Plugin](https://github.com/pethost-dev/plugin)
- [Términos](https://pethost.dev/terms/)
- [Privacidad](https://pethost.dev/privacy/)
- [Reembolsos](https://pethost.dev/refunds/)
- [support@pethost.dev](mailto:support@pethost.dev)

Bases de datos

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

Agent Sandboxes

- [Sandboxes](https://pethost.dev/es/sandboxes/)
- [Precios](https://pethost.dev/es/sandboxes/#pricing)
- [Docs](https://pethost.dev/es/docs/sandboxes/)
- [API](https://pethost.dev/docs/sandboxes/api/)

Comparativas

- [Coolify vs Dokploy vs CapRover vs Dokku](https://pethost.dev/es/blog/coolify-vs-dokploy-vs-caprover-vs-dokku/)
- [Coolify Cloud vs Dokploy Cloud](https://pethost.dev/es/blog/coolify-cloud-vs-dokploy-cloud/)
- [Precios de Railway vs Render vs Fly.io](https://pethost.dev/es/blog/railway-vs-render-vs-fly-io-pricing/)
- [Hosting gestionado para Docker Compose](https://pethost.dev/es/blog/managed-docker-compose-hosting/)

Alternativas

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