Always-on agents · Set it up anywhere

Running an always-on agent on openSUSE

openSUSE gives you three different hosts under one name, and one of them, MicroOS, may be the best always-on box in this whole series: a read-only system that updates itself into a new snapshot and reboots only in a window you choose. This page covers only what differs from the generic Linux steps.

In short

On openSUSE the ten Linux steps are the same; what changes is the host you pick and the package manager. Tumbleweed is rolling and upgrades with zypper dup, Leap is the regular release with a 24-month support period, and MicroOS is immutable: packages go into a new snapshot with transactional-update and the box reboots inside a rebootmgr window. firewalld is on by default.

Part of the Always-on agents series, post 27 of 33.

Every Linux guide in this series starts from the same ten steps: a dedicated user, a virtual environment, secrets outside the unit, a systemd service with a restart policy, a timer, a watchdog. I am not going to repeat them. What is worth a page of its own on openSUSE is the choice you make before step one, because the distribution ships three hosts with three different ideas about how a machine should change while it runs.

Leap, Tumbleweed or MicroOS: pick the host first

FlavourHow it changesWhat that means for an agent that never stops
Leap 16.0Regular releases built from SUSE Linux Enterprise source plus community packages; openSUSE describes it as a longer lifecycle with a 24-month support periodThe quiet choice. Patch with zypper patch on your own schedule; the Python and Node you install stay put
TumbleweedRolling: openSUSE describes it as install once and enjoy it forever, with updates thoroughly tested before release and a single command to update thousands of packagesThe current choice. The host moves under the agent, so the venv and a scheduled, logged zypper dup matter more than anywhere else except Arch
MicroOSImmutable: no changes on disk, every update is a transaction into a new btrfs snapshot, with automated recovery from a faulty update by rebooting to an old snapshotThe always-on choice. The agent lives in the writable parts, the system updates itself, and you decide the hour it reboots

If you want the shortest path to a box you can forget about, read the MicroOS section first. If you already run Leap or Tumbleweed, the rest of this page is a short list of differences and one real test.

zypper, in the four commands you need

The package manager is the first visible difference from the Debian family. The commands are longer and the names are different, but the shape is familiar: refresh, install, upgrade. The one that catches people is that Tumbleweed upgrades with dup, short for distribution upgrade, because a rolling release is technically a new distribution every time.

Terminal# refresh the repositories, then install what the agent needs
sudo zypper refresh
sudo zypper install python3 python3-pip

# Tumbleweed upgrades with dup (distribution upgrade), not update:
sudo zypper dup --dry-run      # show what a rolling upgrade would change
sudo zypper dup

# Leap takes patches like a regular release:
sudo zypper patch

The dry run is the habit I would build on any rolling host. Before an unattended upgrade touches a machine with an agent on it, something should have logged what it was about to do. On Arch I run the upgrade inside a maintenance window; on Tumbleweed I would do the same, with zypper dup --dry-run written to the log first.

The unit is the same, and it verifies

Nothing about the service file changes on openSUSE. The same unit I used on the core page, with its restart policy, memory cap and read-only filesystem view, verifies clean here. The Python you get from the repositories is current (3.13 on the Tumbleweed snapshot I tested), so the virtual environment is a one-liner rather than the backports dance that Debian needs.

firewalld is on by default

openSUSE ships firewalld rather than ufw, the same as Fedora, and I leave the default zone exactly as it comes: it opens nothing inbound. For an agent that reaches out to the world and listens for nothing, that is exactly right and there is nothing to do. If your agent exposes a local port for a dashboard, add the port to the zone with firewall-cmd --permanent --add-port and reload, and keep it bound to localhost or a tailnet address, never to every interface. In a container there is no daemon, so the test below uses firewall-offline-cmd, which reads the same configuration.

YaST, when you prefer a screen

