Skip to content
My accountDeutsch

API first,
then the tools

Command line, Terraform provider and libraries are intended to speak the same HTTP interface as the console. None of these have been published yet. The documentation describes the interface with examples, the console creates the tokens โ€” and this page lists for each tool what is available today and what is in preparation.

The code examples on this page are drafts of the future interface: they show paths, headers and response formats as described in the documentation โ€” without a base path, because this will only be announced upon publication.

At a glance
Interface
HTTPS and JSON, draft in the documentation
Token
create in the console
Command line
in preparation
Terraform provider
in preparation
Libraries
in preparation
Cloud Shell, MCP server
Projects
Only what has been published is listed here as available. Everything else is marked as in preparation or planned and will appear here upon publication.
Interface
HTTPS, JSON
Draft, documented with examples
Description
OpenAPI 3.1
planned, not yet published
Token
Console
Scope, expiry and IP binding per token
Terraform, SDK, CLI
in preparation
without a committed date

What is available and what is in preparation

The tools for ENTRONYX CLOUD are built around an API. The documentation and the console's token management are published; the command line, Terraform provider and libraries are in preparation, Cloud Shell and MCP server are described as planned. This table shows the status of each tool.

How the interface is designed

Console, command line, Terraform provider and libraries should speak the same HTTP interface: HTTPS, JSON, one header for the token, one header for the project. The documentation describes it with examples; this page will only name a public base path once it is accessible. A description according to OpenAPI 3.1 is planned โ€” a machine-readable file from which a client can be generated for any language.

Authentication
Authorization: Bearer
Project binding
X-Entronyx-Project
Rate limit
3,000 / min
Description
OpenAPI 3.1
Versioning
v2 in the path
Deprecation period
12 months

Token and project

A token carries a scope โ€” read, operate or manage, just as the console assigns it per token today. If the scope is missing, the interface should respond with 403, not 404: the resource exists, the token just is not allowed to see it.

The project is in its own header, not in the path. This means the same request remains unchanged between test and production; only the identifier is swapped.

Authorization: Bearer ยท X-Entronyx-Project

Rate limit

The window should slide, not jump at the full minute. Every response carries the remaining quota; if you read it, you never have to run into the limit.

On a 429, the wait time is in Retry-After. An immediate retry extends the block instead of bypassing it.

3,000 requests per minute, per project and token

Version and pagination

The version is in the path and only changes for breaking changes. A deprecated version should continue to run for twelve months and report itself via the Deprecation header during this time.

Lists are paginated using a cursor. It is opaque and returned unchanged โ€” unlike a page number, it does not skip an entry if a resource is created or disappears during pagination.

v2 in the path ยท cursor instead of offset

What the draft shows: the first page of instances in Frankfurt, the response headers and the second page via the cursor of the first. Token and project are in the request header, not in the path.

Draft: list instances, read headers, fetch second page
# Draft of the future API. The base path is intentionally omitted:
# It is only stated once it resolves. Token and project are in the header.
GET /v2/compute/instances?region=fra1&limit=20
Authorization: Bearer <Token>
X-Entronyx-Project: prj_4c81f0
 
HTTP 200
x-ratelimit-limit: 3000
x-ratelimit-remaining: 2987
x-ratelimit-reset: 1787043180
x-request-id: req_2f8c14ab9e
 
{
  "data": [
    {
      "id": "inst_9a2f31",
      "name": "web-01",
      "flavor": "nx-4-8",
      "region": "fra1",
      "image": "debian-13",
      "state": "running",
      "created_at": "2026-08-14T09:12:44Z",
      "network": { "ipv4": "198.51.100.7", "ipv6": "2001:db8:41::7" }
    }
  ],
  "meta": { "total": 24, "next_cursor": "eyJhIjoiaW5zdF85YSJ9" }
}
 
# Second page: return the cursor of the first unchanged.
GET /v2/compute/instances?region=fra1&limit=20&cursor=eyJhIjoiaW5zdF85YSJ9
Authorization: Bearer <Token>
X-Entronyx-Project: prj_4c81f0
What comes back is an envelope of two fields: data with the instances of this page and meta with the cursor for the next. The remaining quota is not in the body, but in the headers โ€” in the draft 2,987 of 3,000. The first call including the response, explained field by field, is in the documentation. There, creating an instance carries an idempotency key: if the call is repeated after a connection drop, the key prevents a second instance.

What the draft shows: an instance with a flavor that does not exist in the Helsinki region, and the response to it. A flavor is a fixed combination of cores and memory.

Draft: read and classify error response
# Draft of the future API.
# A flavor that does not exist in this region: 422, not retryable.
POST /v2/compute/instances
Authorization: Bearer <Token>
X-Entronyx-Project: prj_4c81f0
Content-Type: application/json
 
{ "name": "web-02", "flavor": "nx-96-768", "region": "hel1", "image": "debian-13" }
 
HTTP 422
x-request-id: req_71b0d4c6aa
 
{
  "error": {
    "code": "flavor_not_available_in_region",
    "message": "Flavor nx-96-768 is not offered in region hel1.",
    "field": "flavor",
    "request_id": "req_71b0d4c6aa"
  }
}
What comes back is 422 and an error object with four fields: machine-readable code, plain text message, affected field and request identifier. 422 means: the request was formally correct, but factually impossible โ€” a retry will not change this. The identifier belongs in every ticket; with it, support can find the request in the log without searching for timestamps.

