Komodo

DevOps & Automation rootful 3 containers
Open in Generator
mongo docker.io/mongo:8
komodo-core ghcr.io/moghtech/komodo-core:2 · 9120:9120
komodo-periphery ghcr.io/moghtech/komodo-periphery:2

Deployment rootful

1. Prepare the host

Operating System:
!

Prerequisites once as root

Install Podman (needs podman 4.3 or newer; Ubuntu 22.04 ships 3.4 and is too old, use 24.04)

apt update && apt install -y podman
!

Create the host directories

The containers write to these host paths as their own user, so they need the right owner, whatever format you use. Quadlet does not even create a missing one.

sudo mkdir -p /etc/komodo/backups
# sudo chown UID:GID /etc/komodo/backups   # owner unknown: the user the container writes as
sudo mkdir -p /proc
# sudo chown UID:GID /proc   # owner unknown: the user the container writes as
sudo mkdir -p /etc/komodo
# sudo chown UID:GID /etc/komodo   # owner unknown: the user the container writes as

2. Choose a format and deploy

The same pod in four forms. Pick one and follow only its steps.

Each tab says which podman it needs. Check yours with podman --version: Debian 12 ships 4.3, Ubuntu 24.04 4.9, Debian 13 5.4, Fedora 5.8, Arch 6.x.

Kubernetes YAML for podman kube play, started by systemd through a Quadlet .kube unit (podman 4.4+; older podman like Debian 12 uses podman-kube@, see the version check below).

Kubernetes YAML 

apiVersion: v1
kind: Pod
metadata:
  name: komodo
  labels:
    app: komodo
spec:
  restartPolicy: Always
  containers:
  - name: mongo
    image: docker.io/mongo:8
    env:
    - name: MONGO_INITDB_ROOT_USERNAME
      value: admin
    - name: MONGO_INITDB_ROOT_PASSWORD
      value: w5JTEf0HpfnOJ0Wa7vlwFw
    volumeMounts:
    - name: vol-0
      mountPath: /data/db
    - name: vol-1
      mountPath: /data/configdb
    args:
    - --quiet
    - --wiredTigerCacheSizeGB
    - '0.25'
  - name: komodo-core
    image: ghcr.io/moghtech/komodo-core:2
    ports:
    - containerPort: 9120
      hostPort: 9120
    env:
    - name: TZ
      value: UTC
    - name: KOMODO_DATABASE_ADDRESS
      value: 127.0.0.1:27017
    - name: KOMODO_DATABASE_USERNAME
      value: admin
    - name: KOMODO_DATABASE_PASSWORD
      value: w5JTEf0HpfnOJ0Wa7vlwFw
    - name: KOMODO_HOST
      value: https://komodo.example.com
    - name: KOMODO_TITLE
      value: Komodo
    - name: KOMODO_PERIPHERY_PUBLIC_KEY
      value: file:/config/keys/periphery.pub
    - name: KOMODO_LOCAL_AUTH
      value: 'true'
    - name: KOMODO_INIT_ADMIN_USERNAME
      value: admin
    - name: KOMODO_INIT_ADMIN_PASSWORD
      value: w5JTEf0HpfnOJ0Wa7vlwFw
    - name: KOMODO_FIRST_SERVER_NAME
      value: Local
    - name: KOMODO_WEBHOOK_SECRET
      value: XXw02tDZu-rRG4oiOAGKaQ
    - name: KOMODO_JWT_SECRET
      value: XXw02tDZu-rRG4oiOAGKaQ
    volumeMounts:
    - name: vol-2
      mountPath: /config/keys
    - name: vol-3
      mountPath: /backups
  - name: komodo-periphery
    image: ghcr.io/moghtech/komodo-periphery:2
    env:
    - name: PERIPHERY_CORE_ADDRESS
      value: ws://127.0.0.1:9120
    - name: PERIPHERY_CONNECT_AS
      value: Local
    - name: PERIPHERY_CORE_PUBLIC_KEYS
      value: file:/config/keys/core.pub
    - name: PERIPHERY_ROOT_DIRECTORY
      value: /etc/komodo
    - name: PERIPHERY_INCLUDE_DISK_MOUNTS
      value: /etc/hostname
    volumeMounts:
    - name: vol-2
      mountPath: /config/keys
    - name: vol-4
      mountPath: /var/run/docker.sock
    - name: vol-5
      mountPath: /proc
      readOnly: true
    - name: vol-6
      mountPath: /etc/komodo
  volumes:
  - name: vol-0
    persistentVolumeClaim:
      claimName: komodo-mongo-data
  - name: vol-1
    persistentVolumeClaim:
      claimName: komodo-mongo-config
  - name: vol-2
    persistentVolumeClaim:
      claimName: komodo-keys
  - name: vol-3
    hostPath:
      path: /etc/komodo/backups
      type: DirectoryOrCreate
  - name: vol-4
    hostPath:
      path: /run/podman/podman.sock
      type: FileOrCreate
  - name: vol-5
    hostPath:
      path: /proc
      type: DirectoryOrCreate
  - name: vol-6
    hostPath:
      path: /etc/komodo
      type: DirectoryOrCreate
