The Web Console
Every node whose local API is on serves a console in the browser: the node's operator sees what runs on it and manages its networks, machines, images, volumes and tenants — including each machine's screen and serial console, its graphs, and every task and change made on the node — and the server's own settings — its interfaces, routing, firewall, services, traffic, backups, certificates, system log and updates — without a command line.
The people who run your servers sign in with their own accounts, each seeing and doing what their roles allow — see Accounts and Access Control.
The same page is also a portal for your customers: a customer who signs in with their tenant key sees only their own machines, networks and public addresses, and can start, stop and restart their machines, open their consoles and reset a password — see A portal for your customers.
Part of Compute, in early access. The console is served by the node itself; it never passes through Cenvero.
Opening it
The console lives on the same address and port as the node's local API, under
/console/; the node's address on its own (https://<node>:7070/) leads there
too:
https://<node>:7070/console/
- The local API must be on. A node installed with the
computeorsuiteprofile has it on from the start: the installer generates the node's API token, keeps it root-only in/etc/cenvero-str/api-token, and ends by printing the console's address. Otherwise the API is off until a token is set — see API Reference (cenvero-str-ctl api-token generate). The console is on whenever the API is; there is no separate switch. - The page uses the node's own certificate. If the node's certificate is not one your browser trusts, the browser warns first; check that the address is the node's before you continue.
- If you restricted the API to certain addresses (
api_allowed_ips), the console is restricted to them too. In a cluster, each member's own list applies to your address, whichever member you signed in to (see Every node of a cluster).
Signing in
People sign in with their own account: a Stratum account with a password, or through your organisation's identity provider. Scripts and the first sign-in can use a key. Customers sign in with their tenant key (see A portal for your customers). Accounts, roles and identity providers are explained in Accounts and Access Control.
The first time, there are no accounts yet. Make the first administrator on the node, as root (the password is asked for at a prompt):
sudo cenvero-str-ctl user add alice@local --role Administrator --password-stdin
Or sign in with the node's API token (on a node installed with the
compute or suite profile, sudo cat /etc/cenvero-str/api-token): a banner
says you signed in with the node's own token, and Accounts opens
Datacenter › Permissions, where Add account and Add permission make
the first administrator. Use personal accounts from then on.
With a password. Choose the sign-in method if there is more than one, enter your user name and password, then the 6-digit code your authenticator app shows (Use a recovery code instead if you do not have it). An account that must use a second factor but has none yet is first asked to Set up a second factor: scan the code with an authenticator app, enter the code it shows, and store the recovery codes shown once — the console opens when that is done. Every failure gives the same answer, whatever was wrong.
Through your identity provider. Press Sign in with your provider's name;
it signs you in and sends you back. A link to the console from your provider's
own portal must open https://<node>:7070/console/ — a sign-in started by a
link on another site is refused (see
Signing in through your identity provider).
With a key. Sign in with an API key takes an API token, an operator API key, the node's API token, or a tenant key. The key is sent once, in the sign-in request, over the node's encrypted connection; the browser never stores it, and the node keeps it in memory for the session only. A session signed in with an API token or operator key cannot make the changes that need a password confirmed.
- The session is held in a cookie the page's scripts cannot read. It ends after 30 minutes without activity (the page warns you two minutes before), after 12 hours in all, when you sign out, and when the agent restarts. Typing or using the mouse in a machine's console counts as activity; a page left open on its own does not.
- Taking access away ends sessions at once. Disabling or deleting an account, its expiry, disabling its sign-in method, revoking the token or key it signed in with, or changing the node's API token ends every session that depends on it, and closes the machine consoles opened with it.
- A tenant key signs in to that tenant's portal, never to the operator console.
- Up to 64 operator sessions can be open at once, and at most eight per account: signing in again when they are all in use closes the one used least recently, the account's own first. Customers' sessions are counted apart — at most eight per customer account, where a ninth sign-in closes that account's least recently used session — so a customer signing in again and again never signs you out.
- Sign-in attempts are limited per address (a burst of 5, then 10 a minute). Five wrong keys lock that address out of the API — console included — for five minutes. A user name that fails five times waits a minute before its next attempt, doubling up to 15 minutes.
Your account, and confirming it is you
The menu under your name has Your account and Sign out. Your account has three tabs:
- Profile — your name and email, the roles you hold and where, and Change password (for a Stratum account; an identity provider's accounts change it there).
- API tokens — make tokens for your scripts, give each its own permissions, and revoke them. A token's secret is shown once.
- Second factor — set up, replace or remove your authenticator app, and make New recovery codes.
A change that gives someone more power, or weakens a sign-in — a password, a second factor, giving Administrator, a token with everything your account holds, a sign-in method — first shows Confirm it is you: your password, and your authenticator's code if you have one, or a new sign-in at your identity provider. It then counts for five minutes. See Confirming your password.
What you see depends on what you may do
The tree and every list hold only what your account may see; with nothing to show, a page says that nothing here is visible to your account. A button for something you may not do is disabled, and says which privilege it needs. The node still decides: a change it refuses shows its own answer.
Datacenter › Permissions (for accounts that may see them) has Accounts, Groups, Roles, Permissions, API tokens, Sign-in methods (with Add identity provider and Check) and Second factors (who has one, who must set one up, and Reset). A machine, a network and a tenant each have a Permissions tab showing the permissions on that object, where you can add one in place.
What it shows
The console is laid out like a datacenter manager: a bar along the top, a tree of everything on the left, the page of what you selected in the middle, and the node's tasks along the bottom.
- The top bar. Search (press Ctrl K or / from anywhere;
tag:webfinds the objects taggedweb), the tasks running now, the alerts firing on every node (they open Datacenter › Notifications), the licence's state, and the menu under your name. - The tree. Datacenter → the node → its Machines, Networks, Storage, Images and Tenants, each machine with its state as a shape and, when it is not the usual one, a word (stopped, suspended, degraded). Switch to the Tenants view to see each tenant's machines, networks and volumes together, and the operator's own apart, or to the Tags view to see each tag with the objects that carry it. Type in the filter box to find something by name, id, address or tenant. On a phone the tree opens from the menu button.
- Pages with tabs. Every object has its own address, so a reload — or a link you send someone — opens the same page and tab.
| Page | Tabs | What you can do |
|---|---|---|
| Datacenter | Summary (nodes, totals, what needs attention — with the button that fixes it —, running tasks) · Cluster · Migrations (on a cluster member: the recent moves) · Tasks · Log · Search · Permissions · Notifications · Options · Updates | Start a machine that should be running; form, join or manage a cluster; manage accounts and permissions; alerts and the mail server (Notifications); your brand (Options); the rolling update (Updates) |
| Node | Summary (graphs of CPU, memory, disk space and network; version, licence, modules, services, self-healing checks, capacity, alerts, the software it runs, its tags and notes) · Machines · Networks · Storage (its Media view is the disc library) · Images · Tenants · Maintenance (on a cluster member) · Tasks · Interfaces · Routing · Firewall · Services · Traffic · Backups · Certificates · System log · Updates | Create a machine (the wizard, below); change the server's settings (A server's settings) |
| Machine | Summary (its state explained, graphs of CPU, memory, disk activity and network, guest agent, open consoles) · Hardware (size, network cards, volumes, CD-ROM drives and the boot order) · Snapshots (the boot disk's, and its disks) · Backups (the boot disk's, and its schedule) · Options (name, protection, boot order, start at boot) · Console · Cloud-init · Migrations (on a cluster member) · Tasks · Log · Permissions | Start, stop, restart, force stop; move the machine to another member (its Migrate button), stopped and copied, or while it runs with Move while running; change size; add, reconnect or remove a network card; insert, change or eject a disc; take a snapshot; back up now; restore a backup; set the boot disk's backup schedule; change options and first-boot settings; delete (Snapshots, backups and schedules) |
| Network | Summary · Addresses (which are in use, and by what — a machine, or a container) · Machines · the containers attached to it · Permissions | Turn the host gateway (masquerade, DHCP) on or off; delete |
| Volume | Summary (size, what it is attached to, protection) · Snapshots · Backups (the backup schedule above the list) · Tasks | Attach, detach, back up now, snapshot, grow, set the backup schedule and how many restore points to keep, revert to a snapshot, restore a backup, delete. A boot disk cannot be detached or deleted: it stays with its machine |
| Tenant | Summary (usage against quotas) · Machines · Networks · Volumes · Permissions | Set quotas; suspend and resume; delete |
| Task | What it does and to what, who started it, how far it has got, when it started and ended, and its log, which follows the task while it runs | Cancel, where the operation can stop safely |
Deleting anything asks you to confirm, and deleting a machine, network, volume or tenant asks you to type its name.
Changes appear as they happen. A machine that stops, a task's progress, a volume that is attached: the tree, the task panel and the page you are on follow the node as it changes, without a reload. If that live connection is interrupted the console reconnects on its own and catches up on what it missed; until it is back, pages refresh every 15 seconds. (The customer portal refreshes every 15 seconds.)
Tasks
Starting a machine, downloading an image, backing up a volume and every other longer operation is a task. The panel along the bottom lists the latest tasks with their progress — for downloads and backups, the bytes done of the total — and opens at once when you start one. Open a task to read its log as it is written, and to cancel it where the operation can stop safely. On a phone, the tasks are a page of their own.
Graphs
A node's graphs cover the last hour and a machine's the last 90 minutes as it happens (Live), or an hour, a day, a week, a month or a year. Average shows each point as the average of its time step and Peak as its highest value. Point at a graph, or focus it and use the arrow keys, to read the figures at a moment; every graph can also show its figures as a table. Times are in UTC. A break in a line is a time when nothing was recorded — the machine was stopped, or the agent was not running.
The log
The Datacenter's Log tab lists every change made to the node (and every attempt that was refused), every console sign-in and sign-out, and each task's start and end: when, who, what, on which object, from which address, and how it ended. Filter by time, person, action, object or outcome; Download saves every record the filters select, one per line; Verify the log checks that no record was changed or removed since it was written, and says so in a sentence. A machine's own Log tab shows the records about it.
A server's settings
A node's settings tabs show what the server holds and offer each control the
server carries out as offered; what it does not, a form never offers. Every form
has Show as API call, and the ones a command can make show the
cenvero-str-ctl command too.
- Interfaces — the cards, their addresses, bridges, bonds and MAC bindings. Addresses can be added to and removed from the server's bridges, cards and bonds, except those on the way the server is reached. An address added here is kept across restarts, and only such addresses are offered for removal. Bonds can be created with a mode and an MTU from 68 to 9216; a member that cannot be put back after a restart is listed as held, with the reason.
- Routing — routes, policy rules, port forwards, masquerade, floating addresses, the gateway pair and, as its second view, BGP. A route can be given a metric and a table; a default route goes in a table other than the main one. The port-forward form shows the address every forward answers on, and is unavailable until a masquerade rule gives the server one. Each masquerade rule shows the address its range leaves as. Taking or releasing a gateway pair's shared address by hand is offered only where a partner is configured and no heartbeat runs.
- BGP — a neighbour's TCP MD5 key is typed once and never shown again; the page shows only whether the neighbour has one. The keepalive is at most a third of the hold time; the page refuses a longer one before it is sent. Removing a neighbour removes its import and export policies with it.
- Firewall — the rules, the default action, schedules, the connection limit, the connection table and the addresses the server blocks on its own, each with Unblock.
- Services — DHCP, DNS and, as its third view, Load balancers. A backend's health can be set up or down by hand; a configured health check can change it back, so to keep a backend out whatever its checks find, take it out of rotation. A web (layer-7) frontend made here takes a certificate you paste: the server's own certificate is put on one only on the server's command line. A frontend that uses the server's own certificate, and the pools it routes to, are shown without their changes, saying why; such a frontend can still be deleted here.
- Traffic — bandwidth limits, pools, monthly quotas, flows and accounting. A bandwidth limit's burst may be left empty: it is then one second of the rate. A pool member can have a rate of its own, up to what the pool has left for its members. A monthly quota either alerts (notify) or, with throttle and Hold the address to almost nothing on, holds the address to almost nothing until the month resets or the quota is raised. A quota saved earlier whose words contradict what it does says so, and its edit form opens with the server's explanation.
- Networks shows, below the managed networks, the overlay networks, VLANs, VRF, Geneve tunnels, NAT64, routed addresses and address pools. Each overlay network shows its device and whether it is up, and why when it is not built. A VLAN can be denied by its id, from 1 to 4094, and the entry cleared again. VRFs are created and deleted and their interfaces attached and released, Geneve tunnels created and deleted, and NAT64's setting — on or off, prefix and pool — changed in one step.
- Backups — the server's backups and their schedules (in UTC).
- Certificates — the server's certificate, its names, a new request and a pull (see TLS/SSL & License Operations).
- System log — the server's own log lines, newest first, with secrets, credentials, paths on the host and the accounts a line's details name removed, and without the audit lines, which are in the Log.
- Updates — see Updates.
These tabs need the right to see the server's settings (Sys.Audit) and, to
change them, Sys.Modify — updates Sys.Update; see
Which role reaches a server's settings.
Notifications
Datacenter › Notifications shows the alerts firing on every server, and each server's alert conditions, alert history and event webhooks, each asked of the server it belongs to.
- Copy to every node adds a condition to each other server in turn and shows what each answered; the condition's actions are not copied.
- Acknowledging or resolving an alert records it under your name, and a frozen licence stops neither.
- A webhook's signing secret is shown once, when it is added.
- The mail server that alert email goes through is set here. Its password is never shown again; leaving it empty keeps it for the same mail server — a new server, port, encryption or authority needs it again. Changing the settings asks for your password again. See Monitoring.
Updates
Datacenter › Updates shows the rolling update's plan before it starts: every server in the order it is updated, what each runs and is offered, and why it cannot start yet. It then shows each server's progress as it happens, from whichever server you watch. A rolling update can be cancelled between servers; the server being updated finishes first. If it stops at a server that runs the new version but failed its checks, that server is offered its own rollback; it is never rolled back on its own. See Upgrades.
Node › Updates shows what the server runs, what is offered, staged and kept to roll back to, and offers Check now, Update and Roll back. Updating and rolling back restart the server into the version, and no licence state stops any of the three.
When the server you are signed in to restarts to finish an update, your session
ends and the sign-in page says this server restarted to finish an update; sign in
again.
Tags and notes
An object carries up to 16 tags of lower-case letters, digits, ., _ and -,
up to 32 characters each. They show as chips on its page and in the tree's
Tags view, and search finds them with tag:name. Each tag can be given a
colour (Datacenter › Options), shown wherever the tag appears. Notes are plain
text of at most 8 KiB, shown in a notes card on the object's page; an address in a
note is shown as text, never as a link. If someone changed an object's tags or notes since you
opened it, your change is refused: open it again and reapply.
Tags organise objects; they never grant or take away access. A customer never sees the provider's tags or notes in the customer portal.
Your brand
Datacenter › Options holds your brand:
- a product name; a logo and a favicon (PNG, WebP or SVG, at most 128 KB and 32 KB); one accent colour; support text and an https support address; a sign-in notice;
- it applies to the sign-in page and the customer portal, and to this console if you choose;
- saving asks for your password again.
An accent too light to read on the console's background is darkened, keeping its hue, until it reaches a contrast of 4.5 to 1; the page shows the colour it will be saved as before you save. An SVG must be a plain drawing: one with scripts, event handlers, links, or images or styles from elsewhere is refused. The sign-in notice and the support line show on the sign-in page even where your name and logo are not applied — to anyone who reaches it, so never put anything private there. On a cluster the brand is the cluster's.
Creating a machine
Create machine opens a wizard in eight steps: its name and owner; its source,
which is a base image or an install from a disc in the disc library; its size;
its firmware (BIOS or UEFI, secure boot and a TPM, or the Windows preset); its
disks and media (the two CD-ROM drives and the boot order); its network cards and
public address; its first boot (the hostname and SSH keys, or, for a disc install,
nothing: the installer sets the machine up); and a summary. Sensible defaults are
filled in — two vCPUs, 2 GiB of memory, a disk the image's size rounded up to the
next 10 GiB (20 GiB for a disc install), the owner's first network — and a mistake
is named beside the field before anything is sent. The last step says in one sentence what will be
created. Show as command gives the cenvero-str-ctl command that creates
exactly the same machine (run it on the node as root), and Show as API call
the same request for the API.
Every node of a cluster
On a member of a cluster (agent 1.0.0-rc.81 or later), the console manages every member, whichever one you signed in to:
- The tree lists every member under Datacenter, each with its machines, networks, storage and images; tenants are shared by the members and appear once. A member that stops answering is marked, within a few seconds, with when it was last heard from (last seen 12 s ago), and its objects stay listed from its last answer. A member that has not finished joining is shown as joining, and one on a version that cannot be managed from here as update needed, with a link to its own console.
- Actions on another member's machines, networks and volumes work as on the node you signed in to: the member that holds them does the work, under its own licence, and checks your account or token for itself. A machine's screen and serial console open through the node you signed in to.
- Accounts are the cluster's. Sign in to any member with the same account; a change to accounts or permissions made on one reaches every member. A member that cannot reach the others shows a banner saying so, with since when: access changes made elsewhere are not known there yet, and changes to shared settings wait until it is back in touch.
- Tasks, the Log and live changes cover every member. The Log can be filtered by node, and Verify the log answers for each member, since each keeps its own log.
- Datacenter › Cluster lists the members — role, whether it votes, its state (online, or when it was last seen), version, cluster address, when its identity expires, and a warning when its clock is off. It offers Make a join code (the code is shown once, with a copy button, a countdown and the command to run on the new node), the codes made so far with Revoke, and Remove… on each other member's row (type the node's name, then press Remove node). Under Advanced: giving a member a new identity, replacing the cluster's certificate authority, and Leave the cluster…, which takes the node you signed in to out of the cluster (type the cluster's name to confirm).
- On a member whose plan no longer includes clustering, Datacenter › Cluster says so. It still lists the members and the join codes, with Revoke, Remove… and Leave the cluster…. Making a join code, giving a member a new identity and replacing the authority wait until the plan includes clustering again.
- On a node that is not in a cluster, Datacenter › Cluster offers Form a cluster (a name and this node's address, then Form the cluster) and Join a cluster: paste a join code, check the address offered for this node, and press Next. The node asks the cluster what joining would mean, without using up the code, and the summary names the cluster and its size, the address, the tenants that will be shared, and any conflicts that stop the join. Nothing changes until you press Join the cluster.
- Creating a machine asks where: it offers the members that can run machines, have Compute in their licence and are not frozen. Show as command says which node to run it on, and Show as API call addresses that node (
/api/v1/nodes/<node id>/…). - A member that is not answering keeps its pages, showing what it last reported; changes to it are held back, with when it was last heard from, until it is back. Everything else keeps working.
- A member that does not accept your address. Each member applies its own
api_allowed_ipsto your browser's address, also when you signed in to another member. If a member's list does not include it, every action and console on that member is refused with 403forbidden: source address not allowed, and Tasks and the Log name it among the members that did not answer. The tree leaves its machines and networks out for your browser, and the member's node is marked not manageable from there, with the reasonnode <name> does not accept requests from this address.
A machine's screen and serial console
A running machine's Console tab opens its consoles in the browser:
- Display — the machine's screen, keyboard and mouse. Buttons send Ctrl+Alt+Del, switch between fitting the window and actual size, and go full screen. Up to four people can watch at once.
- Serial console — the machine's first serial port, in a terminal. One session per machine; if another session has it, Take over closes that one and connects you.
The console opens these exactly as described in Consoles: with a single-use ticket, from the node's own address. The same limits apply — a session closes after 30 minutes without input, and when the machine stops. A machine's console never outlives your sign-in: it closes at once when you sign out, and when your session ends or the key you signed in with is revoked.
Links in the serial console's output are shown as text only: the console never opens them, so nothing a machine prints can open a window or leave the page.
When the licence refuses changes
The console shows what the licence allows, with the node's own reason:
- A frozen licence (or none installed): a banner says the console is read-only. Everything keeps running, and you can still look at everything and open consoles; every change is refused until the licence is renewed, except updates and rollbacks, certificate requests, lifting an automatic block, acknowledging and resolving an alert, and sending the mail server's test message. In a cluster, removing a member, leaving and revoking a join code still work, so a node can always be taken out.
- A module not in the plan: its pages still show what exists, but the buttons that would change it are disabled, with the reason — for example, that Storage is not included in the plan.
- A module that is not available on the node (Compute on a server where the virtualization service is not installed, say): the page says why, in the node's words.
The console enforces nothing itself: every action goes to the node's API as you, and the API applies the same checks it applies to any other client. A button the console shows as enabled can still be refused, and the console then shows the node's answer.
Security
- Every change the page makes carries a per-session token and must come from the console's own page; a page on another site cannot act through your session.
- The console's pages load nothing from anywhere else and cannot be framed by another site.
- Sign-ins, refused sign-ins, sign-outs and sessions that end are recorded in the node's audit log (see Monitoring), and every change made through the console is recorded with the session it came through. They are also written to the node's log as audit entries (
audit=true) and published as the eventsconsole.signed_in,console.sign_in_refused,console.signed_out,console.session_ended,console.reauthenticatedandconsole.reauth_refused, so the event stream and webhooks carry them. They name the account or the key that was used, never a password, code or key. A refused sign-in is recorded without the user name typed, in case a password was typed there.
A portal for your customers
If you host machines for customers, each customer can have this console, confined to their own tenant. You create a tenant for the customer and give it their machines. The customer then signs in with an account of their own, which you make for them (see Customer portal accounts). A customer who uses the API can have a tenant key instead, and the portal accepts that too.
1. Make the customer's account. Make it in the console or over the API. Its temporary password is shown to you once, so send it to the customer over a channel you trust. The customer must choose a new password at their first sign-in.
2. Send the customer the address. Give them the portal name, reached through your own front (see The portal name and Putting the portal behind your own address). Without a front, the address is this node's console, https://<node>:7070/console/. The browser then shows the node's own certificate, which it does not trust until the account root is trusted (see Opening it). In a cluster, use any member's address.
Signing in. The customer opens the address and signs in with their login, which is their email address, and their password. At a portal name, the sign-in page offers only the customer portal.
- A wrong login or password answers
that user name and password were not accepted. - The second step asks for a code from the authenticator app, or for one recovery code. A wrong code answers
that code was not accepted; enter a code from your authenticator app, or one recovery code. - An account that cannot sign in answers
this account can no longer sign in; contact your provider. For a closed tenant, a correct password answersthis account is closed.
The first sign-in. The password the customer was given was set by their provider, so it must be replaced, and the portal says so: your password was set by your provider; choose a new password to continue. The new password must be at least 12 characters, not a common one, and different from the current one. What comes next depends on the account:
- If it already has an authenticator app, the customer enters a code from it, and then chooses the new password.
- If it has none, the customer chooses the new password, and then sets up an authenticator app:
set up your authenticator app to continue; your provider needs a second factor on this account.
To set up the app, scan the QR code the portal shows, or enter the key it shows, and then enter the code the app shows. The portal then gives the customer ten recovery codes. Each works once, in place of a code from the app, and they are shown once, so the customer must save them then.
The account page. The Your account page shows the customer's login, display name and tenant, whether an authenticator app is set up, how many recovery codes are left, and whether the password must change. From it the customer can:
- Change the password. Enter the current password, and a code from the authenticator app (or one recovery code) if there is an app, then the new password. A new password that is the same as the current one is refused with
choose a password you have not used before. The customer's other sessions end, and this one carries on. - Set up a new authenticator app. Enter the current password and a current code, from the app or one recovery code, then a code from the new app. The old app stops working at once, the other sessions end, and new recovery codes are given, shown once.
- Make new recovery codes. Enter the current password and a code from the app. The old codes stop working; the new ones are shown once, and the sessions carry on.
A wrong current password or code is refused with the current password or code was not accepted. Each wrong one counts toward the same wait a sign-in meets: after five wrong tries the account waits, a minute at first and longer after each further wrong try, before the next check. A right one resets nothing.
Sessions. A customer's session has the same limits as every console session: it closes after 30 minutes without activity and after 12 hours in all. An account can be signed in from four browsers at once, and a fifth closes the one used least recently. A change of password or authenticator app ends the account's other sessions.
Usage. The Usage page shows the network traffic the customer's machines carried, as download and upload, with totals and this note: the usage figures are the network traffic each machine's interfaces carried, as the server counted it; they are not a bill. What the figures count, and their limits, are on Usage figures. Each machine's own graphs are on its page.
Or a tenant key. A key suits a customer who uses the API:
sudo cenvero-str-ctl tenant key-generate <tenant-id> --name "acme portal" --ttl 2160h
The key is printed once. Send it to the customer over a channel you trust, and give it an expiry (--ttl) so it lapses on its own if it is forgotten. A key can also be minted over the API (POST /api/v1/tenant/{id}/keys, see Tenants). Revoke it with sudo cenvero-str-ctl tenant key-revoke <key-id>: every session signed in with it ends at its next request, and the machine consoles opened with it close within a few seconds. In a cluster where every member runs this release, the key works on every member, and revoking it on any member revokes it everywhere.
What the customer sees and can do. The portal wears the same layout, with a tree of the customer's own machines and networks:
| Page | What they see | What they can do |
|---|---|---|
| Overview (the tenant's name at the top of the tree) | Their account's state (active or suspended), their limits and usage (machines, bandwidth, volumes), and their machines | — |
| Machines | Their own machines: state, size, addresses, network cards, open consoles, guest tools, and graphs of CPU, memory, disk activity and network | Start, stop, restart, force stop; open the display and serial console; reset a user's password through the guest tools |
| Networks | Their own private networks and which of their machines use them | — |
| Public addresses | The public addresses their machines hold | — |
| Tasks | What was done to their machines and volumes, by them or by you, and how it ended | — |
| Usage | The network traffic their machines carried, as download and upload, with totals (Usage figures) | — |
| Your account | Their login, whether an authenticator app is set up, and whether their password must change | Change their password; set up an authenticator app; make new recovery codes |
| Activity | What was done with their keys and accounts: portal sign-ins and actions on their machines | — |
In a cluster. Once every member runs this release, the portal shows the
customer their machines, networks, addresses, tasks and activity on every
member, whichever member they signed in to, and acts on each machine where it
runs — consoles included, through the member they signed in to. The customer
never sees which server is which. If the server that holds one of their
machines is not answering, they are told
this machine's server is not answering right now; your machine keeps running. Try again shortly.;
everything else keeps working. Their limits and usage on the Overview are
those of the member they signed in to.
What stays with you. Creating and deleting machines, networks and volumes, changing a machine's size or interfaces, and changing the account's limits, bandwidth or state are not in the portal, and the node refuses them to a tenant key whatever it sends. A customer never sees another customer's machines, networks or addresses — asking for one by its id answers exactly as if it did not exist — nor your own machines, the node's licence or anything else on the node.
When you suspend the account. Suspending a tenant stops its machines. The customer can still sign in and look at everything, with a banner saying the account is suspended, but starting, stopping or restarting a machine, opening a console and resetting a password are refused until you resume the account. A console ticket issued before the suspension is refused when it is used, and a console the customer already has open closes within a few seconds.
What the customer is told when something fails. The portal answers in plain, fixed sentences — that the machine cannot be started right now, that its guest tools did not answer, and so on — never with the server's own error text. When a machine itself refuses a new password (an unknown user, say), the customer is shown the machine's own reason.
When the node's licence refuses changes. A frozen licence refuses the customer's power actions and password resets just as it refuses yours; the customer is told that changes are paused on the server and that their machines keep running. Looking and opening consoles still work.
What the customer's actions leave behind. Power actions, password resets,
console sessions and portal sign-ins are recorded in the node's audit log naming
the tenant key's id or the account's id, which is never its login (cenvero-str-ctl audit list --tenant <id>), like yours; the
customer can read its own records in the portal's API
(GET /api/v1/tenant/{id}/audit). Consoles the customer opens appear on
the machine's page in your console.
The portal shows what the customer's key allows; the node's API decides. A customer holding the key can make the same calls with any HTTP client — the API Reference lists what a tenant key may call.
Current limits
- Without a cluster, one node per console: open each node's own address. Join the nodes into a cluster to manage them all from any one of them.
- A browser session belongs to the member it was opened on: signing in to one member does not sign you in to another, though the same account works on each.
- Customer accounts work across a cluster once every member runs this release. Until then a customer signs in with a tenant key. A customer's machine and volume limits count across the cluster once every member runs a version that supports it; its address and rule limits are still set and shown per node.
- Customers cannot yet create their own machines — provisioning goes through you (or your billing system over the API).
- Sessions live in the agent's memory: restarting or updating the agent signs everyone out.