Compute templates

A template is a saved launch configuration — image, startup command, GPU shape, storage, duration, port and init script — that you can launch again in one click. Templates cover all three compute resources:

• GPU instances
• Model instances (User Inference)
• GPU clusters

They live under Compute → Templates in the console.

Templates come from a resource that started

There is deliberately no "save as template" button on the launch form. A template is created from the detail page of a resource that has actually started, so what it promises the next person is this configuration works rather than this configuration was typed.

That also matches how a working setup is really built:

① launch something    →   ② get inside      →   ③ adjust            →   ④ save as template
   pick an image           SSH / Jupyter,        install packages,       write ③ down as an
   and see                 find what the         download weights        init script, store it
                           image lacks                                   with the config

The moment worth recording is the end of that loop.

Terminated resources can be saved too — a finished run is still proof that the configuration started.

Save a template

1. Open the resource's detail page: Compute → GPU Instances / GPU Clusters / Model Instances, then click the resource.
2. Click Save as template.
3. Fill in the dialog:

Field	What it does
Template name	Required. Unique within your account. Seeded with the resource's own name.
One-line summary	Optional. The only thing shown on the card in the template list — say what it is for.
Init script	GPU instances only, and hidden for Jupyter images. Whatever you installed by hand over SSH goes here — see Init scripts.

4. Click Save. You land on the new template's detail page.

What gets captured

The spec is assembled server-side from the resource row and its volume attachments, not from what the browser happens to be showing:

From the resource	Stored in the template as
Image, startup command, service port, GPU type and count	Verbatim
Attached cloud drives and shared filesystems	A shape to create — {name, size_gb, mount_path}, not the original volume ids
Estimated duration	The original budget; whoever launches adjusts it on the launch form
Init script	What you typed in the dialog, overriding whatever the instance ran with
HuggingFace token, shared-filesystem ids	Dropped — one is a credential, the other is an id scoped to your account

Attached storage is recreated at the same size, not reattached. A cloud drive belongs to exactly one instance at a time, so reusing its id would either fail at launch or take the drive away from the instance the template came from. Launching a template gives you new, empty volumes of the same size at the same mount paths.

The template list

Compute → Templates has two tabs:

Tab	What it holds
My templates	Templates saved inside your account. Visible to every member of the account.
Platform	The EcoLink platform catalogue — setups the EcoLink team has published for every customer.

Each card shows the name, the resource kind, the one-line summary, a short resource summary read from the spec (2 × GPU, 200 GB storage, 8h, port 8000), and how many times the template has been launched. Pricing is not on the card — it needs live GPU rates and free-GPU counts per region, so it lives on the detail page.

Delete is available on your own templates only. Deleting a template does not touch instances already launched from it.

The template detail page

Four sections:

Resources

Generated from the spec — image, GPU shape, volumes with their mount paths, duration, port. CPU and memory are shown as "platform default tier, scales with GPU count", or "admin exception tier" if the EcoLink team has granted this template a raised tier.

Pricing

Quoted by the server from the same helpers the launch handlers charge from, so the figure you read cannot drift from the bill. The console renders the returned lines and does no arithmetic of its own.

Two controls re-quote without saving anything:

• Region — GPU rates are per GPU type and capacity is per region, so "what does this cost" has no answer until a region is picked. Platform templates carry no region at all; the server picks the one with the most free GPUs on first load.
• Duration (hours) — disabled for model instances, which are billed on a rolling 24-hour hold.

The quote is deliberately three figures, never one total:

	What it is
Hold at launch	The upfront credit hold: hourly_rate × gpu_count × hours, frozen at launch and refunded minus usage when the resource stops
First day	The hold plus one day of storage
Storage	Billed daily, and it keeps being billed after the instance is gone — the drive still exists

Warnings appear underneath, for example when a template carries no region or when its image is not a platform image.

If the chosen region cannot currently fit the GPUs the template asks for, Launch is disabled and the button reads "No capacity right now" rather than showing a price for a request that would be refused.

README

A markdown document the author writes for whoever launches this next. It is the place for what the resource summary cannot say — what the setup is for, what is already installed, what to run first, what to change.

Click Write (or Edit) on your own template. A new README opens on a skeleton — a prompt to type over, not a form to fill in. Don't hand-write the resource table or the price into it: both are generated above and would go stale the first time a rate changes.