1

Save the YAML file

sudo mkdir -p /etc/containers/
sudo nano /etc/containers/komodo.yaml
2

Test the pod (without systemd)

sudo podman kube play /etc/containers/komodo.yaml

# Status:
sudo podman pod ps && sudo podman ps

# Stop:
sudo podman kube down /etc/containers/komodo.yaml

Check your podman version

podman --version

4.4 or newer: continue with step 3 below.

Older, e.g. 4.3 on Debian 12? There is no Quadlet yet: use podman's own podman-kube@ service instead of steps 3–5 
sudo systemctl enable --now podman-kube@$(systemd-escape /etc/containers/komodo.yaml).service

# Status & logs:
sudo systemctl status podman-kube@$(systemd-escape /etc/containers/komodo.yaml).service
sudo journalctl -u podman-kube@$(systemd-escape /etc/containers/komodo.yaml).service -f

The day-to-day commands below have a block for this service.

3

Create Quadlet .kube file (systemd)

komodo.kube 
[Unit]
Description=komodo pod
After=network-online.target
Wants=network-online.target

[Kube]
Yaml=/etc/containers/komodo.yaml

[Service]
Restart=always

[Install]
WantedBy=multi-user.target

Save to /etc/containers/systemd/:

sudo mkdir -p /etc/containers/systemd/
sudo nano /etc/containers/systemd/komodo.kube
4

Start systemd service (rootful)

sudo systemctl daemon-reload
sudo systemctl start komodo.service
5

Status & Logs

sudo systemctl status komodo.service
sudo journalctl -u komodo.service -f
sudo podman pod ps
sudo podman ps
6

Enable automatic image updates optional

Requires AutoUpdate=registry in the .kube file. Podman checks for new images and restarts the pod automatically:

sudo systemctl enable --now podman-auto-update.timer

# Check status:
sudo systemctl status podman-auto-update.timer

# Trigger manually:
sudo podman auto-update
Rootful mode:
  • Containers run as root — only use trusted images
  • Ports < 1024 can be bound directly
  • No loginctl enable-linger needed — systemd manages the service
  • Quadlet path: /etc/containers/systemd/ (not ~/.config/)
Day-to-day logs, restart, update, remove (click to open)

Logs & shell into a container

sudo podman logs -f komodo-mongo
sudo podman logs -f komodo-komodo-core
sudo podman logs -f komodo-komodo-periphery
sudo podman exec -it komodo-mongo /bin/sh

Restart

sudo systemctl restart komodo.service

Update an image by hand

Pull the new version, the restart recreates the containers from it:

sudo podman pull <image>:<tag>
sudo systemctl restart komodo.service

Stop & remove

Stop through systemd, otherwise Restart=always brings the pod back. To remove it for good, delete the unit files and reload:

sudo systemctl stop komodo.service
sudo rm /etc/containers/systemd/komodo.kube
sudo systemctl daemon-reload

podman older than 4.4 (podman-kube@ from step 3)

sudo systemctl restart podman-kube@$(systemd-escape /etc/containers/komodo.yaml).service

# Update an image: pull, then restart as above
sudo podman pull <image>:<tag>

# Stop and remove from autostart:
sudo systemctl disable --now podman-kube@$(systemd-escape /etc/containers/komodo.yaml).service

Delete the data — permanent, only after stop & remove

