Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. It only takes a minute to sign up.
Sign up to join this community
I have read what is multi-user.target and the systemd documentation, which states that the multi-user.target is a special target. Further, a lot of the systemd examples contain that line.
1.) 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 graphical.target or multi-user.target.
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.
The line 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.
However, 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 Requires=your.service or Wants=your.service in its service definition, your service will not be started automatically.
systemd works on dependencies, and at boot time, if nothing Requires or 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 Requires or 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 WantedBy and RequiredBy keywords which can be used to insert Wants and 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 B.service with 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 Wants or 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.
man systemd.target says when you are wanted by a target, you are also automatically ordered before the target. This explains why the logs show graphical.target is only "started" after all the services are. Unless the wanted unit (or the target?) has DefaultDependencies=no.
Mar 16, 2019 at 14:04
Type=oneshot services which are intended to be triggered by something else (like a notification service)? Would the oneshot be run also for each boot?
[Install] Wanted-By=<multi-user|graphical|whatever>.target; but if you want it to only be triggered by your "something else", then you'd omit it.
If you remove WantedBy=multi-user.target, then 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 graphical.target.
Starting graphical.target starts 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 DefaultDependencies=no.
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.
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 sshd.socket or ssh.socket is typically available to activate [email protected] or [email protected]. 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.
The 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 multi-user.target1.
Consider the file /home/jonathan/.config/systemd/user/coolstuff.service
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.
Footnotes
systemd --user instance which has its own targets. You'd want to use the default.target then.
user.target. As mentioned explicitly, ”I opted to use my own semantic conventions.“ All targets are semantic conventions that serve as latches. You can list your targets using systemctl list-units —user —type=target. Creating targets is beyond the scope of this question.
May 6 at 8:54