Runtimes and kinds#
Everything in Hesperus runs in a runtime: one container on one machine
of your workspace, with the drive that holds your files mounted at
/content. This page explains the three kinds of runtime, their states,
how a notebook finds its runtime, and who may do what with one.
A runtime is a run#
A runtime is an Astraeus run with one worker, made for you:
- It asks for what you choose — CPU cores, memory, GPUs, a machine or a pool, an image, other drives — and nothing is refused because no machine has it free now: it waits, Pending, until one does (Resources and machines).
- It counts against the workspace's quota, shows in its usage and cost, and holds its GPUs while it runs, like any run (Quotas, pools and terms).
- It is never restarted. A runtime that stops is Stopped (or Failed); starting it again makes a new run on the same drive.
- It stops by itself when nobody uses it (Idle stop).
Its run is named after it and its start count: runtime dev runs as
dev-1, then dev-2 after it is started again, each with one worker
(dev-1-0). Run and worker pages, astra astraeus runs and
astra astraeus logs show them as any other.
Three kinds#
Kind (kind) |
Console | What runs in the container | Reached by | Its drive at /content |
Idle stop (default) | SSH (default) |
|---|---|---|---|---|---|---|
jupyter |
a notebook's runtime | Jupyter Server and its kernels | the notebook editor in the console | the notebook's drive (default notebooks) |
30 min without activity | off; SSH into the runtime too turns it on |
shell |
Environment, kind Shell | only an SSH server | astra ssh, ssh, scp, rsync, VS Code, Cursor, JetBrains Gateway |
its own, <name>-home |
60 min with nobody connected | always on |
ide |
Environment, kind IDE | VS Code in the browser (code-server), and the SSH server unless turned off | Open IDE (astra env open), and SSH |
its own, <name>-home |
60 min with nobody connected | on; may be turned off |
Shell and IDE runtimes are development environments: long-lived containers for working from your own tools, with no notebook. Any kind can also serve apps — TensorBoard, Streamlit, Gradio, Spark's UI — that you start inside it and open in your browser (Addresses of their own).
The machine brings the SSH server and the IDE, mounted read-only into the
container: your image needs neither. A notebook's runtime needs Jupyter
Server, which most presets have; for an image without it, Jupyter Server
and ipykernel are installed onto the drive at its first start
(Presets and setup).
States#
| State | Meaning | Holds a machine |
|---|---|---|
| Pending | Its run is made; no machine has taken it yet. Why? says what it waits for. | about to |
| Starting | On a machine: the image is pulled (the first time there), the setup runs, its server starts. | yes |
| Ready | Its server answers: Jupyter Server, the SSH server, or the IDE. | yes |
| Stopping | Asked to stop, by a person or because it was idle. | yes, briefly |
| Stopped | Its run is gone. The drive keeps the files. Start runs it again. | no |
| Failed | Its run failed: the image, the machine, the server exiting with an error. Start runs it again. | no |
Each state comes with a reason, such as:
| Reason | When |
|---|---|
Started by user:… · Started by user:… for user:… · Started again by user:… |
Made or started (by an admin for someone else). A Pending runtime keeps this reason until a machine takes it: Why? says what it waits for. |
Starting Jupyter Server on gpu-01 (1 × NVIDIA GeForce RTX 4090) |
On a machine, not answering yet (its SSH server, its IDE (code-server) for environments). |
What the machine says while it prepares, then (gpu-01) |
The image being pulled, a drive being prepared, the IDE being downloaded. |
Ready on gpu-01 (1 × NVIDIA GeForce RTX 4090) |
Ready, with its machine and GPUs. |
Stopped by user:… · Stopped after 30 minutes idle |
Stopped by a person, or idle. |
Jupyter Server exited · Its SSH server exited · Its IDE (code-server) exited |
Its server ended by itself: Stopped. |
Its run could not be made: … · Its run dev-2 was deleted · the run's failure |
Failed. |
… runs on gpu-01, but its agent is too old to say it is ready: update the agent (Machines → gpu-01 → Update) |
Starting for good: the machine's agent predates Hesperus. |
Every change of state is an event of the workspace (notebook_runtime,
StateChanged), with who and why
(Events, audit and event streams).
What a runtime keeps, and what it loses#
When a runtime stops, its container is removed. What is on its drives stays
— the notebook file, your home in an environment, packages installed onto
the drive, checkpoints — and is there at the next start. Everything else
is lost: a kernel's variables, processes you started, packages installed
outside the drive, files written outside /content and the other drives.
See Drives and home.
Notebooks and their runtimes#
A notebook is a title, a drive and the path of an .ipynb file on that
drive (default: the workspace's notebooks drive, notebooks/<name>.ipynb),
and the runtime settings its runtimes are made of. The notebook's cells
and outputs are only in the file; Astralyx keeps the title, the drive and
the path, never the content.
Opening a notebook finds your runtime for it — one you started, on the
same drive, with the same image, resources, machine or pool, other drives,
SSH and setup — and starts one when there is none: one of yours that
stopped for this notebook is started again, else a new one is made, named
after the notebook with a random suffix (first-steps-3fa91c). A Ready one
is preferred, then one opened for this notebook. Two people opening the
same notebook each get their own runtime.
Change runtime… in the editor moves the notebook to a runtime with other settings (a new one starts; the kernel restarts). Runtime settings on the notebooks list changes what the notebook's next runtimes are made of. See Create and change a runtime.
Deleting a notebook removes it from the list; its file stays on the drive, and its runtimes run on until stopped or idle. Deleting a runtime removes it and its run; its drive keeps its files.
Who may do what#
| viewer | editor | admin | |
|---|---|---|---|
| See notebooks, runtimes and environments, their states and sessions | ✓ | ✓ | ✓ |
| Create notebooks and open them (run code in a kernel) | — | ✓ | ✓ |
| Create environments; start, stop and delete runtimes | — | ✓ | ✓ |
| SSH into a runtime, open its IDE and its apps | — | its owner and the people it is shared with | ✓ (any) |
| Share a runtime | — | its owner | ✓ (any) |
| Make a runtime for someone else, one that never stops when idle, set limits per person | — | — | ✓ |
A runtime's owner is who made it, or the person an admin made it for. A notebook's Jupyter is every editor's: anyone who may open the notebook may run code in its kernel. An environment's shell, IDE and apps are its owner's, its members' and the workspace's admins' only, because they are a shell in the container. Starting, stopping and deleting are an editor's on any runtime of the workspace. See Members and limits.