sudo podman volume rm komodo-mongo-data
sudo podman volume rm komodo-mongo-config
sudo podman volume rm komodo-keys
sudo rm -rf /etc/komodo/backups
sudo rm -rf /run/podman/podman.sock
sudo rm -rf /proc
sudo rm -rf /etc/komodo

Native systemd units without the Kubernetes YAML: one .pod plus one .container per container. Each container becomes its own systemd service (restart, logs and ordering per container). Needs podman 5.0 or newer — Debian 12 ships 4.3, use the Kube YAML tab there.

1

Save the unit files

komodo.pod 
[Unit]
Description=komodo pod

[Pod]
PodName=komodo
PublishPort=9120:9120
komodo-mongo.container 
[Unit]
Description=komodo-mongo container

[Container]
Image=docker.io/mongo:8
Pod=komodo.pod
ContainerName=komodo-mongo
Environment=MONGO_INITDB_ROOT_USERNAME=admin
Environment=MONGO_INITDB_ROOT_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
Volume=komodo-mongo-data:/data/db:Z
Volume=komodo-mongo-config:/data/configdb:Z
Exec=--quiet --wiredTigerCacheSizeGB 0.25

[Service]
Restart=always

[Install]
WantedBy=multi-user.target
komodo-komodo-core.container 
[Unit]
Description=komodo-komodo-core container

[Container]
Image=ghcr.io/moghtech/komodo-core:2
Pod=komodo.pod
ContainerName=komodo-komodo-core
Environment=TZ=UTC
Environment=KOMODO_DATABASE_ADDRESS=127.0.0.1:27017
Environment=KOMODO_DATABASE_USERNAME=admin
Environment=KOMODO_DATABASE_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
Environment=KOMODO_HOST=https://komodo.example.com
Environment=KOMODO_TITLE=Komodo
Environment=KOMODO_PERIPHERY_PUBLIC_KEY=file:/config/keys/periphery.pub
Environment=KOMODO_LOCAL_AUTH=true
Environment=KOMODO_INIT_ADMIN_USERNAME=admin
Environment=KOMODO_INIT_ADMIN_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
Environment=KOMODO_FIRST_SERVER_NAME=Local
Environment=KOMODO_WEBHOOK_SECRET=XXw02tDZu-rRG4oiOAGKaQ
Environment=KOMODO_JWT_SECRET=XXw02tDZu-rRG4oiOAGKaQ
Volume=komodo-keys:/config/keys:Z
Volume=/etc/komodo/backups:/backups:Z

[Service]
Restart=always

[Install]
WantedBy=multi-user.target
komodo-komodo-periphery.container 
[Unit]
Description=komodo-komodo-periphery container

[Container]
Image=ghcr.io/moghtech/komodo-periphery:2
Pod=komodo.pod
ContainerName=komodo-komodo-periphery
Environment=PERIPHERY_CORE_ADDRESS=ws://127.0.0.1:9120
Environment=PERIPHERY_CONNECT_AS=Local
Environment=PERIPHERY_CORE_PUBLIC_KEYS=file:/config/keys/core.pub
Environment=PERIPHERY_ROOT_DIRECTORY=/etc/komodo
Environment=PERIPHERY_INCLUDE_DISK_MOUNTS=/etc/hostname
Volume=komodo-keys:/config/keys:Z
Volume=/run/podman/podman.sock:/var/run/docker.sock
Volume=/proc:/proc:ro
Volume=/etc/komodo:/etc/komodo:Z

[Service]
Restart=always

[Install]
WantedBy=multi-user.target

Save all of them to /etc/containers/systemd/:

sudo mkdir -p /etc/containers/systemd/
sudo nano /etc/containers/systemd/komodo.pod
sudo nano /etc/containers/systemd/komodo-mongo.container
sudo nano /etc/containers/systemd/komodo-komodo-core.container
sudo nano /etc/containers/systemd/komodo-komodo-periphery.container
2

Start the pod

The pod service pulls in every container service. Autostart at boot comes from the [Install] section of the units, no enable needed.

sudo systemctl daemon-reload
sudo systemctl start komodo-pod.service
3

Status & Logs

sudo systemctl status komodo-pod.service
sudo journalctl -u komodo-mongo.service -f
sudo journalctl -u komodo-komodo-core.service -f
sudo journalctl -u komodo-komodo-periphery.service -f
sudo podman pod ps && sudo podman ps
Day-to-day logs, restart, update, remove (click to open)