Rate limiting headers

Four headers that a client should evaluate. If you only read the first three, you will never get close to the limit; if you only read the fourth, you will wait correctly after exceeding it.

Rate limiting headers and their meaning
HeaderMeaning
X-RateLimit-LimitWindow quota, 3,000 planned
X-RateLimit-RemainingRemaining requests in the current window
X-RateLimit-ResetUnix time when the window restarts
Retry-AfterSeconds until the next allowed attempt, for 429 and 503
Opened 2U server chassis from diagonally above on the workbench: heatsink with copper base over the socket, populated and locked memory banks, fan wall, power supplies with IEC connector at the back, drive bays at the front.

One program for the individual case

The command line is in preparation. Planned is a single, statically linked program for Linux, macOS and Windows โ€” with no underlying interpreter โ€” that provides all output as a readable table and as JSON for further processing. Package repositories and installation commands will be listed here as soon as the program is available.

What is planned

The blueprint is finalised before the first version is released โ€” so that a script written against the first version will still run against the tenth: new fields are added, existing ones do not disappear.

Format
a single executable, statically linked, without a runtime environment
Architecture
entronyx <resource> <verb>, flags via --help
Output
Table in the terminal, JSON in the pipe, JSONL for large lists
Login
Token from a file, never as an argument
Return value
distinguishes between success, user error, API error and timeout
Workspace with two monitors, an open terminal window and a notepad, next to a casing part on the workbench.

A terminal in the browser, as a plan

A terminal in the browser, authenticated against the same account as the console, without installation and without a copied token: that is the direction the Cloud Shell is meant to take. There is no service for this yet. This page will only list the toolset, limits and address once it is published.

State as a file, not as a memory

A Terraform provider for ENTRONYX CLOUD is in preparation. It is intended to cover what can be clicked in the console โ€” compute, storage, network, Kubernetes and databases โ€”, following the same condition that applies to the interface: no function that is only clickable. The identifier, version binding and source of the provider will be here as soon as it is published.

Four steps to the first plan

  1. 1Include providerThe source and version binding of the provider will be here as soon as it is published. What applies then applies to every provider: terraform init downloads it and writes the checksum to the lock file โ€” which belongs in the repository.
  2. 2Set token, do not hard-code itThe provider should read the token from the ENTRONYX_TOKEN environment variable. A token in a .tf file ends up in the repository and in the state; neither can be undone once it has happened.
  3. 3Store stateThe S3 backend โ€” Terraform's storage for the state file via the S3 interface โ€” points to our own Object Storage. The lock uses conditional writes via use_lockfile and does not need an additional database. The bucket should have versioning enabled so that an overwritten state remains recoverable.
  4. 4Plan, check, applyterraform plan -out plan.tfplan and terraform apply plan.tfplan. The detour via the file is the difference between โ€œwhat was checked is appliedโ€ and โ€œwhat happens to be valid right now is appliedโ€.

State in your own Object Storage

The state file contains identifiers, addresses and, depending on the resource, secrets in plain text. It therefore does not belong in the repository, but in a bucket with separately assigned access. These three rules apply regardless of which provider writes the state.

Attribute lists per resource, the behaviour when importing existing systems and the question of which change forces a rebuild will be in the Terraform section of the documentation as soon as the provider is published.

Ribbon-shaped row of server cabinets, in between an aisle with floor markings, in the background a wall of status lights.

There are two separate steps between commit and running instance: terraform plan -out writes the verified plan to a file, terraform apply applies exactly this file โ€” not what is currently valid. The ENTRONYX CLOUD provider, which is intended to serve these steps, is in preparation.

The same interface, described for agents

Model Context Protocol is the common language between a language model and the tools it is allowed to use. A server that translates the ENTRONYX CLOUD interface into such tools โ€” with description, input schema and clear separation between reading and writing โ€” is a project, not a service. Tool list, connection and address will be here as soon as it exists.

What it is intended for

An agent investigating an incident needs three things: the list of resources, their metrics and the documentation. All three via one server instead of three cobbled-together scripts โ€” and in a format the model doesn't have to guess.

For the second case, provisioning resources, the same server should apply, but not the same approval.

Inventory, cost questions, troubleshooting

What it should separate

Blocked tools should not be hidden, but reported as blocked. A model that does not see a tool at all looks for a workaround โ€” one that knows about the block reports it back to the human.

Every response should carry the request ID of the underlying request. This allows every step of an agent to be traced in the activity log.

Reading and writing, individually approved

Permissions

An agent does not act with intent, but with probability. The question is therefore not whether it makes a wrong call, but what the wrong call can cause. What is written here does not only apply with the server โ€” it applies to every token that the console issues today.

Generated from a description

Libraries for ENTRONYX CLOUD are in preparation. They will be generated from the same OpenAPI description as the documentation โ€” this ensures none of them can name an endpoint differently than the API, and a new field can appear everywhere on the same day. Which languages will come first and who maintains which will be announced here upon release; until then, this page will not list any package names.

The interface first, the tools afterwards

Terraform provider, SDKs and command line are in preparation. Until publication, the documentation under /docs describes each interface with examples. The console already creates tokens today; which publication follows when is stated on this page as soon as it is decided.

Interface
HTTPS, JSON
Description
OpenAPI 3.1
Token
in the console
Terraform, SDK, CLI
in preparation