Metadata

Created and updated dates.

Launch from a template

Click Launch on a card or on the detail page. This opens the resource's own launch form, pre-filled from the spec, with the region you picked on the detail page.

It is a navigation, not a separate launch endpoint — which means every check still runs exactly once, where it already lives: balance, quota, capacity reservation, SSH keys. You still confirm the parameters and can change anything before anything is charged.

The launch counter on a template increments after the underlying resource is created, so it counts launches that actually happened.

Visibility

Value	Who sees it
account	The default. Every member of your account.
private	Only you.
public	The platform catalogue — set by the EcoLink team only, on a copy. See below.

The platform catalogue

The Platform tab is curated by the EcoLink team. There is no submit button and no review queue — an admin browses what accounts have built and publishes what is worth putting in front of every customer.

What gets published is a copy, not your row:

• Your template is not touched, not flagged, not made public. You keep editing, renaming and deleting it exactly as before, and none of it changes the published copy.
• The copy carries a sanitised spec: tokens, SSH keys, region, volume ids and the original name are all removed, and an image nobody else can pull is refused outright.
• Deleting your template does not remove the platform one, and vice versa.

If one of your templates is picked up, its detail page shows a Featured as a platform template badge. Writing a README is what makes a template a candidate — it is the one thing nobody can supply on your behalf.

Templates marked private are never considered: keeping a template off your own colleagues' list is not a signal to show it to every account.

From the API

All routes are under https://api.ecohash.com and authenticate the same way as the rest of the platform — see Authentication.

Save a template from a resource

curl https://api.ecohash.com/compute-templates/from-instance \
  -X POST \
  -H "Authorization: Bearer eco_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "target_kind": "gpu_instance",
    "instance_id": 142,
    "name": "flux-dev-box",
    "description": "FLUX inference dev box, weights on the mounted drive",
    "init_script": "pip install -r /mnt/models/requirements.txt"
  }'

target_kind is one of gpu_instance, model_instance, gpu_cluster. The response carries the template, the assembled spec, and a note about storage being recreated rather than reattached.

List, read and price

# Your account's templates (optionally filtered by kind)
curl https://api.ecohash.com/compute-templates?target_kind=gpu_instance \
  -H "Authorization: Bearer eco_YOUR_KEY"

# The platform catalogue
curl https://api.ecohash.com/compute-templates/public \
  -H "Authorization: Bearer eco_YOUR_KEY"

# One template, with its spec and a quote
curl "https://api.ecohash.com/compute-templates/142?region=<region-id>&hours=8" \
  -H "Authorization: Bearer eco_YOUR_KEY"

# Re-price without reading the whole template
curl https://api.ecohash.com/compute-templates/quote \
  -X POST \
  -H "Authorization: Bearer eco_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "template_id": 142, "region_id": "<region-id>", "hours": 8 }'

A quote responds with the line items plus upfront_hold_usd, recurring_daily_usd, first_day_total_usd, capacity_ok and warnings.

Edit and remove

# Replace the README
curl https://api.ecohash.com/compute-templates/142/readme \
  -X PUT \
  -H "Authorization: Bearer eco_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "readme_md": "## What this is\n..." }'

# Visibility — 'private' or 'account' only
curl https://api.ecohash.com/compute-templates/142/visibility \
  -X PUT \
  -H "Authorization: Bearer eco_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "visibility": "private" }'

curl https://api.ecohash.com/compute-templates/142 \
  -X DELETE \
  -H "Authorization: Bearer eco_YOUR_KEY"

Asking for "visibility": "public" answers 403 — the platform catalogue is curated, not requested.

To launch from a template over the API, read the template, then post its spec to the resource's own create endpoint (POST /gpu-instances, POST /gpu-clusters, POST /inference-instances) with a region_id of your choice.

Limits

Limit	Detail
Init scripts are GPU-instance only	Model instances and clusters have no equivalent yet
Platform templates carry no region	Pick one on the detail page before launching
Templates cannot be read anonymously	Every route needs a session or an API key
Storage is recreated, not reattached	New empty volumes at the same sizes and mount paths

What to do next

• Write an init script
• Edit a running instance instead of relaunching
• Launch a GPU instance
• How billing works