Systemd vs. Docker: Exploring a Surprising Alternative

What is Docker?

Docker is a platform that allows you to build, run, and manage containers. Containers are like lightweight virtual machines, but they don't emulate the entire operating system. Instead, they provide a sandboxed environment that mimics a virtual machine, allowing you to isolate and run applications with their dependencies in a consistent environment, regardless of the underlying host system.

What is Systemd?

Systemd is an init system and a process manager for Linux. It’s responsible for bootstrapping the user space and managing system processes, including services that run in the background. Systemd can be used to start, stop, and manage processes and services, and it integrates deeply with the operating system.

Why This Article?

At first glance, Docker and Systemd may seem like two very different tools, but both are used to manage the execution of applications. Docker is often used to run applications in isolated containers, while Systemd is traditionally used to manage services that run directly on the host operating system. In this article, we’ll compare these two approaches by setting up Pocketbase, a lightweight backend server, in both environments: one using Docker and the other using Systemd to run it as a regular process.

We'll explore the differences in setup, management, and performance of both approaches and discuss when you might prefer one over the other.

Prerequisites:

Before we begin, make sure you have the following:

1. A Linux-based system (Ubuntu, CentOS, Debian, etc.).


2. Docker installed, if you want to run the application in a container.


3. Basic knowledge of the command line.


4. The Pocketbase binary. Find the right one for your machine here.

Running Pocketbase in Docker

First, let's look at how to run Pocketbase using Docker. Docker makes it simple to get Pocketbase up and running quickly by encapsulating the application and all its dependencies within a container. Here’s how you would run Pocketbase in Docker:

docker run -d -p 8090:8090 -v ~/pocketbase_data:/pocketbase pocketbase/pocketbase

Explanation:

• 
  -d: Runs the container in detached mode.


• 
  -p 8090:8090: Maps port 8090 on the host to port 8090 in the container.


• 
  -v ~/pocketbase_data:/pocketbase: Mounts the local directory ~/pocketbase_data to /pocketbase inside the container to persist data.


• 
  pocketbase/pocketbase: Specifies the Pocketbase image to run.

With Docker, you get a clean, isolated environment, and managing the application is as simple as running or stopping the container. Docker also ensures that your Pocketbase instance runs in a consistent environment, regardless of what system it’s on.

Running Pocketbase with Systemd

Now, let’s look at how we can run Pocketbase as a regular process using Systemd. With Systemd, you will be directly managing the Pocketbase process, and it will be tied to the underlying system, rather than running in a container. Here’s how to do it:

1. 
   Create a Systemd Service File
   

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

1. 
   Add the following content to the file:
   

[Unit]

Description=Pocketbase Application

After=network.target



[Service]

ExecStart=/usr/local/bin/pocketbase serve --http=0.0.0.0:8090

WorkingDirectory=/home/yourusername/pocketbase

Restart=always

User=yourusername

Group=yourgroup



[Install]

WantedBy=multi-user.target

1. 
   Reload Systemd and Start the Service:
   

sudo systemctl daemon-reload

sudo systemctl start pocketbase

sudo systemctl enable pocketbase

Explanation:

• 
  ExecStart: Specifies the command to run Pocketbase.


• 
  WorkingDirectory: Sets the directory where Pocketbase will run (you can adjust this to your Pocketbase installation path).


• 
  Restart=always: Ensures that the process is restarted if it crashes.


• 
  User and Group: Specifies the user and group that should run the process.

With Systemd, you manage the Pocketbase process like any other system service. You can control it using standard Systemd commands like start, stop, restart, and status.

Comparison: Docker vs. Systemd

• 
  

  Ease of Setup:

  
  
  
  
  
  • Docker offers a more streamlined setup with fewer dependencies since it isolates the application within a container. It’s a great choice if you need a quick, portable solution that works across different environments.
  
  
  • Systemd requires setting up a service file, managing dependencies, and ensuring the application runs directly on the system. It's a more manual process but offers deeper integration with the host OS.
  
  
  
  
  
  



• 
  
  

  Isolation:

  
  
  
  
  
  • Docker provides full isolation for the application, meaning it runs in a self-contained environment. This is especially useful when you want to avoid conflicts with other applications or dependencies on your system.
  
  
  • Systemd runs the application directly on the system, which can lead to potential conflicts with other system services if not properly managed, but it allows for better integration with the system’s process management.
  
  
  
  
  
  



• 
  
  

  Management and Monitoring:

  
  
  
  
  
  • Docker simplifies management by encapsulating all the application dependencies within the container. You can easily stop, restart, or scale the application by interacting with the Docker container.
  
  
  • Systemd gives you more control over how the process interacts with the system. You can manage logging, resource allocation, and service dependencies more granularly with Systemd.
  
  
  
  
  
  



• 
  
  

  Performance:

  
  
  
  
  
  • Docker adds a small overhead due to containerization, though the performance difference is usually negligible for most applications.
  
  
  • Systemd typically offers better performance for long-running processes since there’s no container overhead, and it runs natively on the host system.
  
  
  
  
  
  

Conclusion

In this article, we’ve explored two different methods for running Pocketbase: inside a Docker container and as a regular process managed by Systemd. Docker is ideal for creating isolated environments and easily managing dependencies, while Systemd gives you more control and deeper integration with the host system.

Which method you choose depends on your needs. If portability and isolation are key, Docker might be the better choice. If you prefer direct integration with the operating system and need more control over service management, Systemd is a great option. Both approaches have their strengths, and understanding them can help you make the right decision for your application deployment.