Dokumentacja Agent Sandboxes · Zadania
Fork sandboxa, razem z pamięcią i procesami
Fork kopiuje sandbox taki, jaki jest w tej chwili, z pamięcią, działającymi procesami i dyskiem, do nowych sandboxów, które idą dalej od tego miejsca. Agent próbuje naraz trzech poprawek z tego samego stanu, ewaluacja uruchamia sto ziaren z jednego rozgrzanego środowiska, a kopie, które przegrają, są usuwane.
ForkSandboxrobi do 100 kopii jednym wywołaniem, w stanie RUNNING na serwerze źródła; trzy zajmują ok. 0,25 s.- Źródło działa dalej: działające wstrzymuje się na kilka milisekund; wstrzymane zostaje wstrzymane; kopie zatrzymanego startują z jego dysku.
- Każda kopia ma własne id, nazwę hosta, machine-id i losowość jądra, rozmiar źródła i żadnej nazwy.
- Wszystkie albo żadna: każda kopia to start i liczy swoje vCPU; gdy nie zmieszczą się wszystkie, nie powstaje żadna.
Step 1: Zrób fork sandboxa
Daj kopiom własną etykietę, żeby później znaleźć je razem. Bez niej dostają etykiety źródła.
from pethost.sandboxes import Label
run = Label(key="run", value="seeds-7")
copies = sandboxes.fork_sandbox(sandbox_id, count=3, labels=[run]).sandboxes
print([copy.sandbox_id for copy in copies])
# ['kecrb56zb2sqfmy0', '9pd5esg1e2vguf1j', 'zawco1pzbjzgxjyy']
const run = { key: "run", value: "seeds-7" };
const { sandboxes: copies } = await sandboxes.forkSandbox({ sandboxId, count: 3, labels: [run] });
console.log(copies.map((copy) => copy.sandboxId));
run := sandboxes.Label{Key: "run", Value: "seeds-7"}
forked, err := client.ForkSandbox(ctx, &sandboxes.ForkSandboxRequest{SandboxID: id, Count: 3, Labels: []sandboxes.Label{run}})
if err != nil {
log.Fatal(err)
}
for _, copy := range forked.Sandboxes {
fmt.Println(copy.SandboxID)
}
let run = Label { key: "run".into(), value: "seeds-7".into() };
let copies = sandboxes
.fork_sandbox(ForkSandboxRequest {
sandbox_id: id.clone(),
count: 3,
labels: vec![run.clone()],
..Default::default()
})
.await?
.sandboxes;
for copy in &copies {
println!("{}", copy.sandbox_id);
}
$ pethost sandbox fork api-dev --count 3 --label run=seeds-7
✓ Forked api-dev into 3 sandboxes in 1 s
us8wjivt4ndyu3mn
7sfjrgzwk72v3ie4
955mpq7p89sfaezv
ForkSandbox {"sandbox_id": "…", "count": 3, "labels": [{"key": "run", "value": "seeds-7"}]}
Step 2: Daj każdej kopii własną pracę
Każda kopia odpowiada na własne wywołania. Uruchom w każdej inne zadanie, nie czekając na nie, i oznacz je keep_awake, żeby żadna kopia nie wstrzymała się w trakcie swojego zadania.
for seed, copy in enumerate(copies):
sandboxes.run_command(
copy.sandbox_id,
command=f"python3 experiment.py --seed {seed} > result.txt",
wait_seconds=0,
keep_awake=True,
)
await Promise.all(
copies.map((copy, seed) =>
sandboxes.runCommand({
sandboxId: copy.sandboxId,
command: `python3 experiment.py --seed ${seed} > result.txt`,
waitSeconds: 0,
keepAwake: true,
}),
),
);
for seed, copy := range forked.Sandboxes {
_, err := client.RunCommand(ctx, &sandboxes.RunCommandRequest{
SandboxID: copy.SandboxID,
Command: fmt.Sprintf("python3 experiment.py --seed %d > result.txt", seed),
WaitSeconds: new(uint32(0)),
KeepAwake: true,
})
if err != nil {
log.Fatal(err)
}
}
for (seed, copy) in copies.iter().enumerate() {
sandboxes
.run_command(RunCommandRequest {
sandbox_id: copy.sandbox_id.clone(),
command: format!("python3 experiment.py --seed {seed} > result.txt"),
wait_seconds: Some(0),
keep_awake: true,
..Default::default()
})
.await?;
}
Step 3: Zostaw tę, która zadziałała, resztę usuń
ListSandboxes z etykietą przebiegu znajduje kopie; usuń te, których nie zostawiasz. Zostawiona kopia to sandbox jak każdy inny: nadaj jej nazwę przez UpdateSandbox.
best = copies[0].sandbox_id # the copy whose result you keep
for copy in sandboxes.list_sandboxes(labels=[run]).sandboxes:
if copy.sandbox_id != best:
sandboxes.delete_sandbox(copy.sandbox_id)
const best = copies[0]!.sandboxId; // the copy whose result you keep
const { sandboxes: found } = await sandboxes.listSandboxes({ labels: [run] });
for (const copy of found) {
if (copy.sandboxId !== best) await sandboxes.deleteSandbox({ sandboxId: copy.sandboxId });
}
best := forked.Sandboxes[0].SandboxID // the copy whose result you keep
found, err := client.ListSandboxes(ctx, &sandboxes.ListSandboxesRequest{Labels: []sandboxes.Label{run}})
if err != nil {
log.Fatal(err)
}
for _, copy := range found.Sandboxes {
if copy.SandboxID != best {
if _, err := client.DeleteSandbox(ctx, &sandboxes.DeleteSandboxRequest{SandboxID: copy.SandboxID}); err != nil {
log.Fatal(err)
}
}
}
let best = copies[0].sandbox_id.clone(); // the copy whose result you keep
let found = sandboxes
.list_sandboxes(ListSandboxesRequest { labels: vec![run], ..Default::default() })
.await?;
for copy in found.sandboxes.iter().filter(|copy| copy.sandbox_id != best) {
let gone = DeleteSandboxRequest { sandbox_id: copy.sandbox_id.clone(), ..Default::default() };
sandboxes.delete_sandbox(gone).await?;
}
$ pethost sandbox ls --label run=seeds-7
ID NAME STATE SIZE TEMPLATE CREATED LABELS
us8wjivt4ndyu3mn running default base@17 20 s ago run=seeds-7
955mpq7p89sfaezv running default base@17 20 s ago run=seeds-7
7sfjrgzwk72v3ie4 running default base@17 20 s ago run=seeds-7
$ pethost sandbox rm us8wjivt4ndyu3mn 7sfjrgzwk72v3ie4 --yes
us8wjivt4ndyu3mn deleted
7sfjrgzwk72v3ie4 deleted
Co ma kopia
Kopia to źródło takie, jakie było w chwili forka: te same pliki, ta sama pamięć, te same procesy na tej samej instrukcji. Serwer deweloperski dalej serwuje, sesja Pythona zachowuje swoje zmienne, a rozmowa agenta kodującego jest gotowa do kontynuacji, w każdej kopii. Kopie działają na serwerze źródła, w rozmiarze źródła i z jego dyskiem. Ich pozostałe ustawienia są takie jak źródła, chyba że fork wysyła własną grupę (settings), np. inny ruch wychodzący albo środowisko; inny rozmiar jest odrzucany.
Każda kopia dostaje własne id, które jest też jej nazwą hosta, własny machine-id i świeżą losowość jądra, więc /dev/urandom różni się od pierwszego odczytu. Nie ma nazwy: nazwy są unikalne, a UpdateSandbox nadaje ją zostawionej kopii.
Daj nowe ziarno temu, co generuje liczby losowe
Jądro dostaje nowe ziarno w każdej kopii; własny generator procesu nie. Generator losowy zainicjowany przed forkiem, random w Pythonie, math/rand w Go, Math.random w V8, generator OpenSSL, daje w każdej kopii te same liczby, dopóki nie dostanie nowego ziarna, a klucze wygenerowane przed forkiem są takie same w każdej kopii. Inicjuj eksperymenty po forku, jak robi to ziarno powyżej, i klucze też generuj po nim.
Źródło i koszt forka
- Źródło RUNNING wstrzymuje się na kilka milisekund, gdy pobierane są jego pamięć i dysk, i działa dalej.
- Źródło PAUSED zostaje wstrzymane, a jego kopie startują z jego zapisanej pamięci.
- Źródło STOPPED nie ma pamięci: jego kopie startują z jego dysku, jak przy uruchomieniu systemu.
Fork to wszystkie albo żadna. Każda kopia liczy swoje vCPU do twojego planu od swojego startu i każda jest startem w limicie startów planu na minutę, godzinę i dzień. Starty są darmowe: kopia kosztuje to, co działa, co do sekundy, jak każdy sandbox. Gdy serwer źródła nie ma miejsca na wszystkie kopie, wywołanie jest odrzucane z UNAVAILABLE i NoCapacity, którego fork_count mówi, ile się zmieści. Z sandboxa z wolumenem do odczytu i zapisu nie da się zrobić forka, bo wolumen zapisuje naraz jeden sandbox.
Gdy to nie działa
UNAVAILABLEzNoCapacity: serwer źródła nie ma miejsca na wszystkie kopie. Poproś ofork_countkopii lub mniej albo spróbuj później.RESOURCE_EXHAUSTEDzLimitReached,vcpus: kopie przekroczyłyby vCPU twojego planu. Usuń niepotrzebne sandboxy albo zrób mniej kopii.LimitReachedz limitemstarts_per_*: kopie przekroczyłyby starty okna;retry_timemówi, kiedy się zmieszczą. Fork z większą liczbą kopii niż sam limit nie maretry_time: podziel go.FAILED_PRECONDITION: sandbox montuje wolumen do odczytu i zapisu. Rób fork sandboxa, który montuje go tylko do odczytu albo nie montuje wcale.- Każda kopia wypisuje te same liczby losowe: generator dostał ziarno przed forkiem. Zainicjuj go ponownie w każdej kopii.
Pytania
Jak sklonować działający sandbox?
ForkSandbox z count: każda kopia ma pamięć, procesy i dysk źródła i działa dalej od miejsca, w którym było źródło.
Ile kopii może zrobić jeden fork?
Do 100, wszystkie albo żadna, w ramach vCPU i startów twojego planu.
Czy fork zatrzymuje oryginalny sandbox?
Nie. Działające źródło wstrzymuje się na kilka milisekund i działa dalej.
Czy fork jest rozliczany?
Starty są darmowe. Każda kopia jest rozliczana co do sekundy za swój stan, jak każdy sandbox.
Czym różni się fork od szablonu?
Fork kopiuje sandbox teraz, z pamięcią i procesami, na jego serwerze. Szablon zachowuje pliki sandboxa dla nowych sandboxów na dowolnym serwerze, bez pamięci i procesów.
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.