Creating pod units from existing pod using Quadlet

[elhananjair]

Hello friends,
I have spent days figuring out how to auto-start a pod running with podman pod start mypod. I read an article on Redhat about using Quadlet, but I find it difficult to implement it on my current running system.

The examples I found on the man page and Redhat articles only focus on container units, which pull the new image and execute it. But in my case, I have already a working pod with 6 containers in it, and I want to auto-start it with Quadlet.
Can someone please support me on this?
Thanks

[Luap99]

https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html#pod-units-pod

and also see the "Example for Container in a Pod" at the end of the page for a small example

[elhananjair]

Hello @Luap99
After spending 3 weeks on this topic, I get ideas for creating different quadlets. I had a pod with 10 containers inside it, and I was trying to convert the docker-compose. yml to quadlets implementation. I used the volume path and other dependencies using podman-desktop application.

I have created a network file with the following simple content:

[Unit]
Description=Frappe App Network

[Network]
Label=app=frappe_erpnext

and I could see the network listed when executing podman network ls but the problem I am having is multiple containers running are depends on redis-queue container which is running well and ready for connection checking on the status from systemd. But, other containers are complaining that redis is inaccessible.
I tried to check whether there is a network communication issue, but podman network inspect systemd-mynetowrk all active containers on the network with ipv4 assigned to each of them.

Can you give me a hint here to fix the issue?
Thanks

[ygalblum]

Can you also share the unit files for the redis-queue container and an example of the ones that depend on it?

[elhananjair]

Ok

Here is the content of redis-queue unit file

[Container]
Label=app=frappe_redis_queue
Image=docker.io/library/redis:6.2-alpine
AutoUpdate=registry
Volume=/home/elhanan/.local/share/containers/storage/volumes/frappe_docker_redis-queue-data/_data:/data
Network=liyumfi.network
Pod=liyumfi.pod

[Service]
Restart=always

[Install]
WantedBy=default.target

There is a container depends on Redis, which is starting the redis service, I set the service type to oneshot because it only executes a command once, here is the content of the unit file

liyumfi_configurator.service

[Unit]
Description=Short living service
Requires=liyumfi_db.service liyumfi_redis-cache.service liyumfi_redis-queue.service
After=liyumfi_db.service liyumfi_redis-cache.service liyumfi_redis-queue.service

[Container]
Label=app=frappe_configurator
Image=localhost/custom:15
AutoUpdate=local
Volume=/home/elhanan/.local/share/containers/storage/volumes/frappe_docker_sites/_data:/home/frappe/frappe-bench/sites
Volume=/home/elhanan/.local/share/containers/storage/volumes/4c97a76ec8b3072249e4fceb5400a2c0897d9219fbe946ab47c176d30769fa49/_data:/home/frappe/frappe-bench/sites/assets
Volume=/home/elhanan/.local/share/containers/storage/volumes/c8cefb7de4248c8482bd66033a425c637e8c71053b3cab2bc2687b2ff98340ba/_data:/home/frappe/frappe-bench/logs
Environment=DB_HOST=db
Environment=DB_PORT=3306
Environment=REDIS_CACHE=redis-cache:6379
Environment=REDIS_QUEUE=redis-queue:6379
Environment=SOCKETIO_PORT=9000
Entrypoint=bash
Exec=-c ls -1 apps > sites/apps.txt; bench set-config -g db_host $$DB_HOST; bench set-config -gp db_port $$DB_PORT; bench set-config -g redis_cache "redis://$$REDIS_CACHE"; bench set-config -g redis_queue "redis://$$REDIS_QUEUE"; bench set-config -g redis_socketio "redis://$$REDIS_QUEUE"; bench set-config -gp sock>
Network=liyumfi.network
Pod=liyumfi.pod

[Service]
Type=oneshot
RemainAfterExit=yes
Restart=on-failure

[Install]
WantedBy=default.target

Finally, multiple containers depend on the above container, and here Is the content of the service file:

liyumfi_websocket.service

[Unit]
Requires=liyumfi_configurator.service
After=liyumfi_configurator.service

