this post was submitted on 02 Oct 2024
39 points (97.6% liked)

Selfhosted

40734 readers
348 users here now

A place to share alternatives to popular online services that can be self-hosted without giving up privacy or locking you into a service you don't control.

Rules:

  1. Be civil: we're here to support and learn from one another. Insults won't be tolerated. Flame wars are frowned upon.

  2. No spam posting.

  3. Posts have to be centered around self-hosting. There are other communities for discussing hardware or home computing. If it's not obvious why your post topic revolves around selfhosting, please include details to make it clear.

  4. Don't duplicate the full text of your blog or github here. Just post the link for folks to click.

  5. Submission headline should match the article title (don’t cherry-pick information from the title to fit your agenda).

  6. No trolling.

Resources:

Any issues on the community? Report it using the report flag.

Questions? DM the mods!

founded 2 years ago
MODERATORS
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
39
The purpose of podman quadlets? (lemmy.world)
submitted 2 months ago by [email protected] to c/[email protected]
16 comments fedilink hide all child comments
 

I'm afraid this is going to attract the "why use podman when docker exists"-folks, so let me put this under the supposition that you're already sold on (considering) using podman for whatever reason. (For me, it has been the existence of pods, to be used in situations where pods make sense, but in a non-redundant, single-node setup.)

Now, I was trying to understand the purpose of quadlets and, frankly, I don't get it. It seems to me that as soon as I want a pod with more than one container, what I'll be writing is effectively a kubernetes configuration plus some systemd unit-like file, whereas with podman compose I just have the (arguably) simpler compose file and a systemd file (which works for all pod setups).

I would get that it's sort of simpler, more streamlined and possibly more stable using quadlets to let systemd manage single containers instead of putting podman run commands in systemd service files. Is that all there is to it, or do people utilise quadlets as a kind of lightweight almost-kubernetes distro which leverages systemd in a supposedly reasonable way? (Why would you want to do that if lightweight, fully compliant kubernetes distros are a thing, nowadays?)

Am I missing or misunderstanding something?

you are viewing a single comment's thread
view the rest of the comments
[–] [email protected] 2 points 2 months ago (1 children)

Nah, I have a paperless pod created with Quadlet.

[–] [email protected] 1 points 2 months ago* (last edited 2 months ago) (1 children)

Awesome, so, essentially, you create a name.pod file like so:

[Unit]
Description=Pod Description

[Pod]
# stuff like PublishPort or networking

and join every container into the pod through the following line in the .container files: Pod=name.pod

and I presume this all gets started via systemctl --user start name.service and systemd/podman figures out somehow which containers will have to be created and joined into the pod, or do they all have to be started individually?

(Either way, I find the documentation of this feature lacking. When I tested this stuff myself, I'll look into improving it.)

[–] [email protected] 2 points 2 months ago* (last edited 2 months ago) (1 children)

Awesome, so, essentially, you create a name.pod file like so: [...]and join every container into the pod through the following line in the .container files

Yep, that's the way!

and I presume this all gets started via systemctl --user start name.service and systemd/podman figures out somehow which containers will have to be created and joined into the pod, or do they all have to be started individually?

Systemd figures it out iff you have specified your service dependencies correctly, with things like After=, Upholds=, BindsTo=, etc. Have a look at systemd.unit manpage for details. For my paperless service, it goes something like this:

  1. The entrypoint is paperless.container, which I start with systemctl --user start paperless, which depends on:
    • paperless.pod
    • Three other services, which also depend on:
      • paperless.pod
  2. Systemd figures out that the paperless pod should be started first, and does that
  3. Systemd startes the three dependent containers
  4. Finally, systemd starts the paperless container itself

The point of quadlet was to lean as heavily as possible on systemd for the service and dependency bits and use podman only for translating the container bits into something systemd can handle. The one bit of dependency handling that quadlet does is to make sure that paperless.pod is started before all containers that have Pod=paperless.pod in their quadlet file.

Either way, I find the documentation of this feature lacking. When I tested this stuff myself, I’ll look into improving it.

That would be amazing, of course! :) I find that, if you're familiar with unit files, you're like 85% of the way there already. By the way, the unit files that quadlet generates are somewhere in $XDG_RUNTUME_DIR for you to inspect. I'm afraid I'm not at a computer right now andI don't know the exact path off the top of my head.

[–] [email protected] 2 points 2 months ago

Nice, thanks, again! I overlooked the dependency instructions in the container service file, which is why I wondered how the heck podman figures out the dependencies. It makes a lot of sense to do it like this, now that I think of it.