When working with Linux systems, you will often need to create, modify, or troubleshoot systemd unit files. Whether you're configuring a custom service, adjusting a systemd timer, or changing service dependencies, you need to ensure that systemd recognizes your changes.

This is where the systemctl daemon-reload command comes into play.

What Is systemctl daemon-reload?

systemctl daemon-reload is a Linux command that instructs the systemd manager to reload its unit configuration files. This allows systemd to recognize newly created, modified, or removed unit files and update its understanding of the system's configuration.

Systemd is the system and service manager used by many Linux distributions, including Ubuntu, Debian, Fedora, and Red Hat Enterprise Linux (RHEL).

It manages system services, mount points, timers, sockets, and other system resources through unit files.

Whenever you modify a systemd unit file, systemd does not automatically detect every change. Running daemon-reload ensures that the system manager rereads the unit files and updates its configuration accordingly.

How to Use systemctl daemon-reload

The command is straightforward:

$ sudo systemctl daemon-reload

Once executed, systemd reloads its unit definitions and rebuilds its dependency information.

Important: This command does not restart running services, stop processes, or reload application-specific configuration files.
It updates systemd's understanding of the unit files on disk.

When Should You Use systemctl daemon-reload?

You should run this command whenever you create, modify, or remove systemd unit files and want the system manager to recognize those changes.

Common scenarios include:

• Creating a new service: You have created a custom .service file and need systemd to recognize it.
• Modifying a service: You have changed directives such as ExecStart=, User=, Group=, or Restart=.
• Configuring a systemd timer: You have modified a .timer or its associated .service file.
• Changing dependencies: You have updated directives such as After=, Requires=, or Wants=.
• Removing a unit file: You want systemd to refresh its configuration after deleting a unit file.

For example, suppose you create a custom service named myapp.service in /etc/systemd/system/.

After saving the file, run:

$ sudo systemctl daemon-reload

Systemd can now recognize the new unit.

You can verify this by checking its status:

$ systemctl status myapp.service

If the service is not running yet, you can start it:

$ sudo systemctl start myapp.service

If you want it to start automatically during boot, enable it separately:

$ sudo systemctl enable myapp.service

Remember that recognizing a unit, starting a service, and enabling a service at boot are three different operations.

What Is the Difference Between daemon-reload, reload, and restart?

These commands serve different purposes, and understanding the distinction is essential for Linux system administration.

Consider a situation where you modify the ExecStart= directive in a service's unit file.

Running the following command makes systemd recognize the updated unit definition:

$ sudo systemctl daemon-reload

However, the currently running process does not automatically switch to the new command.
You will generally need to restart the service:

$ sudo systemctl restart myapp.service

On the other hand, if you change an application's configuration file rather than its systemd unit file, you generally do not need daemon-reload.
Instead, use the application's supported configuration-reload mechanism.

For example, after modifying an Nginx configuration file:

$ sudo nginx -t

$ sudo systemctl reload nginx.service

The first command validates the Nginx configuration, while the second asks Nginx to reload it.

Does systemctl daemon-reload Restart Running Services?

No. Running systemctl daemon-reload does not, by itself, restart or stop running services.

It instructs the systemd manager to reread unit files and update its internal configuration.

However, changes to a unit file may require additional action before they affect a running service.

For example, changing Restart=, User=, or ExecStart= does not automatically reconfigure an already running process. Depending on the directive, you may need to restart the service to apply the change.

This separation is particularly useful on production servers, where administrators may need systemd to recognize configuration changes without immediately interrupting running applications.

A Practical Example

Suppose you are running a custom Python application through a systemd service on Ubuntu.

Your unit file is located at:

/etc/systemd/system/myapp.service

You modify the service definition to change its execution command or environment variables.

A typical workflow would be:

Step 1: Edit the unit file.

$ sudo nano /etc/systemd/system/myapp.service

Step 2: Reload systemd's unit definitions.

$ sudo systemctl daemon-reload

Step 3: Restart the service to apply the relevant changes.

$ sudo systemctl restart myapp.service

Step 4: Verify that the service is running correctly.

$ sudo systemctl status myapp.service

Step 5: Inspect the service logs if necessary.

$ sudo journalctl -u myapp.service -n 50 --no-pager

This workflow ensures that systemd recognizes the updated unit file and that the application is restarted when necessary.

How Can You Verify That systemd Recognizes Your Changes?

After running daemon-reload, you can inspect the unit configuration that systemd has loaded.

For example:

$ systemctl cat myapp.service

This displays the unit file and any applicable drop-in configuration files.

To inspect a particular property, use:

$ systemctl show myapp.service -p ExecStart

This displays the ExecStart property as interpreted by systemd.

These commands are particularly useful when troubleshooting custom services or verifying changes on production systems.

The systemctl daemon-reload command is an essential tool for Linux system administrators working with systemd.
It ensures that systemd recognizes changes to unit files without automatically restarting running services. Whether you are creating custom services, configuring timers, or adjusting service dependencies, understanding when and why to use this command helps you manage Linux systems more reliably.

Remember: daemon-reload updates systemd's configuration, reload asks an application to reload its configuration, and restart starts the service again.
Understanding this distinction will help you troubleshoot systemd services and apply configuration changes with greater confidence.

Thank you for stopping by, and keep mastering Linux.