Logs & shell into a container

sudo podman logs -f komodo-mongo
sudo podman logs -f komodo-komodo-core
sudo podman logs -f komodo-komodo-periphery
sudo podman exec -it komodo-mongo /bin/sh

Restart

sudo systemctl restart komodo-pod.service

Update an image by hand

Pull the new version, the restart recreates the containers from it:

sudo podman pull <image>:<tag>
sudo systemctl restart komodo-pod.service

Stop & remove

Stop through systemd, otherwise Restart=always brings the pod back. To remove it for good, delete the unit files and reload:

sudo systemctl stop komodo-pod.service
sudo rm /etc/containers/systemd/komodo.pod
sudo rm /etc/containers/systemd/komodo-mongo.container
sudo rm /etc/containers/systemd/komodo-komodo-core.container
sudo rm /etc/containers/systemd/komodo-komodo-periphery.container
sudo systemctl daemon-reload

Delete the data — permanent, only after stop & remove

sudo podman volume rm komodo-mongo-data
sudo podman volume rm komodo-mongo-config
sudo podman volume rm komodo-keys
sudo rm -rf /etc/komodo/backups
sudo rm -rf /run/podman/podman.sock
sudo rm -rf /proc
sudo rm -rf /etc/komodo

A docker-compose.yml for podman-compose. Handy if you already work with Compose; there are no per-container systemd services.

1

Install podman-compose as root

apt install -y podman-compose
2

Save the compose file

docker-compose.yml 
services:
  mongo:
    image: docker.io/mongo:8
    restart: always
    environment:
    - MONGO_INITDB_ROOT_USERNAME=admin
    - MONGO_INITDB_ROOT_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
    command:
    - --quiet
    - --wiredTigerCacheSizeGB
    - '0.25'
    volumes:
    - komodo-mongo-data:/data/db:Z
    - komodo-mongo-config:/data/configdb:Z
    ports:
    - 9120:9120
  komodo-core:
    image: ghcr.io/moghtech/komodo-core:2
    restart: always
    environment:
    - TZ=UTC
    - KOMODO_DATABASE_ADDRESS=127.0.0.1:27017
    - KOMODO_DATABASE_USERNAME=admin
    - KOMODO_DATABASE_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
    - KOMODO_HOST=https://komodo.example.com
    - KOMODO_TITLE=Komodo
    - KOMODO_PERIPHERY_PUBLIC_KEY=file:/config/keys/periphery.pub
    - KOMODO_LOCAL_AUTH=true
    - KOMODO_INIT_ADMIN_USERNAME=admin
    - KOMODO_INIT_ADMIN_PASSWORD=w5JTEf0HpfnOJ0Wa7vlwFw
    - KOMODO_FIRST_SERVER_NAME=Local
    - KOMODO_WEBHOOK_SECRET=XXw02tDZu-rRG4oiOAGKaQ
    - KOMODO_JWT_SECRET=XXw02tDZu-rRG4oiOAGKaQ
    depends_on:
      mongo:
        condition: service_started
    volumes:
    - komodo-keys:/config/keys:Z
    - /etc/komodo/backups:/backups:Z
    network_mode: service:mongo
  komodo-periphery:
    image: ghcr.io/moghtech/komodo-periphery:2
    restart: always
    environment:
    - PERIPHERY_CORE_ADDRESS=ws://127.0.0.1:9120
    - PERIPHERY_CONNECT_AS=Local
    - PERIPHERY_CORE_PUBLIC_KEYS=file:/config/keys/core.pub
    - PERIPHERY_ROOT_DIRECTORY=/etc/komodo
    - PERIPHERY_INCLUDE_DISK_MOUNTS=/etc/hostname
    depends_on:
      mongo:
        condition: service_started
    volumes:
    - komodo-keys:/config/keys:Z
    - /run/podman/podman.sock:/var/run/docker.sock
    - /proc:/proc:ro
    - /etc/komodo:/etc/komodo:Z
    network_mode: service:mongo
volumes:
  komodo-mongo-data: null
  komodo-mongo-config: null
  komodo-keys: null

sudo mkdir -p /opt/komodo
sudo nano /opt/komodo/docker-compose.yml
3

Start, status & logs

cd /opt/komodo
sudo podman-compose up -d
sudo podman-compose ps
sudo podman-compose logs -f