[Container]
Label=app=frappe_websocket
Image=custom:15
AutoUpdate=local
Volume=/home/elhanan/.local/share/containers/storage/volumes/5b535920a8ba43b3d828b3e7c8fe18a3f0e130ad13922288a0a4c154642f0fc1/_data:/home/frappe/frappe-bench/logs
Volume=/home/elhanan/.local/share/containers/storage/volumes/frappe_docker_sites/_data:/home/frappe/frappe-bench/sites
Volume=/home/elhanan/.local/share/containers/storage/volumes/9aa307220ba4a24a0f37adc73a7ca78f311b28b570fbaf7cf14779c0e7e833b1/_data:/home/frappe/frappe-bench/sites/assets
Exec=node /home/frappe/frappe-bench/apps/frappe/socketio.js
Network=liyumfi.network
Pod=liyumfi.pod

[Service]
Restart=on-failure

[Install]
WantedBy=default.target

I am trying to transform a pod that is already running using podman pod start ... into quadlet format to auto-start the pod an easily manage each containers.

[ygalblum]

Thanks. Since I don't have the volumes you mount into the containers, I'm not sure I can run this thing myself. BTW why are you manually mounting these directories? Their paths look like podman volumes.

Having said that, I am seeing a few things.

First, if you are running everything in the same pod, you don't really need to create a separate network. Since containers running in the same pod share their network namespace, you can reach them on localhost. The issue I'm seeing with running them together is that it seems that you have an order requirement which currently is not supported via Quadlet (no support for init-containers - #24680)

Another thing, I see that you configure: REDIS_QUEUE=redis-queue:6379. But, you didn't set the ContainerName for the redis-queue Quadlet. When not set, Quadlet uses systemd-<UnitName>. This may be the reason why your client cannot reach the server. Do you set the name argument of the container when you use the manual pod configuration?

[elhananjair]

Since I don't have the volumes you mount into the containers, I'm not sure I can run this thing myself. BTW why are you manually mounting these directories? Their paths look like podman volumes.

I have built the image locally and am deploying an open-source ERP system called ERPNext. I have already successfully created a pod with different containers and I used the volume path of those containers to check if it works with quadlets, therefore I manually copied the exact path from podman-desktop inpsect outputs.

First, if you are running everything in the same pod, you don't need to create a separate network.

I didn't know about that, thank you for the info.

The issue I'm seeing with running them together is that it seems that you have an ordering requirement that currently is not supported via Quadlet (no support for init-containers - #24680)

That's too bad I think, since the pod I have deployed using podman compose has interdependent containers. Bun in this situation, it seems it's working, because some of the unit files I have defined are starting even though I didn't define the Restart=alawys directive, it seems the other unit files are triggering for others to start, or do all units starts by default?
this is what docker-compose.yml file contains describing interdependencies.

 configurator:
    command:
      - |
        ls -1 apps > sites/apps.txt; bench set-config -g db_host $$DB_HOST; bench set-config -gp db_port $$DB_PORT; bench set-config -g redis_cache "redis://$$REDIS_CACHE"; bench set-config -g redis_queue "redis://$$REDIS_QUEUE"; bench set-config -g redis_socketio "redis://$$REDIS_QUEUE"; bench set-config -gp socketio_port $$SOCKETIO_PORT;
    depends_on:
      db:
        condition: service_healthy
        required: true
      redis-cache:
        condition: service_started
        required: true
      redis-queue:
        condition: service_started
        required: true
    entrypoint:
      - bash
      - -c
    environment:
      DB_HOST: db
      DB_PORT: "3306"
      REDIS_CACHE: redis-cache:6379
      REDIS_QUEUE: redis-queue:6379
      SOCKETIO_PORT: "9000"
    image: custom:15
    networks:
      default: null
    platform: linux/amd64
    pull_policy: never
    volumes:
      - type: volume
        source: sites
        target: /home/frappe/frappe-bench/sites
        volume: {}

Another thing, I see that you configure: REDIS_QUEUE=redis-queue:6379. But, you didn't set the ContainerName for the redis-queue Quadlet. When not set, Quadlet uses systemd-. This may be the reason why your client cannot reach the server. Do you set the name argument of the container when you use the manual pod configuration?

I haven't set ContainerName in all containers I didn't know it is mandatory for communications, but as you said checking on network inspect all container names are prepended with systemd-. When I created a pod manually from cli I used the following command
podman-compose --in-pod=1 --project-name erpnext -f ./docker-compose.yml up -d and this created a pod with containers defined in compose file.

Here is an output from Podman network inspect

[
     {
          "name": "systemd-mynetowrk",
          "id": "2bc2f7933c74c55f5a37f10864533e67916a9e7d5a96b5566ec70f71ff382915",
          "driver": "bridge",
          "network_interface": "podman3",
          "created": "2025-01-10T18:41:09.42113783+03:00",
          "subnets": [
               {
                    "subnet": "10.89.2.0/24",
                    "gateway": "10.89.2.1"
               }
          ],
          "ipv6_enabled": false,
          "internal": false,
          "dns_enabled": true,
          "labels": {
               "app": "frappe_erpnext"
          },
          "ipam_options": {
               "driver": "host-local"
          },
          "containers": {
               "791ab272335a4e10606946815b0e61d7703e672feb4bf93446a4c805828e6c5d": {
                    "name": "systemd-mynetwork_db",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.3/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "6e:1b:7c:be:60:92"
                         }
                    }
               },
               "7da2260bed489b32e69a2b8c14837ebab5c6f39a72424748796001f8fcb8a64f": {
                    "name": "systemd-mynetwork_redis-queue",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.4/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "b6:5e:b0:0c:d1:8b"
                         }
                    }
               },
               "921d3180a0c919579954d352e1603a3b53d45662928f5275dc17a1edf82f0ce1": {
                    "name": "systemd-mynetwork_redis-cache",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.6/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "c2:b0:f8:e3:df:b9"
                         }
                    }
               },
               "92ad8ee19e4d84b0e12e8dc5f2ad07b310cdce201deb4309de41380fe52afa12": {
                    "name": "systemd-mynetwork_scheduler",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.5/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "26:8f:0d:43:33:2b"
                         }
                    }
               },
               "bae52ab41fffc2c880bf01018963a924eacc3c97dc898ce75f044487a2d13de3": {
                    "name": "mynetwork-infra",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.2/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "be:a6:4b:8e:fe:c3"
                         }
                    }
               },
               "d1c607ab44a31d11b6d0c06cfc1b6500d822b47a0562cb2b5f0fad7edd85c19f": {
                    "name": "systemd-mynetwork_backend",
                    "interfaces": {
                         "eth0": {
                              "subnets": [
                                   {
                                        "ipnet": "10.89.2.11/24",
                                        "gateway": "10.89.2.1"
                                   }
                              ],
                              "mac_address": "f2:14:6a:b2:18:79"
                         }
                    }
               }
          }
     }
]

