How to use Enver
The complete guide to the Enver application.
How Enver works
Enver is a control plane for your containers. Your applications run on your own servers; Enver keeps their configuration, tells the servers what to run and shows you what is going on. The building blocks are:
- Account – your company or team. Everything below belongs to an account, and its members get permissions in it.
- Container registry – where your images come from: Docker Hub or any OCI-compatible registry (GHCR, GitLab, Harbor…).
- Service – one application described once for the whole account: its image, default tag, ports, volumes, command and variables.
- Edge server – your server (Debian/Ubuntu or macOS) with the small Enver agent installed. It runs the containers with Docker or on your Kubernetes cluster.
- Environment – dev, staging, production… An environment sits on one edge server and contains services with its own tags, variables and settings.
Your containers, volumes and backups never leave your servers. If Enver is unavailable, your environments keep running; you just cannot manage them until it is back.
Quick start
- Sign in with Google or GitHub and choose Create account (or Wait for an invite if a colleague is adding you).
- Connect a registry under Registries if your images are private. Public Docker Hub images work without one.
- Describe your services under Services: image, default tag, ports and variables.
- Add an edge server under Edge Servers → New server, open it and follow Install: one command on the server and a token.
- Create an environment under Environments, pick the edge server and Docker or Kubernetes, and add services to it.
- Start it. The environment detail shows the live status, uptime and logs of every service. The logs refresh every 10 seconds, or at once with the refresh button.
Accounts and team
Accounts
The user who creates an account is its owner and can do everything in it. You can own more accounts (User settings → Accounts → New account) and be a member of others; switch between them with the account switcher in the header. Account names are unique across Enver.
Accounts live on one of our servers. We may move an account to another one, e.g. when a paid plan runs on dedicated servers. While it moves – usually for seconds to minutes – the account is read-only and a bar under the header says so; your environments keep running. The app and your edge servers then find the account on its new server by themselves.
When an account starts paying – any plan, even a single add-on – we move it to a server for paying customers if it isn’t on one already. The owner of a paid account can also choose its server under Account → Settings; the move then works as described above.
Inviting members
Under Account → Users, invite a colleague by e-mail. They receive an e-mail with a link to the invitation, sign in and accept or reject it. They must sign in with the address the invitation was sent to - with a password, or with Google, GitHub or Microsoft. Their invitations are also listed under User settings → Accounts → Invitations. Pending invitations count towards the account’s user limit.
Members
The owner and user admins see who is online, edit permissions (Permissions) and the owner can remove members or Transfer ownership to another member (the previous owner loses owner privileges).
Export and deletion
Under Account → Data and deletion, the owner downloads everything Enver stores for the account as a JSON file (secret values and tokens are left out) and deletes the account. Deleting needs the paid subscriptions ended first; the account then disappears for all members at once and its data is erased within 30 days. Containers and volumes on your edge servers stay as they are. Your own profile is deleted under User settings → General → Delete profile, once you own no account.
Permissions
Members get permissions per account. Higher permissions include the lower ones.
| Permission | Allows |
|---|---|
| Env Admin | Create, edit, start and stop all environments, add and configure their services. |
| Env Tag Switching | Switch tags, restart services and view logs – ideal for developers deploying their branch. |
| Env Viewer | See environments, their status and variables (without secret values). |
| Service Admin / Viewer | Manage or see the service catalog and service groups. |
| Edge Server Admin / Viewer | Manage (including tokens and settings) or see edge servers. |
| Variable Group Admin / Viewer | Manage or see variable groups. |
| Registry Admin / Viewer, Registry Tag Search | Manage or see registries, search images and tags. |
| User Admin | Invite members and change their permissions; Invites Admin, Permissions Admin and User Viewer grant the parts separately. |
| Monitoring Viewer | See edge server metrics. |
| Infrastructure Viewer | See the infrastructure overview: every environment with its edge server, ports and volumes. |
| DB Backups Admin / Operator / Viewer | Configure and delete backups / create and restore them / see them. |
| Secrets Reveal | Copy stored secret values. Every reveal is recorded in the audit log. |
| Security Viewer | See the edge servers’ security audit: reports, logins and findings, which include the user names of the server’s accounts, and the vulnerabilities of the images the services run, and the account’s security overview with its members’ last activity. Turning the audit on, its retention and muting findings belong to Edge Server Admin. |
You can only grant or remove permissions you hold yourself, so nobody can raise their own or anyone else's access above their own. Permissions you don't hold are greyed out in the dialog and stay as they are. The owner holds every permission.
Per-environment permissions
In an environment, Permissions lets the owner fine-tune access for one member: a whitelist grants Env Admin, Tag Switching or Viewer in this environment only, a blacklist takes it away here only (e.g. a developer can switch tags everywhere except production). Blocking a level also blocks the levels above it.
Container registries
Under Registries, add Docker Hub or a custom registry (its URL, e.g. https://ghcr.io) with a username and an access token. The token is stored encrypted and never shown again; leave it empty when editing to keep it. Enver uses the registry to pull images on your edge servers and to suggest images and tags in forms.
Automatic redeploy from Docker Hub
For a Docker Hub registry, Set up Docker Hub webhook shows a URL to paste into the repository’s webhooks on Docker Hub. After every push, Enver restarts – pulls and recreates – every running service that uses the pushed repository and tag, and the new tag shows up in the tag suggestions at once (without a webhook within a minute). Anyone who knows the URL can trigger those restarts, so keep it secret. If it leaks, issue a new one in the same dialog (Regenerate URL): the old one stops working at once, and you replace it on Docker Hub. The URL points to the Enver hub and stays valid when your account moves to another of our servers; a URL copied before the hub existed points to the server itself, so copy it again.
Services
Under Services → New service, describe an application once for the whole account:
- Name and container image (e.g.
ghcr.io/acme/api) with its default tag, - registry for private images (suggested from the image name),
- command, if the image needs one to start (e.g.
npm run start), - default ports (internal → exposed) and volumes (container path → host path),
- default variables, each public or secret.
Ports and volumes are a starting point: they are copied into an environment when you add the service there, and later changes to the service don’t affect environments it is already in. Default variables are different: they are inherited, so a changed default applies in every environment that doesn’t override it (see One configuration for many environments). A service can only be deleted once it is removed from all environments.
Variables and secrets
Where values come from
When a service is deployed, its variables are merged in this order, a later one winning:
- the service’s default values,
- assigned variable groups (the later assignment wins),
- values set in the environment itself,
- the service’s env file on the edge server, if it has one – Enver never sees these values.
The environment service form lists the Inherited variables with their source, and Override sets an environment value. Variables are always listed alphabetically.
One configuration for many environments
Dev, staging, production and every preview environment mostly need the same variables; only a few, such as the database URL or the log level, differ. Thanks to the order above you configure the common part once and each environment adds only its differences:
- Put what a service needs everywhere into its default variables (Services).
- Put what several services share – SMTP, a message broker, Sentry, object storage – into a variable group (Variable Groups) and assign it to those services in each environment.
- In each environment, Override only the values that differ. Everything else stays inherited, and the form shows where each value comes from.
- For the next environment, use Duplicate existing: the copy brings every service with its own values and group assignments, so you only adjust what differs again.
Defaults and groups are not copied into environments, so a change to them applies in every environment that doesn’t override the variable, the next time its service starts or restarts. When test environments should use different shared values than production, keep a group per stage, e.g. smtp-production and smtp-test; Duplicate group creates the second one, secrets included.
Example: an api service with 4 default variables and the group backend-shared with 6 more runs in dev, staging, production and a preview. Each of these environments sets just DATABASE_URL, and dev also LOG_LEVEL=debug; the other 10 values live in one place.
Secrets
A secret value is stored encrypted and never sent back to the browser – the form only shows whether it is set. Members with Secrets Reveal can copy it to the clipboard, and every reveal is recorded in the audit log. A variable the service declares secret is secret in every environment; an environment can make its own value secret, too. A stored secret only becomes public together with a new value.
Secrets that never leave your server
If you’d rather not give Enver some values at all – database passwords, API keys – keep them in an env file on the edge server and let the agent read it there. Enver stores only the file’s name; the values go from the file straight into the container and never pass through Enver, its database or the connection to it.
- On the edge server, create the file in
/etc/enver/env-files(the installer creates the directory; on an agent installed before this feature, create it withsudo install -d -m 750 -o root -g enver-edge-server /etc/enver/env-files). Let root own it and the agent only read it:
The format is the usualsudo nano /etc/enver/env-files/my-app.env sudo chown root:enver-edge-server /etc/enver/env-files/my-app.env sudo chmod 640 /etc/enver/env-files/my-app.env.env:NAME=valueper line,#comments, quoted values may span several lines. A bareNAMEwithout a value is not taken from the agent’s environment, unlikedocker --env-file. - In Enver, open the service in the environment and fill in Env file on the edge server with the file’s name, e.g.
my-app.env, or a path below the directory, e.g.production/my-app.env. - Start or restart the service. The agent reads the file at every start and restart, so after editing it, restart the service.
- Values from the file win over every value set in Enver with the same name, so the server’s administrator has the last word.
- Enver never sees, shows, exports or reveals them, and they are not in the audit log; only a change of the file name is audited.
- The agent reads nothing outside the directory: absolute paths,
..and symbolic links leading out of it are refused. Another directory can be set withENV_FILES_DIRin/etc/enver/edge-server.env. Whoever may edit a service in Enver can point it to any file in that directory, so keep only files of services running on this server there, ideally one subdirectory per environment. - When the file is missing or unreadable, the service doesn’t start and its error names the file – never its contents.
- On Docker the values end up in the container’s environment, where anyone with access to Docker on the server can read them (
docker inspect), as with every other variable. On Kubernetes the agent puts them into the service’s Secret<name>-envin your cluster.
Want to check it for yourself? See Check what the agent sends.
Import, export and references
- Import .env / Export .env move variables in the usual
.envformat. A# secretcomment line marks the next variable as secret. - Type
@in a value to reference another service of the same environment: it is replaced by that service’s container name at deploy time, e.g.postgres://@db:5432/app. In a variable group, which can be assigned in any environment,@offers the services of every environment, each labelled with its environment. - Type
#in a value to link a variable of another service, e.g. the database passwordPG_PASSWORDof the postgres service, instead of copying it or creating a variable group for it. The link shows as a chip and Enver fills in the variable’s current value at deploy time, also when it is a secret. A link always resolves in the environment being deployed, so a variable group or a copied service links the service of that environment; a link to a service the environment doesn’t have is shown crossed out and isn’t filled in.
Service and variable groups
Service groups (Service Groups) bundle services such as “backend” so an environment can start, stop or switch the tag of all of them at once. Variable groups (Variable Groups) hold shared configuration – e.g. SMTP or a message broker – that you assign to services in environments instead of copying the values. Both support public and secret values and .env import and export. Duplicate group on a variable group’s edit page creates a copy under a new name with every saved variable, secrets included – they are copied encrypted, so it needs no permission to reveal them. The copy is not assigned to any service.
Edge servers
Install
Under Edge Servers → New server, name the server, open it and click Install. The dialog shows the commands with your token filled in. On Debian/Ubuntu (amd64 or arm64):
curl -fsSL -o /tmp/enver-edge-server.deb "https://enver-api.apinecka.com/v1/edge-servers/installer" \
&& echo "<SHA-256 from the dialog> /tmp/enver-edge-server.deb" | sha256sum -c - \
&& sudo dpkg -i /tmp/enver-edge-server.deb && rm /tmp/enver-edge-server.deb
On macOS (with Docker Desktop, OrbStack or Colima):
curl -fsSL -o /tmp/enver-edge-server.tar.gz "https://enver-api.apinecka.com/v1/edge-servers/installer/macos" \
&& echo "<SHA-256 from the dialog> /tmp/enver-edge-server.tar.gz" | shasum -a 256 -c - \
&& tar -xzf /tmp/enver-edge-server.tar.gz -C /tmp && sudo /tmp/enver-edge-server/install.sh \
&& rm -rf /tmp/enver-edge-server /tmp/enver-edge-server.tar.gz
Then put the connection settings from the dialog into /etc/enver/edge-server.env and restart the agent:
EDGE_SERVER_PORT=10999
EDGE_SERVER_TOKEN=<token from the dialog>
API_URL=https://hub.enver.apinecka.com
sudo systemctl restart enver-edge-server # Linux
sudo launchctl kickstart -k system/com.enver.edge-server # macOS
The server turns Online within seconds. Keep the token secret – anyone with it can connect as your server. API_URL is the Enver hub: on every start the agent asks it which instance your account lives on and connects there. The token has the form <server id>.<secret>; an agent installed earlier keeps working with its old token and API_URL. The agent keeps a connection to Enver open (outgoing only; no inbound port has to be opened to the internet), reports statuses every few seconds and host metrics every minute. When we move your account to another server, the agent asks the hub again and reconnects by itself, with the same token.
Verify the download
The commands in the dialog stop before installing unless the file’s SHA-256 matches the one Enver publishes for it. Every installer is also signed, and the dialog shows how to check the GPG signature; before you trust the key, compare its fingerprint with enver-signing-key.gpg in the public repository:
curl -fsSL "https://enver-api.apinecka.com/v1/edge-servers/installer/signing-key" | gpg --import
curl -fsSL -o /tmp/enver-edge-server.deb "https://enver-api.apinecka.com/v1/edge-servers/installer" \
&& curl -fsSL -o /tmp/enver-edge-server.deb.asc "https://enver-api.apinecka.com/v1/edge-servers/installer.asc"
gpg --verify /tmp/enver-edge-server.deb.asc /tmp/enver-edge-server.deb && sudo dpkg -i /tmp/enver-edge-server.deb
What the agent does and what it needs
- Access to Docker. It runs as the
enver-edge-serversystem user in thedockergroup (on macOS as a launchd service of your account). Access to the Docker socket amounts to root on the machine, which is why it only runs what you configure in Enver: it pulls images (with the registry credentials Enver sends for each deployment), creates, starts, stops and removes containers, volumes and networks, removes old images, and for PostgreSQL backups runspg_dump/pg_restoreinside the database container and writes to the backup directory you set. To report how full Docker's disk is, it reads the size of Docker's data directory, or where it can't see that disk (Docker Desktop, a remote daemon) runsdfinside one of its running containers. It touches only containers it created, mounts volumes only from the server's volumes directories and keeps backups only in its backups directories (see Docker settings). - Kubernetes only with the service account token you enter; the command in the dialog grants exactly the rights it uses.
- Network: only outgoing HTTPS and WebSocket connections to the Enver hub and to the instance it names. On
EDGE_SERVER_PORTit only answersGET /health; don’t expose that port. - What it sends: container states, image tags and digests, host metrics (CPU, memory, swap, disk, uptime), names and sizes of backup files, container logs only while you view them (the last 250 lines, not stored) and, with the security audit on, its report. The contents of containers and volumes never leave the machine.
- What it receives: the desired state of your services, including their variables. Secret values are decrypted only for this and travel over the encrypted connection. Values of an env file are not among them: the agent reads them on the server, only from
/etc/enver/env-files. - Security audit (Linux, only when you turn it on for the server): reads the host’s security state without root, through fixed read-only commands and files anyone may read (open ports, accounts, startup files, processes), see Security audit.
- Updates itself inside its own install directory (
/opt/enver/edge-server/versions), without root, the package manager or changes to the system service. It downloads only the package Enver publishes and checks its SHA-256 and its signature by the Enver release key, which is built into the agent. Details below. - It doesn’t take Enver’s word either. Whatever a job from Enver asks for, the agent stays within its edge server’s settings: volumes and backups only inside the directories you listed (a path or symbolic link leading out is refused, and nested mounts are too), only containers it labelled as its own, connections only over HTTPS, and the Kubernetes API server’s certificate is checked unless you turn that off. A setting it doesn’t receive counts as closed: without directory lists, no service with volumes starts and no backup runs.
- Open source. The agent’s complete source is public at github.com/apinecka/enver-edge-server under the Apache 2.0 license, including the scripts that build the installers. Every release is built there from its tag and attested, so you can check that a package came from that source:
gh attestation verify enver-edge-server_<version>_amd64.deb --repo apinecka/enver-edge-server. The version an agent runs is in/opt/enver/edge-server/VERSION.
Check what the agent sends
You don’t have to take our word for any of the above. The agent can write the TLS session keys of its connections into a file, and Wireshark then decrypts everything it exchanged with Enver. On Linux:
- Turn the key log on (a directory only the agent can write to) and restart the agent. Its log then warns that it writes the keys:
sudo install -d -m 700 -o enver-edge-server /var/lib/enver-keys echo 'SSLKEYLOGFILE=/var/lib/enver-keys/edge-server.keys' | sudo tee -a /etc/enver/edge-server.env sudo systemctl restart enver-edge-server - Capture the traffic while you do what you want to check, e.g. start a service with an env file. Restart the agent once more after starting the capture, so it also holds the websocket’s handshake:
sudo tcpdump -i any -w /tmp/enver.pcap 'tcp port 443' sudo systemctl restart enver-edge-server # in another terminal, then start the service in Enver - Stop the capture with Ctrl+C and copy
/tmp/enver.pcapand/var/lib/enver-keys/edge-server.keysto the computer with Wireshark. - In Wireshark, set Edit → Preferences → Protocols → TLS → (Pre)-Master-Secret log filename to the keys file and open the capture (or run
wireshark -o tls.keylog_file:edge-server.keys enver.pcap). The display filterhttp || websocketshows the decrypted requests and messages; Follow → TLS Stream shows a whole connection as text. The deployment arrives as aservice.actionmessage: it carriesenvFilewith the file’s name and the variables set in Enver, but no value from the file. - To search everything at once without the GUI:
for s in $(tshark -r enver.pcap -T fields -e tcp.stream | sort -un); do tshark -r enver.pcap -o tls.keylog_file:edge-server.keys -q -z follow,tls,ascii,$s done > enver-decrypted.txt grep -c 'a value from your env file' enver-decrypted.txt - Turn it off again: remove the
SSLKEYLOGFILEline from/etc/enver/edge-server.env, restart the agent and delete the keys file and the capture.
The keys file and the capture together reveal everything the agent exchanged, including its token and the secrets set in Enver. Keep them only as long as you need them. On Kubernetes, the agent also sends the env file’s values to your cluster’s API server – that is expected, it is your cluster; capture only the connections to Enver if you want to see just those. On macOS, put the same line into /etc/enver/edge-server.env, use a directory your user can write to and restart with sudo launchctl kickstart -k system/com.enver.edge-server.
Updates
Every few hours the agent asks Enver whether a newer version is published. If so, it downloads it, verifies it, unpacks it next to the running one and restarts into it; your containers keep running meanwhile. The new version has to connect to Enver within 10 minutes and stay connected for half a minute, otherwise the agent goes back to the previous version and doesn’t try that version again on its own. The edge server detail shows the agent’s version and whether an update is available; Update now starts it at once (also for a version that failed before). Automatic updates in the settings turns the periodic updates off; Update now keeps working.
Installations from before self-updating show an unknown version: run the install command once more, from then on the agent updates itself. Installing a package by hand always switches to that package’s version.
Token
The token identifies the server to Enver. If it leaks, click Regenerate token on the edge server detail: the old token stops working at once and the agent disconnects. Put the new token into /etc/enver/edge-server.env and restart the agent. Deleting an edge server disconnects it too.
Logs and uninstall
- Linux:
journalctl -u enver-edge-server -f; remove withsudo apt remove enver-edge-server. - macOS:
/var/log/enver-edge-server.log; remove withsudo /opt/enver/edge-server/uninstall.sh(keeps the env file).
Security audit
With the security audit turned on for an edge server, Enver regularly asks the agent for the host’s security state. It covers Debian 11–13 and Ubuntu 20.04 and later; other systems, macOS included, answer that they aren’t supported. Without that setting the agent refuses the request.
- Where: the Security tab of the edge server (with Security Viewer). It shows the open findings by severity, each with advice and, where one does it, a command to fix it; the logins, a chart of failed attempts, the pending security updates, the time of the last check and Check now. Its settings turn the audit on and set how long data is kept, and it says which access the agent lacks according to the last report. The edge server list marks each server with its worst open finding that isn’t muted.
- What it reads: the distribution, the running and the newest installed kernel, a pending reboot, whether
unattended-upgradesis installed and on; the SSH server’s version and the settings that matter fromsshd_configand itsIncludefiles (root login, passwords, keyboard-interactive, keys, empty passwords,MaxAuthTries, X11 forwarding,AllowUsers/AllowGroups, ports, socket activation, weak ciphers), whether fail2ban or CrowdSec runs; SSH logins since the previous check from the journal or/var/log/auth.log; the pending updates from a simulatedapt-get dist-upgrade, security and Ubuntu Pro (ESM) ones apart; the TCP ports listening and the UDP ports bound on every address (/proc/net/tcp,tcp6,udp,udp6), the names of the VPN interfaces (WireGuard, tun, tap from/sys/class/net, no other interfaces and no addresses) and whether UFW is on (/etc/ufw/ufw.conf); from/etc/passwdand/etc/grouponly the accounts with UID 0, a login shell or a membership insudo,admin,wheelordocker; whether/etc/ld.so.preloadis used and the names of/etc/crontab,/etc/cron.d,/etc/cron.*,/etc/rc.localand the.service/.timerunits in/etc/systemd/system; the running processes in/proc, compared with known cryptocurrency miners and checked for programs started from/tmp,/dev/shmor/var/tmp; and sudo’s failed attempts from the same log as the logins; and the installed packages (dpkg-query: name, source package, version, architecture). - What it sends: successful logins with their time, user name and method (key or password); failed attempts only as numbers (in total, on existing and on non-existing accounts, the number of distinct sources and the 10 most tried user names). IP addresses never leave the server: the agent keeps a salted SHA-256 of each source it has seen in
/var/lib/enver-edge-serverfor 90 days and sends only whether a login came from a new source or after a series of failed attempts. The first check only learns the sources. Of the extended checks it sends the open port numbers, the relevant accounts (name, UID, whether they can log in) with the members of the privileged groups, the names of the startup files with a hash of each (an HMAC keyed with the server’s machine ID, so it shows a change but not the content), the name of a suspicious process with the miner it matches or the temporary directory it runs from, and sudo’s failures as counts with the user names. The list of installed packages goes only when it changed since the previous check (the agent compares a hash of it). File contents, command lines and IP addresses never leave the server. - Package vulnerabilities: Enver matches the package list against known vulnerabilities (CVE) with the open-source scanner Trivy on its own servers, as soon as a new list arrives and again every day after its vulnerability database is updated; only the public databases are downloaded, the list goes nowhere else. The Package vulnerabilities card shows the critical and high ones and those actively exploited (CISA’s catalog of Known Exploited Vulnerabilities, highlighted), each with a link to the CVE, the installed and the fixed version or that no fix exists yet; Show all lists the rest. Where this Enver installation has no scanner, the card says the scan is unavailable.
- Vulnerabilities of deployed images: with the security audit in the plan, Enver also scans the image every service runs, straight from its registry with the access stored for it (never on the Edge server), as soon as the Edge server reports a new image digest and again every day. One scan serves every service of the account running the same digest. An image is scanned only from a public registry address (one that resolves to a public IP, on port 443, 80 or the port the image name gives; redirects are held to the same) and at most 2 GB per scan, under a tag that still points to the running image (Kubernetes reports the exact digest). An actively exploited vulnerability with a fix makes a critical finding, critical or high ones with a fix a high one; they go into the same e-mail as the server’s findings, a critical one is reminded of after 3 days, and they are listed in the weekly summary. Each vulnerability in the list names where its package comes from: the image’s operating system (for example
alpineordebianof the base image, even a library the service never loads) or the file of a language package such as anode_modulespackage installed in the image; only what is in the image is scanned, not the dependencies of the build. Members with the Security Viewer permission see a badge next to the service in the environment; it, or Image vulnerabilities in the service’s menu, opens the list of CVEs, exploited ones highlighted; Copy the CVE list by package puts all of them as text, grouped by package with the version to upgrade to, on the clipboard for an issue or a coding agent. The list also says when the next automatic scan comes; Scan again queues the image right away (at most once a minute), and the vulnerabilities found so far stay until it is done. Scans run one at a time, so a queued image can take a while. Fix them by rebuilding the image from an updated base, or moving to a newer tag, and redeploying. - Account overview and checks: Account settings → Security (Security Viewer) shows every edge server with its worst open finding, the time of its last audit and why it doesn’t run where it doesn’t, the agent’s version and automatic updates, the images with open findings, and checks of the Enver account itself, which use only Enver’s data and so run without an agent, hourly: edge server tokens and container registry webhooks not rotated for 12 months (rotate them in the server’s detail or the registry), a database or broker port a Docker service publishes to the network (or a Kubernetes load balancer), an older agent, automatic updates off, and members inactive for over 90 days. For that Enver records the day (not the time) of each member’s last request on the account, once a day, with no log of the requests. The page also lists the members who may reveal secrets, manage permissions or manage edge servers, the pending invitations and all published ports. An old token or webhook and a published database port are medium findings e-mailed like the others; the rest are low and show only on the page and in the weekly summary. The links in the e-mails open the right account.
- How: without root, only through fixed read-only commands (
journalctl,dpkg-query,apt-get -s,systemctl is-active/is-enabled), each started directly without a shell, with a time limit and a cap on its output; the other checks only read files anyone on the server may read. The simulated upgrade takes no lock and changes nothing. - When: every hour while the server is online, and on Check now (at most once a minute). It needs the security audit in your plan; when the subscription ends, the checks stop.
- Findings: each check is evaluated against fixed rules. Critical: a login right after a series of failed attempts, root logging in with a password,
PermitEmptyPasswords yes, root login together with password authentication, the Docker API (port 2375) open to the network, a new account with UID 0,/etc/ld.so.preloadin use, a running cryptocurrency miner. High: password authentication, root login, security updates waiting over 7 days, a distribution past its end of support, a password login from a new source, a database or cache port (PostgreSQL, MySQL, Redis, MongoDB, Elasticsearch, Memcached, RabbitMQ) open to the network, with the Enver service that publishes it, new members ofsudo,admin,wheelordocker, a program running from a temporary directory, sudo tried by a user who may not use it. Medium: a reboot waiting over 7 days,unattended-upgradesoff, package lists older than 7 days, over 100 failed attempts an hour without fail2ban or CrowdSec, weak SSH algorithms, a new account that can log in, a new or changed cron job or systemd unit, at least 5 wrong sudo passwords since the previous check. Package vulnerabilities: an actively exploited one with a fix in the distribution is critical, critical or high ones whose fix waits over 3 days are high, critical or high ones without a fix yet info; they follow the scan with the next check. Low and info: X11 forwarding, a key login from a new source, missing access, a journal that doesn’t survive a reboot, a CPU above 90 % for most of the last 6 hours (from the metrics, a hint at a hidden miner), UFW off. Network firewall: the agent can’t see a firewall in front of the server (the provider’s, a cloud security group, a router). In the server’s Security tab you can declare which ports it lets in from the internet (e.g.80/tcp, 443/tcp, 51820/udp; the ports the audit saw and a VPN’s UDP port are offered). Only those ports then count as open: a database or Docker API port the firewall blocks is a low finding instead of a high or critical one (one rule change would still open it), UFW off no longer counts, and a declared port nothing listens on is a low finding. The declaration is yours, so confirm it every 3 months (Still valid); a declaration that wasn’t confirmed is a medium finding that comes by e-mail. The changes of accounts, groups and startup files are compared with the previous report: the first report with these checks, after turning the audit on or after the agent updated, only remembers them. A finding resolves itself with the first check that no longer sees it; one raised by logins after a week without another one. You can mute a finding for up to a year. - How long it is kept: reports, logins, findings and the package list with its vulnerabilities (counted from the last check that still had it) are kept 1 to 90 days, as set for the server (90 by default), and deleted with the server.
- E-mails: each account gets one report e-mail with everything that opened on its servers, in its images and in its own checks, sent once nothing new came for 5 minutes (an audit and the image scans it starts finish minutes apart), and at the latest 30 minutes after the first finding; each server, service and the account checks have their own section with a link. A finding of medium severity or higher is in it as soon as it opens (an account gets at most 10 such e-mails an hour, the rest follows merged in the next one, and an event such as a new account or a login after failures is e-mailed at most once a day), a critical one still open after 3 days once more, and the Monday morning report carries the weekly summary, which lists per server the open and resolved findings, failed logins against the week before, pending security updates, a pending restart, the ports open to the network, a firewall that is off, sudo’s failures, the package vulnerabilities and the servers where the audit doesn’t run (no check for over 24 hours, refused, unsupported or missing access). Low and info findings show only in the app and the summary, muted ones send nothing. The e-mails carry only the names of the server, service and account, the finding and its advice, with links to the server’s Security tab, the service’s vulnerabilities and the account’s overview. Who gets them is set in Account settings → Security (Edge Server Admin): up to 10 addresses and Czech or English; with no address they go to the account owner. A new address first gets an e-mail with a link valid for 7 days and receives the alerts only once it confirmed it (the list there shows which did and sends the link again); your own address and the owner’s need no confirmation, and until one address is confirmed the e-mails go to the owner. Whenever someone changes the addresses, the owner gets an e-mail saying who receives them now. Nothing is sent while the plan doesn’t include the security audit.
- Push: users with Security Viewer can turn on push for critical findings in User settings → Notifications (off by default).
Access for the security audit
The agent’s user can’t read the system logs by default. Add it to two groups and restart the agent – adm reads /var/log/auth.log, systemd-journal the journal; both only read logs:
sudo usermod -aG adm,systemd-journal enver-edge-server
sudo systemctl restart enver-edge-server
Without them the report is partial and says what the agent couldn’t read. Some cloud images let only root read /etc/ssh/sshd_config.d/50-cloud-init.conf; the report then names the file, and sshd may use other values from it. An agent installed from a package older than the security audit can’t tell new sources apart: install the current package once more, which adds its state directory.
Don’t grant more than these groups: the agent never needs root for the audit, and access through Docker (for example a container with /var/log mounted) would go around the rule that the agent touches only its own containers.
Docker settings
On the edge server detail, Docker & Kubernetes settings apply within a minute without a restart:
- Docker socket path – default
/var/run/docker.sock. On macOS, if the installer reports another socket (e.g.~/.docker/run/docker.sock), enter its absolute path. - Image cleanup – delete only the image a new version replaced (default), or every unused image hourly and after each update.
- Volumes directories and Backups directories – the only places on the host where services may have volumes and where database backups go, one absolute path per line. A volume's host path and a service's backup directory are either relative to the first directory of the list or an absolute path anywhere inside one of them, e.g.
/opt/data/dev1/postgres-init.sh; a symbolic link may not lead out. Services may share a host path, but one volume may not lie inside another, a backup directory may not lie inside a volume, and a whole volumes directory can't be a volume: a container could otherwise reach the other service's data. Enver refuses such a save and the edge server's settings list the paths that break the rule. Enver refuses no path, so list only dedicated directories: containers can read and change everything in them. Until they are set, services with volumes don't start and no backup runs. The settings suggest/opt/enver/volumesand/opt/enver/backups, which the installer creates; another backups directory must be writable by theenver-edge-serveruser.
Everything in these two directories is open to the containers on the server and to whoever may edit services, so use dedicated directories without system files, other applications' data or secrets. On macOS add /opt/enver to the folders Docker Desktop shares.
Docker publishes the services' ports on every address of the server, past a firewall such as ufw. To publish them on one address only (e.g. a private network), put DOCKER_PORTS_HOST_IP=<address> into /etc/enver/edge-server.env.
Kubernetes
An environment of the Kubernetes type runs its services on a cluster reached through the edge server. Prepare a service account with cluster-admin rights once (Kubernetes cluster setup in the app shows the same):
kubectl create serviceaccount enver-edge-server -n default
kubectl create clusterrole enver-edge-server --verb=get,list,watch,create,update,patch,delete \
--resource=namespaces,deployments,pods,pods/log,services,secrets,ingresses,networkpolicies,persistentvolumeclaims,poddisruptionbudgets
kubectl create clusterrolebinding enver-edge-server \
--clusterrole=enver-edge-server --serviceaccount=default:enver-edge-server
kubectl create token enver-edge-server -n default --duration=87600h
kubectl config view --minify -o jsonpath='{.clusters[0].cluster.server}'
Enter the API URL, the token and optionally the cluster’s CA certificate (PEM, or certificate-authority-data from a kubeconfig) in the edge server settings. Without a CA certificate the server's certificate is checked against the system's trusted authorities; Skip TLS verification is meant for test clusters only, since the token then goes to whoever answers at the API URL. Optionally set the ingress class (empty uses the cluster’s default IngressClass) and a cert-manager ClusterIssuer to get TLS certificates for ingress rules.
Every environment gets its own namespace, so environments can’t break each other:
- A network policy lets in only pods of the same namespace. Ports routed by an ingress rule or a load balancer are public anyway, so they are open to everyone.
- The namespace enforces the
baselinePod Security Standard: no privileged containers, host networking or host paths. Pods get no service account token.
Each service becomes a Deployment with a Service of the same name, so other services reach it at name:port, just like on Docker. Variables are stored in a Secret, and a changed value rolls the pods. Volumes become PersistentVolumeClaims named after the volume (1 GiB, the cluster’s default storage class). CPU and memory requests and limits apply as set.
Replicas are set per environment service. Several replicas are spread across the cluster’s nodes, updated one by one without downtime and protected by a PodDisruptionBudget. A service with volumes is replaced instead, since its claim can be mounted on one node only.
Ingress rules route a host (server name, also *.example.com) and a path prefix to one of the service’s ports. The ingress controller serves them on HTTP 80 and, with TLS, on HTTPS 443. A host and path can be routed by only one service per edge server. For other traffic, such as a database, tick Load balancer on a port: it is then published on its exposed port through a LoadBalancer Service.
When pods don’t come up (image pull, crash loop, no room on the nodes), the service shows the reason as its error.
Environments
Under Environments → New environment, set:
- Name and subdomain (a–z, 0–9, hyphens), both unique in the account,
- deployment type – Docker or Kubernetes,
- edge server it runs on.
Start blank or Duplicate existing – every service is copied with its tag, settings, variables and groups, and starts stopped. Optionally Shift exposed ports by a number such as 1000 to move every exposed port of the copy (8080 becomes 9080). The form lists the resulting ports, refuses a shift that would hit a port already taken on the edge server or leave the range 1–65535, and offers the smallest round shift that is free. Changing the type or the name later restarts the running services (container names are derived from the environment name).
The environments page lists environments by name. The owner and members with Env Admin can change the order for the whole account: Edit environments shows every card on one page, drag them (or use the arrows) and Save order. New environments are added at the end.
Actions → Delete environment (owner and Env Admin) stops and removes all its containers and deletes the environment with its services and settings; you confirm it by typing the environment's name. Volumes and backups on the edge server stay.
Adding services
Add service picks a service from the catalog and sets for this environment its tag, index (start order), replicas, ingress rules (Kubernetes), ports, volumes, variables and variable groups. Enver warns when an exposed port is already taken on the same edge server. Docker publishes every exposed port on the host, Kubernetes only the load-balancer ports; the other Kubernetes ports stay inside the cluster. Editing a service in an environment also lets you disable it or override its command. Copy to environment… copies a single service, with its settings, into another environment; @ references are pointed at the services of the target environment.
Running services
- Start / Stop / Restart a service, a group or the whole environment. A service has its start or stop, restart and logs buttons right in its row; editing, copying, notifications and details such as its ID and index are in its ⋮ menu. The whole environment is started, restarted or stopped, edited and its permissions set from the Actions menu at the top. Enver keeps the desired state: the agent re-checks it every minute, so a stopped service stays stopped and a started one comes back.
- Switch tags in the tag field, with suggestions from the registry: the newest tags, narrowed to the matching ones (older ones included) as you type. A tag the suggestions don’t list can still be typed in full. Changes are collected; Save tags deploys them together, Discard changes drops them. Under the service’s name you see who switched its tag last (with a link to their e-mail); hover it for the previous and new tag and the time, so you know whom to ask about the running version.
- Logs show the last 250 lines of a service live, with colours and search. Enver doesn’t store them.
- The status of an environment is Running, Stopped, Starting, Stopping, or Warning when some service is in a different state or hasn’t reported for a while. Each service shows its uptime and the last error.
- A note on the environment card keeps what the team needs at hand, such as the addresses of the apps running there. Web addresses in it are clickable links. Members with Env Admin edit it, everyone who sees the environment reads it. Don’t put passwords in it: it isn’t a secret.
Monitoring
Monitoring shows for each edge server the CPU, memory, swap and disk usage (with free space) and its uptime over the last 24 hours. Metrics are sent every minute and kept for 7 days.
The agent also reports how full Docker's own disk is – on Docker Desktop that is its virtual disk, not the Mac's. From 90 % the edge server and each of its Docker environments show a warning: once the disk is full, new images can't be pulled and services don't start. Free up space with e.g. docker image prune, or set Image cleanup to every unused image.
Infrastructure overview
Infrastructure is living documentation of your infrastructure. It is built from what Enver actually deploys, so unlike a wiki page or a spreadsheet of servers and ports it is never out of date. Use it to show a new colleague what runs where, to answer ops or an auditor, or to plan the next environment.
It shows the account at a glance: for each edge server the environments running on it, each service with its status, exposed ports and volumes, a table of the server's host ports with the blocks of 1000 already in use, and a table of the host paths that hold data. A port taken twice by Docker environments is marked as a collision, a host path mounted by more than one service as shared. Environments without an edge server are listed separately. It needs the Infrastructure Viewer permission and shows every environment of the account, including ones hidden from the member by a per-environment restriction. Variables are never shown there, so you can grant Infrastructure Viewer to anyone who needs the overview without giving them access to the configuration.
PostgreSQL backups
DB Backups lists every postgres service in your Docker environments. In Backup settings, set the service's backup directory inside the edge server's first backups directory (e.g. the service's name) or as an absolute path inside any of them, turn on the daily automatic backup and how many backups to keep (older ones are deleted after each new backup). You can also Create backup at any time, Restore one (the current data is replaced 1:1) or delete it.
Backups are made with pg_dump inside the container and stored only on the edge server, never at Enver. Keep a copy elsewhere, too – a backup on the same machine does not survive losing its disk.
Notifications
Enver can send a push notification to your browser or phone when a service starts running a new image – a different tag, or a new build pushed under the same tag.
- In User settings → Notifications, click Enable on this device (once per browser or phone) and optionally limit the time range in your time zone. Notifications outside it are dropped.
- On the environment detail, choose for a service Notify once or Notify on every change.
With the security audit in your plan, Critical security findings on the same page adds a push when an edge server’s audit finds something critical.
Notifications are part of the PRO and Business packages or available as an add-on.
Plans and billing
The account’s plan is under Account → Plan and payments, your own billing (verification, extra accounts, all subscriptions you pay) under User settings → Subscriptions and payments. Prices are in EUR per month; yearly billing is 20 % cheaper.
| FREE | FREE Verified | PRO – €10 | Business – €80 | |
|---|---|---|---|---|
| Environments | 1 | 2 | 6 | 22 |
| Services | 5 | 10 | unlimited | unlimited |
| Edge servers | 1 | 2 | 6 | 22 |
| Users | 1 | 5 | 15 | 105 |
| Notifications | – | – | ✓ | ✓ |
| Security audit | – | – | – | ✓ |
Add-ons raise single limits: extra environment €4, extra edge server €3, extra user €1, unlimited services €5, notifications €2, security audit €5 and an extra owned account €5 per month. For larger needs, ask for Enterprise in the app.
- Verification unlocks FREE Verified: you save a card in Stripe, nothing is charged and the card is not kept. One card verifies one user. Paying for anything verifies you, too.
- Changing a subscription is billed pro rata right away; higher limits apply once the difference is paid.
- Cancel renewal keeps the limits until the end of the paid period; End now with refund ends it immediately and refunds the unused part to your card.
- If a renewal can’t be paid, the limits stay for 3 more days, then the account returns to the free limits. Nothing is deleted.
- Payments and invoices opens the Stripe customer portal with your invoices and card.
When you hit a limit, Enver shows what to raise instead of failing. Full terms are in the Terms of Service.
Maintenance and feedback
Planned maintenance is announced under the header at least 2 hours ahead. During it the app shows a maintenance page and reloads itself when it’s over; your environments keep running. Found a bug or have an idea? Use Send feedback in the header – every message goes straight to the Enver team.