openSUSE's administration tool runs in text mode over SSH, and two of its modules are useful for an agent box: yast2 services-manager to enable and start the unit and read its state, and yast2 firewall for the zone. I use the command line for both because the commands end up in my notes and the screens do not, but if you inherit a server from someone who set it up in YaST, that is where their settings will be.

MicroOS: the host that updates itself and reboots on your schedule

This is the part of openSUSE I would point an always-on agent at. MicroOS describes itself as an immutable operating system: the root filesystem is read-only, updates are applied as whole transactions into a new btrfs snapshot, and recovery from a faulty update means rebooting to the old snapshot. For a machine whose entire job is to keep one process alive, that is the right set of guarantees, and it is the opposite of the rolling host above.

Terminal (MicroOS)# MicroOS: nothing installs into the running system. Each change goes into a new snapshot
# and becomes the system on the next reboot.
sudo transactional-update pkg install python3 python3-pip
sudo transactional-update shell          # a shell inside the new snapshot, for anything else
sudo reboot                               # or let rebootmgr do it inside the window

# roll back if the new snapshot misbehaves
sudo transactional-update rollback last

Two things follow from the transaction model. First, the agent cannot live in the system tree, because the system tree is read-only and gets replaced; it lives in the writable parts, and I would put it under /var/lib/agent with its state beside it. Second, nothing you install is live until the box reboots, so the reboot has to be scheduled rather than feared. That is what rebootmgr is for. Its README lists four strategies: instantly, maint-window, best-effort (the default, which behaves like maint-window when a window is set and reboots at once when it is not) and off. The window is two lines in a config file.

/etc/rebootmgr/rebootmgr.conf# /etc/rebootmgr/rebootmgr.conf  (MicroOS; the README's own example, moved to a quiet hour)
[rebootmgr]
window-start=03:30
window-duration=1h30m
strategy=maint-window

The transactional-update man page says the update runs from a systemd timer at regular intervals and that the time is configured in /etc/systemd/system/transactional-update.timer.d/local.conf; by default it hands the reboot to rebootmgrd, which then waits for the window. So the whole maintenance story on MicroOS is: pick a quiet ninety minutes, write them into one file, and make sure the agent's unit is enabled so it comes back after the reboot. My own publishing job would have had a calmer September on a host like this, because the failure that bit me was a machine waking at an unplanned time, and MicroOS does not have unplanned times.

The openSUSE checklist

The five steps I do differently here. Everything else is on the core page.

  1. Pick the host. MicroOS for a box that is only the agent, Leap for a quiet regular release, Tumbleweed when you want current packages and will schedule the rolling upgrade.
  2. Install with zypper. zypper refresh, then zypper install python3 python3-pip. On MicroOS the same install goes through transactional-update pkg install and lands after a reboot.
  3. Put the agent in a writable place. /srv/agent on Leap and Tumbleweed; /var/lib/agent on MicroOS, where the system tree is read-only.
  4. Leave firewalld as it is. It is on by default and opens nothing inbound. Add a port only for a local dashboard, bound to a private address.
  5. Schedule the change window. Log zypper dup --dry-run before a Tumbleweed upgrade; on MicroOS set window-start and window-duration in rebootmgr.conf and enable the agent's unit so it returns after the reboot.

What I tested, and what I did not

A fresh opensuse/tumbleweed container, snapshot 20261018, on an Apple Silicon Mac running Docker. Inside it I refreshed the repositories, installed Python, systemd and firewalld, created the agent user and virtual environment, wrote the heartbeat agent and the service unit from the core page, verified the unit, read the firewalld defaults offline, and confirmed that transactional-update and rebootmgr are in the Tumbleweed repositories. This is the log.

