How to Create and Configure Custom Systemd Services on Linux

ByAkensai

Learning how to create and configure custom systemd services on Linux is essential for system administrators who need to manage custom applications and background processes. Systemd has become the standard init system for most modern Linux distributions, replacing traditional SysV init scripts. This tutorial will guide you through creating, configuring, and managing your own systemd service units from scratch.

Custom systemd services allow you to automatically start applications at boot time, restart them if they crash, and manage them using standard systemctl commands. Whether you’re running a web application, database service, or custom script, understanding systemd service creation gives you complete control over your system’s processes.

By the end of this guide, you’ll know how to write service unit files, configure service dependencies, set up automatic restarts, and troubleshoot common issues. You’ll also learn best practices for service security and resource management.

Prerequisites and Requirements for Creating Custom Systemd Services

Before diving into how to create and configure custom systemd services on Linux, ensure you have the following prerequisites:

You need root or sudo access on a Linux system running systemd. Most modern distributions like Ubuntu 16.04+, CentOS 7+, Debian 8+, and Fedora use systemd by default. You can verify systemd is running with systemctl --version.

Basic knowledge of Linux command line operations is required. You should be comfortable editing files with text editors like nano or vim, understanding file permissions, and navigating the filesystem.

You’ll need an application or script to manage as a service. This could be a Python script, Node.js application, or any executable program. For this tutorial, we’ll create a simple example script to demonstrate the concepts.

The estimated time to complete this tutorial is 30-45 minutes, depending on your familiarity with Linux systems. Have a text editor ready and ensure you can access the official systemd documentation for reference.

Step-by-Step Guide to Creating Custom Systemd Services on Linux

Another fascinating historical case is: How to Set Up Headless Wordpress with Next.js and Wpgraphql in 2026

Let’s walk through the complete process of creating a custom systemd service from start to finish.

Step 1: Create Your Application or Script

First, create a simple application that will run as a service. We’ll create a Python script that writes timestamps to a log file:

sudo mkdir -p /opt/myapp
sudo nano /opt/myapp/myservice.py

Add the following content to the script:

#!/usr/bin/env python3
import time
import datetime
import os

log_file = "/var/log/myservice.log"

while True:
    with open(log_file, "a") as f:
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        f.write(f"{timestamp} - MyService is runningn")
    time.sleep(30)

Make the script executable:

sudo chmod +x /opt/myapp/myservice.py

Step 2: Create the Systemd Service Unit File

Systemd service files are stored in /etc/systemd/system/ for custom services. Create your service file:

sudo nano /etc/systemd/system/myservice.service

Add the following configuration:

[Unit]
Description=My Custom Service
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
Restart=always
RestartSec=1
User=nobody
ExecStart=/opt/myapp/myservice.py
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=myservice

[Install]
WantedBy=multi-user.target

Step 3: Configure Service Permissions and Security

Create a dedicated user for better security (optional but recommended):

sudo useradd --system --no-create-home --shell /bin/false myservice
sudo chown -R myservice:myservice /opt/myapp

Update the service file to use the new user:

sudo nano /etc/systemd/system/myservice.service

Change the User line to:

User=myservice

Ensure the log file is accessible:

sudo touch /var/log/myservice.log
sudo chown myservice:myservice /var/log/myservice.log

Step 4: Reload Systemd and Enable the Service

After creating or modifying service files, reload systemd’s configuration:

sudo systemctl daemon-reload

Enable the service to start automatically at boot:

sudo systemctl enable myservice.service

Step 5: Start and Test Your Service

Start your custom service:

sudo systemctl start myservice.service

Check the service status:

sudo systemctl status myservice.service

You should see output indicating the service is active and running. View the logs to confirm it’s working:

sudo tail -f /var/log/myservice.log

Step 6: Configure Advanced Service Options

For production services, you might want additional configuration. Edit your service file to include resource limits and dependencies:

sudo nano /etc/systemd/system/myservice.service

Add these options under the [Service] section:

[Service]
Type=simple
Restart=always
RestartSec=5
User=myservice
ExecStart=/opt/myapp/myservice.py
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=myservice

# Resource limits
MemoryLimit=100M
CPUQuota=50%

# Security settings
NoNewPrivileges=yes
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/var/log

Reload and restart the service to apply changes:

sudo systemctl daemon-reload
sudo systemctl restart myservice.service

Troubleshooting Common Systemd Service Configuration Issues

When working with custom systemd services, you’ll encounter various issues. Here are the most common problems and their solutions.

Service Fails to Start

If your service won’t start, check the detailed status and logs:

sudo systemctl status myservice.service -l
sudo journalctl -u myservice.service -f

Common causes include incorrect file paths, permission issues, or syntax errors in your service file. Verify your ExecStart path is correct and the file is executable.

Permission Denied Errors

If you see permission errors, ensure the service user has access to all required files and directories:

sudo chown -R myservice:myservice /opt/myapp
sudo chmod +x /opt/myapp/myservice.py

For log files, make sure the service user can write to the log directory:

sudo chown myservice:myservice /var/log/myservice.log

Service Starts But Stops Immediately

This usually indicates your application exits quickly. Check if your script has an infinite loop or long-running process. For scripts that run once and exit, use Type=oneshot instead of Type=simple.

Environment Variables Not Available

If your service needs environment variables, add them to the service file:

[Service]
Environment=PATH=/usr/local/bin:/usr/bin:/bin
Environment=PYTHONPATH=/opt/myapp
EnvironmentFile=-/etc/default/myservice

You can also create an environment file at /etc/default/myservice with your variables.

Service Won’t Enable at Boot

If systemctl enable fails, check that your service file has the correct [Install] section and that you’ve run daemon-reload after making changes.

For additional troubleshooting resources, consult the comprehensive systemd guide which covers advanced configuration scenarios.

Managing and Monitoring Your Custom Services

Once your service is running, you’ll need to manage and monitor it effectively. Use these essential systemctl commands for service management:

Check service status and recent logs:

sudo systemctl status myservice.service
sudo journalctl -u myservice.service --since "1 hour ago"

Stop, start, and restart services:

sudo systemctl stop myservice.service
sudo systemctl start myservice.service
sudo systemctl restart myservice.service

View real-time logs:

sudo journalctl -u myservice.service -f

For services that need configuration updates, always reload systemd after editing service files:

sudo systemctl daemon-reload
sudo systemctl restart myservice.service

Monitor resource usage with systemctl:

sudo systemctl show myservice.service --property=MemoryCurrent
sudo systemctl show myservice.service --property=CPUUsageNSec

Set up log rotation for services that generate large log files. Create a logrotate configuration:

sudo nano /etc/logrotate.d/myservice

Add the following 

/var/log/myservice.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
    postrotate
        systemctl reload myservice.service
    endscript
}

For production environments, consider using monitoring tools like Prometheus or Nag

Similar Posts