22

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. Why do so many example services contain that line?
  2. What would happen if they did not contain WantedBy=multi-user.target?
  3. Could you give me an example of when it would actually be advisable to not include that line in a service file definition?
  4. Along the same lines, when is it a good idea to keep that line in?
29

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.

| improve this answer | |
  • 1
    This is a fantastically thorough answer. You even clarified why there are both Wants and WantedBy, which had always puzzled me as I couldn't figure out which I should use when. – Wildcard Mar 14 '19 at 23:12
  • 1
    It glosses over that WantedBy does nothing until you enable the service. Debian Linux based packages enable services automatically when you install them. But most Fedora based packages do not. And if you write your own service, it will not be automatically enabled. You have to run systemctl enable ... as a separate step. – sourcejedi Mar 14 '19 at 23:17
  • Good point - I thought I mentioned it, but apparently only in a negative sense. Edited. – telcoM Mar 15 '19 at 7:00
  • 1
    Cool! lots of good info here. "Note that a Wants or WantedBy only says that the system should startup one service whenever another service [edit:] or target is also started, but it specifies nothing at all about the startup/shutdown order." - unfortunately the edit is not quite right, it is more complicated. 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. – sourcejedi Mar 16 '19 at 14:04
  • Excellent answer – jonahb Mar 26 at 4:37
3

If you remove WantedBy=multi-user.target, then systemctl enable your-example-here will (noisily) fail to do anything.

graphical.target

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 :-).

sysinit.target

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.

multi-user.target

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 sshd.socket or ssh.socket is typically available to activate ssh@.service or 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.

| improve this answer | |
  • Thanks alot. where can I find names such as multi-user.target, sysinit.target I want to know what other options I have aside from these – Rika Mar 11 at 18:16
  • @Rika I'm not really sure what you're asking for. But it sounds more like a different question than a comment on this one. Try asking a new question? You could post a link to it here, if you want me to see it. I don't spend a lot of time on this site at the moment though. – sourcejedi Mar 11 at 18:19
0

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.

Explanation with Example

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

  1. Although it would not make sense from within this context, it would still work.
| improve this answer | |

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.