Provided by: podman_3.4.4+ds1-1ubuntu1.22.04.3_amd64 bug

NAME

       podman-generate-systemd - Generate systemd unit file(s) for a container or pod

SYNOPSIS

       podman generate systemd [options] container|pod

DESCRIPTION

       podman  generate  systemd will create a systemd unit file that can be used to control a container or pod.
       By default, the command will print the content of the unit files to stdout.

       _Note: If you use this command with the remote client, you would still have to place the generated  units
       on  the  remote  system.  Moreover, please make sure that the XDG_RUNTIMEDIR environment variable is set.
       If unset, you may set it via export XDG_RUNTIME_DIR=/run/user/$(id -u).

OPTIONS

   --files, -f
       Generate   files   instead   of   printing    to    stdout.     The    generated    files    are    named
       {container,pod}-{ID,name}.service and will be placed in the current working directory.

       Note:  On  a  system  with  SELinux  enabled,  the generated files will inherit contexts from the current
       working directory. Depending on the SELinux setup, changes  to  the  generated  files  using  restorecon,
       chcon,  or  semanage  may  be  required to allow systemd to access these files. Alternatively, use the -Z
       option when running mv or cp.

   --format=format
       Print the created units in specified format (json). If --files is specified  the  paths  to  the  created
       files will be printed instead of the unit content.

   --name, -n
       Use the name of the container for the start, stop, and description in the unit file

   --new
       Using  this  flag  will  yield  unit files that do not expect containers and pods to exist.  Instead, new
       containers and pods are created based on their configuration files.  The  unit  files  are  created  best
       effort  and  may need to be further edited; please review the generated files carefully before using them
       in production.

       Note that --new only works on containers and pods created directly via Podman (i.e.,  podman  [container]
       {create,run}  or  podman pod create).  It does not work on containers or pods created via the REST API or
       via podman play kube.

   --no-header
       Do not generate the header including meta data such as the Podman version and the timestamp.

   --time, -t=value
       Override the default stop timeout for the container with the given value.

   --restart-policy=policy
       Set the systemd restart policy.  The restart-policy must be one  of:  "no",  "on-success",  "on-failure",
       "on-abnormal", "on-watchdog", "on-abort", or "always".  The default policy is on-failure.

   --container-prefix=prefix
       Set the systemd unit name prefix for containers. The default is container.

   --pod-prefix=prefix
       Set the systemd unit name prefix for pods. The default is pod.

   --separator=separator
       Set the systemd unit name separator between the name/id of a container/pod and the prefix. The default is
       -.