# Stop:
sudo podman-compose down
4

Start after reboot

podman-restart.service starts every container with restart: always at boot:

sudo systemctl enable podman-restart.service
5

Update images

cd /opt/komodo
sudo podman-compose pull
sudo podman-compose up -d
Day-to-day logs, restart, update, remove (click to open)

Logs & shell into a container

sudo podman logs -f komodo_mongo_1
sudo podman logs -f komodo_komodo-core_1
sudo podman logs -f komodo_komodo-periphery_1
sudo podman exec -it komodo_mongo_1 /bin/sh

Restart

cd /opt/komodo
sudo podman-compose restart

Stop & remove

cd /opt/komodo
sudo podman-compose down

Delete the data — permanent, only after stop & remove

sudo podman volume rm komodo_komodo-mongo-data
sudo podman volume rm komodo_komodo-mongo-config
sudo podman volume rm komodo_komodo-keys
sudo rm -rf /etc/komodo/backups
sudo rm -rf /run/podman/podman.sock
sudo rm -rf /proc
sudo rm -rf /etc/komodo

Plain podman pod create / podman create commands. Good for a quick test or to see what happens under the hood.

1

Save the script

komodo.sh 
#!/bin/bash
set -e

# ── Create named volumes ───────────────────────────────────────────
# Named volumes are created automatically — no UID/GID permission adjustment needed.
sudo podman volume exists komodo-mongo-data || sudo podman volume create komodo-mongo-data
sudo podman volume exists komodo-mongo-config || sudo podman volume create komodo-mongo-config
sudo podman volume exists komodo-keys || sudo podman volume create komodo-keys

# ── Create host paths ──────────────────────────────────────────────
# The container process needs write access. Existing data may need chown -R.
sudo mkdir -p /etc/komodo/backups
# sudo chown UID:GID /etc/komodo/backups   # owner unknown: the user the container writes as
sudo mkdir -p /proc
# sudo chown UID:GID /proc   # owner unknown: the user the container writes as
sudo mkdir -p /etc/komodo
# sudo chown UID:GID /etc/komodo   # owner unknown: the user the container writes as

# ── Create pod ─────────────────────────────────────────────────────
sudo podman pod create \
  --name komodo \
  -p 9120:9120

# ── Container: komodo-mongo ─────────────────────────────────────────────
sudo podman create \
  --pod komodo \
  --name komodo-mongo \
  --restart always \
  -e MONGO_INITDB_ROOT_USERNAME='admin' \
  -e MONGO_INITDB_ROOT_PASSWORD='w5JTEf0HpfnOJ0Wa7vlwFw' \
  -v komodo-mongo-data:/data/db:Z \
  -v komodo-mongo-config:/data/configdb:Z \
  docker.io/mongo:8 \
  --quiet --wiredTigerCacheSizeGB 0.25

# ── Container: komodo-komodo-core ─────────────────────────────────────────────
sudo podman create \
  --pod komodo \
  --name komodo-komodo-core \
  --restart always \
  -e TZ='UTC' \
  -e KOMODO_DATABASE_ADDRESS='127.0.0.1:27017' \
  -e KOMODO_DATABASE_USERNAME='admin' \
  -e KOMODO_DATABASE_PASSWORD='w5JTEf0HpfnOJ0Wa7vlwFw' \
  -e KOMODO_HOST='https://komodo.example.com' \
  -e KOMODO_TITLE='Komodo' \
  -e KOMODO_PERIPHERY_PUBLIC_KEY='file:/config/keys/periphery.pub' \
  -e KOMODO_LOCAL_AUTH='true' \
  -e KOMODO_INIT_ADMIN_USERNAME='admin' \
  -e KOMODO_INIT_ADMIN_PASSWORD='w5JTEf0HpfnOJ0Wa7vlwFw' \
  -e KOMODO_FIRST_SERVER_NAME='Local' \
  -e KOMODO_WEBHOOK_SECRET='XXw02tDZu-rRG4oiOAGKaQ' \
  -e KOMODO_JWT_SECRET='XXw02tDZu-rRG4oiOAGKaQ' \
  -v komodo-keys:/config/keys:Z \
  -v /etc/komodo/backups:/backups:Z \
  ghcr.io/moghtech/komodo-core:2

