- Why do so many example services contain that line?
- What would happen if they did not contain WantedBy=multi-user.target?
- Could you give me an example of when it would actually be advisable to not include that line in a service file definition?
- Along the same lines, when is it a good idea to keep that line in?
multi-user.target is basically the closest equivalent of classic SysVinit runlevel 3 that
systemd has. When a
systemd system boots up,
systemd is trying to make the system state match the state specified by
default.target - which is usually an alias for either
multi-user.target normally defines a system state where all network services are started up and the system will accept logins, but a local GUI is not started. This is the typical default system state for server systems, which might be rack-mounted headless systems in a remote server room.
graphical.target is another possible alias for
default.target. Normally it's defined as a superset of the
multi-user.target: it includes everything the
multi-user.target does, plus the activation of a local GUI login. So kind of like runlevel 5 in classic SysVinit.
WantedBy=multi-user.target in a service is essentially the same as specifying "this service should start in runlevels 3, 4 and 5" in SysVinit systems: it tells
systemd that this service should be started as part of normal system start-up, whether or not a local GUI is active.
WantedBy is separate from the enabled/disabled state: so in another sense, it's sort of a "preset": it determines under what conditions the automatic start may happen, but only when the service is enabled in the first place.
2.) if you omit the
WantedBy=multi-user.target line and no other enabled service includes a
Wants=your.service in its service definition, your service will not be started automatically.
systemd works on dependencies, and at boot time, if nothing
Wants your service, it won't be started even if the service is enabled.
Sure, you could edit your
default.target to add or delete
Wants lines for any services you want started at boot time - but so that you can just drop a new service file into the system and have it work by default (which makes things very easy for software package managers),
systemd has the
RequiredBy keywords which can be used to insert
Requires-type dependencies (respectively) from "the other end".
3.) You should omit the line if you don't want the service to be ever started automatically at boot time, or this service is a part of a chain of dependencies you've defined explicitly.
For example, you might be refactoring server application A and for some reason or another decide to split some optional functionality off it into a separate service B, to allow the user the choice of not installing it if it isn't needed. You could then make service B a separate
service-B.rpm, and define
WantedBy=A.service to make
systemd start up service B automatically whenever service A is started - but only when
service-B.rpm is actually installed.
Note that a
WantedBy only says that the system should startup one service whenever another service or target is also started, but it specifies nothing at all about the startup/shutdown order. If you need service B to be already running when service A starts up, you'd need to add
Before=A.service in the
B.service file to explicitly specify the start-up order dependency.
4.) Anytime you do want the service to have the capability of being started automatically at boot time, and there are no other dependencies already defined.
If you remove
systemctl enable your-example-here will (noisily) fail to do anything.
If you install pure systemd from the source, the "default target" that it boots to is
multi-user.target, plus whatever unit(s) are required to provide a graphical user interface. This extra complexity was arranged in an attempt to emulate legacy "runlevels".
You really should ignore / gloss over the "runlevel" emulation; it does not work correctly anyway. Sorry! I guess the reason for emphasizing "graphical" v.s. "multi-user" historically is that graphics software is 1) not as robust and mature as the rest of the system and 2) requires a lot of resources.
Typically only a few units are specific to
graphical.target. There is a single service for the GUI itself like
gdm.target. There are a few support services that are mostly used by the GUI here as well.
Edit: Googling suggests that if you don't have a GUI installed, but the "default target" has been left as
graphical.target, then systemd might log a warning. "Cannot add dependency job for unit display-manager.service, ignoring: Unit display-manager.service failed to load: No such file or directory." We want to avoid littering our logs with unnecessary warnings. So if you did not install a GUI, it is good to use
systemctl set-default multi-user. Although the install system for your OS might have taken care of this for you already. Other than that, I am strongly in favour of apathy in this matter :-).
Some services and other types of units are "involved in early boot". They are defined to start
Before=sysinit.target - either directly or indirectly. Most services are only started
After=sysinit.target - this is automatically the case, unless the service sets
Most example services do not fall under either of the above categories, therefore we attach them to
multi-user.target. This includes most network services (e.g. a web server), which are the archetypal system service.
dynamically activated services
Another possibility you might see, is a service unit that is not started automatically at boot. So it would not need
WantedBy=multi-user.target. The service can instead be triggered or "activated" by something else.
One example of this is a dbus activated service. Dbus can be configured to start your service on-demand, when a dbus call is made to the service.
For network services, you can use socket-activated services. This might be easier to find details about, because all the configuration is in systemd units. For example
ssh.socket is typically available to activate
sshd@.service. Although, I think it is more common to start the sshd service at boot time.
As always, the above simplifies and omits details which did not seem to be required.
multi-user.target is a semantic name, that is, it is associated with a meaning. Allow me to demonstrate the concept with a counterexample. I will make the argument that the decision to use
multi-user.target depends on the context.
If you were to create a systemd user unit configuration rather than a system unit configuration, you might naively follow the conventions of the systemd system units and use
Explanation by Counter-Example
Consider the file
This user will only by used with respect to user
jonathan, therefore it hardly makes sense to call my target "multi-user.target".
[Unit] Description=Does some cool stuff. [Service] ExecStart=/bin/bash -c '/usr/bin/echo "Cool stuff" >> %h/coolstuff.txt' [Install] WantedBy=user.target
Note how I opted to use
WantedBy=user.target. This is because the scope of this context is my user account, therefore I opted to use my own semantic conventions. In other words, multiple users will not be affected by this unit. On the system level however, it makes more sense to follow standardized conventions because of the parallel startup sequence. During startup, many procedures converge on multiple targets. The
multi-user.target is semantically associated with the idea of "read for user engagement / interaction with the system" (without a windowing system as telcoM mentioned), therefore it is a safe bet for most system unit files.
- Although it would not make sense from within this context, it would still work.