EXAMPLES

   Generate and print a systemd unit file for a container
       Generate a systemd unit file for a container running nginx with an always  restart  policy  and  1-second
       timeout  to stdout. Note that the RequiresMountsFor option in the Unit section ensures that the container
       storage for both the GraphRoot and the RunRoot are mounted prior to starting  the  service.  For  systems
       with  container  storage on disks like iSCSI or other remote block protocols, this ensures that Podman is
       not executed prior to any necessary storage operations coming online.

              $ podman create --name nginx nginx:latest
              $ podman generate systemd --restart-policy=always -t 1 nginx
              # container-de1e3223b1b888bc02d0962dd6cb5855eb00734061013ffdd3479d225abacdc6.service
              # autogenerated by Podman 1.8.0
              # Wed Mar 09 09:46:45 CEST 2020

              [Unit]
              Description=Podman container-de1e3223b1b888bc02d0962dd6cb5855eb00734061013ffdd3479d225abacdc6.service
              Documentation=man:podman-generate-systemd(1)
              Wants=network-online.target
              After=network-online.target
              RequiresMountsFor=/var/run/container/storage

              [Service]
              Restart=always
              ExecStart=/usr/bin/podman start de1e3223b1b888bc02d0962dd6cb5855eb00734061013ffdd3479d225abacdc6
              ExecStop=/usr/bin/podman stop -t 1 de1e3223b1b888bc02d0962dd6cb5855eb00734061013ffdd3479d225abacdc6
              KillMode=none
              Type=forking
              PIDFile=/run/user/1000/overlay-containers/de1e3223b1b888bc02d0962dd6cb5855eb00734061013ffdd3479d225abacdc6/userdata/conmon.pid

              [Install]
              WantedBy=default.target

   Generate systemd unit file for a container with --new flag
       The --new flag generates systemd unit files that create and remove containers at service start  and  stop
       commands  (see  ExecStartPre  and ExecStopPost service actions). Such unit files are not tied to a single
       machine and can easily be shared and used on other machines.

              $ sudo podman generate systemd --new --files --name bb310a0780ae
              # container-busy_moser.service
              # autogenerated by Podman 1.8.3
              # Fri Apr  3 09:40:47 EDT 2020

              [Unit]
              Description=Podman container-busy_moser.service
              Documentation=man:podman-generate-systemd(1)
              Wants=network-online.target
              After=network-online.target
              RequiresMountsFor=/var/run/container/storage

              [Service]
              Environment=PODMAN_SYSTEMD_UNIT=%n
              Restart=on-failure
              ExecStartPre=/bin/rm -f %t/%n-pid %t/%n-cid
              ExecStart=/usr/local/bin/podman run --conmon-pidfile %t/%n-pid --cidfile %t/%n-cid --cgroups=no-conmon -d -dit alpine
              ExecStop=/usr/local/bin/podman stop --ignore --cidfile %t/%n-cid -t 10
              ExecStopPost=/usr/local/bin/podman rm --ignore -f --cidfile %t/%n-cid
              PIDFile=%t/%n-pid
              KillMode=none
              Type=forking

              [Install]
              WantedBy=default.target

   Generate systemd unit files for a pod with two simple alpine containers
       Note systemctl should only be used on  the  pod  unit  and  one  should  not  start  or  stop  containers
       individually  via  systemctl,  as  they  are  managed  by  the pod service along with the internal infra-
       container.

       You can still use systemctl status or journalctl to examine container or pod unit files.

              $ podman pod create --name systemd-pod
              $ podman create --pod systemd-pod alpine top
              $ podman create --pod systemd-pod alpine top
              $ podman generate systemd --files --name systemd-pod
              /home/user/pod-systemd-pod.service
              /home/user/container-amazing_chandrasekhar.service
              /home/user/container-jolly_shtern.service
              $ cat pod-systemd-pod.service
              # pod-systemd-pod.service
              # autogenerated by Podman 1.8.0
              # Wed Mar 09 09:52:37 CEST 2020

              [Unit]
              Description=Podman pod-systemd-pod.service
              Documentation=man:podman-generate-systemd(1)
              Requires=container-amazing_chandrasekhar.service container-jolly_shtern.service
              Before=container-amazing_chandrasekhar.service container-jolly_shtern.service
              Wants=network-online.target
              After=network-online.target
              RequiresMountsFor=/var/run/container/storage

              [Service]
              Restart=on-failure
              ExecStart=/usr/bin/podman start 77a818221650-infra
              ExecStop=/usr/bin/podman stop -t 10 77a818221650-infra
              KillMode=none
              Type=forking
              PIDFile=/run/user/1000/overlay-containers/ccfd5c71a088768774ca7bd05888d55cc287698dde06f475c8b02f696a25adcd/userdata/conmon.pid

              [Install]
              WantedBy=default.target

   Installation of generated systemd unit files.
       Podman-generated unit files include an [Install] section, which carries installation information for  the
       unit. It is used by the enable and disable commands of systemctl(1) during installation.

       Once   you  have  generated  the  systemd  unit  file,  you  can  copy  the  generated  systemd  file  to
       /etc/systemd/system for installing as a root user and to $HOME/.config/systemd/user for installing it  as
       a non-root user. Enable the copied unit file or files using systemctl enable.

       Note:  Copying  unit files to /etc/systemd/system and enabling it marks the unit file to be automatically
       started at boot. And similarly, copying a unit file to $HOME/.config/systemd/user and enabling  it  marks
       the unit file to be automatically started on user login.

              # Generated systemd files.
              $ podman pod create --name systemd-pod
              $ podman create --pod systemd-pod alpine top
              $ podman generate systemd --files --name systemd-pod

              # Copy all the generated files.

              $ sudo cp pod-systemd-pod.service container-great_payne.service /etc/systemd/system
              $ systemctl enable pod-systemd-pod.service
              Created symlink /etc/systemd/system/default.target.wants/pod-systemd-pod.service → /etc/systemd/system/pod-systemd-pod.service.
              $ systemctl is-enabled pod-systemd-pod.service
              enabled

       To  run  the  user  services placed in $HOME/.config/systemd/user on first login of that user, enable the
       service with --user flag.

              $ systemctl --user enable <.service>

       The systemd user instance is killed after the last session for the  user  is  closed.  The  systemd  user
       instance can be kept running ever after the user logs out by enabling lingering using

              $ loginctl enable-linger <username>

   Use systemctl to perform operations on generated installed unit files.
       Create and enable systemd unit files for a pod using the above examples as reference and use systemctl to
       perform operations.

       Since systemctl defaults to using the root user, all the changes using  the  systemctl  can  be  seen  by
       appending sudo to the podman cli commands. To perform systemctl actions as a non-root user use the --user
       flag when interacting with systemctl.

       Note: If the previously created containers or pods are using shared resources, such as ports,  make  sure
       to remove them before starting the generated systemd units.

              $ systemctl --user start pod-systemd-pod.service
              $ podman pod ps
              POD ID         NAME          STATUS    CREATED          # OF CONTAINERS   INFRA ID
              0815c7b8e7f5   systemd-pod   Running   29 minutes ago   2                 6c5d116f4bbe
              $ sudo podman ps # 0 Number of pods on root.
              CONTAINER ID  IMAGE  COMMAND  CREATED  STATUS  PORTS  NAMES
              $ systemctl stop pod-systemd-pod.service
              $ podman pod ps
              POD ID         NAME          STATUS   CREATED          # OF CONTAINERS   INFRA ID
              272d2813c798   systemd-pod   Exited   29 minutes ago   2                 6c5d116f4bbe

       Create  a simple alpine container and generate the systemd unit file with --new flag.  Enable the service
       and control operations using the systemctl commands.

       Note: When starting the container  using  systemctl  start  rather  than  altering  the  already  running
       container it spins up a "new" container with similar configuration.

              # Enable the service.

              $ sudo podman ps -a
              CONTAINER ID  IMAGE                            COMMAND  CREATED        STATUS     PORTS  NAMES
              bb310a0780ae  docker.io/library/alpine:latest  /bin/sh  2 minutes ago  Created           busy_moser
              $ sudo systemctl start container-busy_moser.service
              $ sudo podman ps -a
              CONTAINER ID  IMAGE                            COMMAND  CREATED        STATUS            PORTS      NAMES
              772df2f8cf3b  docker.io/library/alpine:latest  /bin/sh  1 second ago   Up 1 second ago              distracted_albattani
              bb310a0780ae  docker.io/library/alpine:latest  /bin/sh  3 minutes ago  Created                      busy_moser

SEE ALSO

       [podman(1)], [podman-container(1)], systemctl(1), systemd.unit(5), systemd.service(5), conmon(8).

HISTORY

       April  2020,  Updated details and added use case to use generated .service files as root and non-root, by
       Sujil Shah (sushah at redhat dot com)

       August 2019, Updated with pod support by Valentin Rothberg (rothberg at redhat dot com)

       April 2019, Originally compiled by Brent Baude (bbaude at redhat dot com)

                                                                                    podman-generate-systemd(1)()