# ── Container: komodo-komodo-periphery ─────────────────────────────────────────────
sudo podman create \
  --pod komodo \
  --name komodo-komodo-periphery \
  --restart always \
  -e PERIPHERY_CORE_ADDRESS='ws://127.0.0.1:9120' \
  -e PERIPHERY_CONNECT_AS='Local' \
  -e PERIPHERY_CORE_PUBLIC_KEYS='file:/config/keys/core.pub' \
  -e PERIPHERY_ROOT_DIRECTORY='/etc/komodo' \
  -e PERIPHERY_INCLUDE_DISK_MOUNTS='/etc/hostname' \
  -v komodo-keys:/config/keys:Z \
  -v /run/podman/podman.sock:/var/run/docker.sock \
  -v /proc:/proc:ro \
  -v /etc/komodo:/etc/komodo:Z \
  ghcr.io/moghtech/komodo-periphery:2

# ── Start pod ──────────────────────────────────────────────────────
sudo podman pod start komodo

# ── Stop & clean up ───────────────────────────────────────────────
# sudo podman pod stop komodo
# sudo podman pod rm komodo
nano komodo.sh
2

Run it, status & logs

bash komodo.sh
sudo podman pod ps && sudo podman ps
sudo podman logs -f <container-name>
3

Start after reboot

podman-restart.service starts every container with --restart always at boot:

podman 6.1 does not bring rootful pods created by hand back after a reboot (the infra container fails with stale file handle, and the failing podman-restart.service then stops the other containers it started). If the pod must survive reboots, use the Kube YAML or Quadlet tab.

sudo systemctl enable podman-restart.service
4

Remove or rebuild

The script creates the pod once. To apply changes or new images, remove the pod and run the script again (named volumes stay):

sudo podman pod rm -f komodo
bash komodo.sh
Day-to-day logs, restart, update, remove (click to open)

Logs & shell into a container

sudo podman logs -f komodo-mongo
sudo podman logs -f komodo-komodo-core
sudo podman logs -f komodo-komodo-periphery
sudo podman exec -it komodo-mongo /bin/sh

Restart

sudo podman pod stop komodo
sudo podman pod start komodo

Stop & remove

sudo podman pod rm -f komodo

Delete the data — permanent, only after stop & remove

sudo podman volume rm komodo-mongo-data
sudo podman volume rm komodo-mongo-config
sudo podman volume rm komodo-keys
sudo rm -rf /etc/komodo/backups
sudo rm -rf /run/podman/podman.sock
sudo rm -rf /proc
sudo rm -rf /etc/komodo
Useful Tips

Ports < 1024 (e.g. 80, 443)

Rootless cannot open privileged ports. Solution:

sysctl net.ipv4.ip_unprivileged_port_start=80

Make persistent in /etc/sysctl.d/99-podman.conf.

Containers communicate via localhost

All containers in the pod share the same network namespace. Always use localhost, not container names.

# Correct (e.g. app → db):
localhost:5432

# Wrong (doesn't work in a pod):
db-container:5432

List open ports

Which ports are the running containers publishing? See the PORTS column:

podman ps

Custom DNS for the pod

Set a custom DNS server (e.g. local Pi-hole) in the generator under DNS server. Every format picks it up.

Set volume ownership

Fix permission errors by adjusting UID/GID in the user namespace:

podman unshare chown 1000:1000 /path/to/volume

SELinux volume labels

On SELinux systems (RHEL, Fedora) set the volume suffix:

/host/path:/container/path:Z   # private
/host/path:/container/path:z   # shared

List all volumes

podman volume ls
podman volume inspect <volume-name>

Volume backup

Back up data from a named volume:

podman run --rm \
  -v <volume-name>:/data:ro \
  -v $(pwd):/backup \
  busybox tar czf /backup/backup.tar.gz /data

Cleanup

Remove unused images, containers and volumes:

podman system prune -f        # containers + images
podman image prune -f         # untagged images only
podman volume prune -f        # unused volumes

Check for outdated images

List local images; auto-update only covers units with AutoUpdate= (Kube and Quadlet tabs):

podman images
podman auto-update --dry-run

All containers, including stopped ones

podman pod ps
podman ps -a

Resource usage

podman stats --no-stream
Customize this stack
Change ports, volumes, environment variables and more in the generator.
Open in Generator