I

[elhananjair]

Hello there @ygalblum
For now, I have created systemd unit file to execute podman pod start mypod and that just works for me now to auto-start the pod when the system boots. But I would love to learn more about Quadlet specifically how to change compose files into quadlets.

[ygalblum]

I think that first you need to design how you want the deployment to look like. That is, do you want to run each container separately and just link them via a network? Or, should they all be part of the same pod?

The advantage of putting them in one pod is that allows managing their lifecycle as a single block. But, what if you don't want that? Or maybe parts should be in the same pod (because they always live together) while others should be separated (e.g. database that serves different applications).

Now, keep in mind that in addition to the support for .containers and .pod files, Quadlet also support .kube files that translate to podman kube play command, allowing you to define your pod/containers as a Kubernetes Pod or Deployment.

Also take a look at https://github.com/containers/podlet as it knows to create Quadlet files from compose

[elhananjair]

I think that first you need to design how you want the deployment to look like. That is, do you want to run each container separately and just link them via a network? Or, should they all be part of the same pod?

I already have a compose file that states the details about the containers, and I created pod based on that. I have created a pod that contains different inter-dependent containers in it, therefore all are part of the same pod. This is how I created the pod as I stated above podman-compose --in-pod=1 --project-name erpnext -f ./docker-compose.yml up -d.
I have tried Podlet and got an error while generating podlets from the compose file, I think there are some parameters that Podlet doesn't support in the compose file.

I am trying to shift from podman to Kubernetes and Openshift.