Español
Menú de la documentación

Documentación de Agent Sandboxes · Tareas

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

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

$ ssh [email protected] -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 [email protected]:data/
sftp -P 2222 [email protected]
ssh -N -L 5173:localhost:5173 [email protected] -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).

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.

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