container log## release
NAME="openSUSE Tumbleweed"
VERSION_ID="20261018"
PRETTY_NAME="openSUSE Tumbleweed"
## zypper refresh
Building repository 'openSUSE-Tumbleweed-Oss' cache [....done]
All repositories have been refreshed.
## zypper install python3 python3-pip systemd firewalld
The following 63 NEW packages are going to be installed:
(21/63) Installing: systemd-default-settings-branding-openSUSE-0.10-1.7.noarch [..done]
(22/63) Installing: systemd-default-settings-0.10-1.7.noarch [..done]
(23/63) Installing: systemd-presets-common-SUSE-15-48.2.noarch [..done]
(37/63) Installing: systemd-presets-branding-openSUSE-12.2-29.3.noarch [..done]
Python 3.13.16
systemd 261 (261.3)
/usr/bin/firewall-offline-cmd
## zypper dup --dry-run (what a Tumbleweed upgrade is)
(in a container zypper only printed its hint about downloading file lists first; on a real host this lists every package the rolling upgrade would change)
## agent user + venv
venv python 3.13.16
## systemd-analyze verify
unit verifies clean
## firewalld (offline, no daemon in a container)
public
ports open by default: []
## transactional-update in the repos
Version        : 6.1.3-1.2
Summary        : Transactional Updates with btrfs and snapshots
## rebootmgr in the repos
Version        : 4.0+git20261008.76d8ee7-1.1
Summary        : Automatic controlled reboot during a maintenance window

What a container cannot show: a real boot with systemd as PID 1, a running firewalld daemon, and the MicroOS transaction and reboot cycle itself. I have described that cycle from the project's own documentation, linked below, and I have not run a MicroOS host through a maintenance window myself. When I do, this page gets a dated update, the same way the headlines post does.

Sources

  1. openSUSE, Tumbleweed: continuously updated (accessed October 20, 2026)
  2. openSUSE, Leap 16.0 (accessed October 20, 2026)
  3. openSUSE, MicroOS (accessed October 20, 2026)
  4. openSUSE, transactional-update(8) man page (accessed October 20, 2026)
  5. SUSE, rebootmgr README (accessed October 20, 2026)

Written by Lera Leonteva. Container run reproduced above; the MicroOS update and reboot cycle is described from the documentation linked here.

Frequently asked questions

Which openSUSE should I use for an always-on agent?

MicroOS if the machine's only job is the agent: read-only system, updates in a new snapshot, reboots inside a window you set. Leap if you want a regular release with a 24-month support period and a host that only changes when you patch it. Tumbleweed if you want current packages and will schedule and log the rolling upgrade.

What is the difference between zypper up and zypper dup?

On Tumbleweed the upgrade command is zypper dup, distribution upgrade, because each rolling snapshot is treated as a new distribution and packages may be replaced or removed. On Leap you take patches and updates with zypper patch or zypper update.

How do updates work on MicroOS?

transactional-update installs into a new btrfs snapshot, which becomes the default root on the next boot; the running system is not touched and a bad snapshot is rolled back. A systemd timer runs the update at regular intervals and, by default, asks rebootmgrd to reboot, which waits for the maintenance window in /etc/rebootmgr/rebootmgr.conf.

Do I need to open the firewall for an agent on openSUSE?

Not if the agent only reaches out. firewalld is on by default and opens nothing inbound. Open a port only for a local dashboard, and bind it to localhost or a private network address.

Was this tested on a real openSUSE install?

In a fresh Tumbleweed container (snapshot 20261018): packages, the venv, the service unit and the firewalld defaults, with the log reproduced above. Not tested: a real boot, a running firewalld, and the MicroOS reboot cycle, which the post describes from the project's documentation.

Lera Leonteva
Lera Leonteva
CEO & Founder, Leo AI

Lera Leonteva is the founder and CEO of Leo AI, where she works on turning long-form footage into short-form video that earns attention on its own merits. She writes Video Scaling Strategies, taking one piece of content that worked and one that did not, and using what the market is doing to explain the gap.

The always-on agent I run for social video

Leo watches what your audience is responding to, picks a clip from footage you already have, edits it and books it on the calendar. Every hour, without being asked. It is the agent this whole series grew out of.

Keep going with the series

Every post in the Always-on agents series is on one page, newest first. If you would rather see the agent I run for social video, here it is.