Managing Processes and Services in Ubuntu: Using ps, top, htop, and systemd

When it comes to advanced system administration, managing processes and services is one of the most important skills. Processes are programs that run on your Ubuntu system, and services (also called daemons) are background processes that typically start when your system boots and continue running to provide essential functions, such as handling network requests, managing databases, or serving web pages.

In this post, we'll cover how to monitor and manage system processes and services using a variety of tools available in Ubuntu, including ps, top, htop, and systemd. By the end of this post, you'll be equipped to track, control, and optimize system resources to keep your Ubuntu system running smoothly.

1. Introduction to Processes and Services

A process is an instance of a program running on your computer. Each process has a unique ID, known as the PID (Process ID). Processes can be user-initiated (e.g., running a web browser or text editor) or system-initiated (e.g., running system services in the background). Processes can also be foreground or background, where foreground processes are directly tied to the terminal and background processes run independently.

Services, on the other hand, are long-running background processes that usually start automatically when the system boots. Common examples of services include:

• Web servers (like Apache or Nginx)
• Database servers (like MySQL or PostgreSQL)
• Network daemons (like OpenSSH or DHCP)

Managing these processes and services effectively ensures your system performs well and stays responsive to user or system requests.

2. Monitoring Processes with ps

The ps command (short for "process status") is a powerful tool to view details of running processes on your system. While it doesn't offer real-time monitoring, it's useful for obtaining a snapshot of the current processes and gathering information about individual processes.

Basic Usage:

ps aux

This command lists all running processes in a user-friendly format. Let's break down what ps aux does:

• a: Shows processes for all users, not just your own.
• u: Displays detailed user-oriented information (e.g., the user who started the process).
• x: Includes processes that are not attached to a terminal (i.e., background services).

Here's an example output:

USER      PID  %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root        1  0.0  0.1  164280  12872 ?       Ss   10:23   0:02 /sbin/init
john      123  0.1  1.2  288532 25748 ?       Ssl  10:24   0:08 /usr/lib/gnome-session
john      543  0.5  2.4  785668 50812 tty2    R+   10:30   0:15 /usr/bin/firefox

Explanation of key columns:

• USER: The user that owns the process.
• PID: The unique Process ID.
• %CPU: The percentage of CPU time used by the process.
• %MEM: The percentage of memory used by the process.
• VSZ: The virtual memory size in kilobytes.
• RSS: The amount of memory currently used by the process (resident set size).
• TTY: The terminal associated with the process (if any).
• STAT: The current status of the process (e.g., R for running, S for sleeping).
• START: The time when the process started.
• TIME: The amount of CPU time consumed by the process.
• COMMAND: The command that started the process.

You can also filter specific processes by user, PID, or process name:

To filter by process name:

ps -C firefox

To filter processes by username:

ps -u john

3. Real-Time Monitoring with top

The top command provides real-time monitoring of system processes, dynamically updating the list of running processes and showing which processes are consuming the most resources.

To start top, simply run:

top

You'll be presented with a continuously updating list of processes, along with system-wide statistics such as CPU usage, memory usage, and load averages.

Here’s a breakdown of the key sections in top:

• Tasks: The number of running, sleeping, or stopped processes.
• CPU usage: Displays the percentage of CPU time used by user processes, system processes, idle time, and more.
• Memory and Swap usage: Shows the total, used, and free memory, as well as swap space.
• Process list: A dynamic list of processes ordered by CPU usage by default, but you can change the sorting.

Useful top keyboard shortcuts:

• k: Kill a process by entering its PID.
• P: Sort processes by CPU usage.
• M: Sort processes by memory usage.
• q: Quit top.

4. Enhanced Process Monitoring with htop

While top provides great real-time monitoring, many users prefer htop because of its improved interface, color coding, and ease of use.

Installing htop:

sudo apt install htop

To start htop, run:

htop

The htop interface is similar to top, but it provides more information at a glance, better color-coding, and an intuitive user interface. It also allows you to navigate the process list using arrow keys and filter or search for processes interactively.

Key advantages of htop over top:

• Visual representation of CPU and memory usage with color bars.
• Easy-to-use navigation with arrow keys.
• Filtering and searching for specific processes (/ to search).
• Tree view of processes to see parent-child relationships (F5 to enable).

5. Managing Services with systemd

systemd is the system and service manager for Ubuntu and most other modern Linux distributions. It controls how services are started, stopped, and managed, and it plays a central role in booting the system. Understanding systemd is essential for managing services and ensuring that they run reliably.

systemd uses "units" to manage services. A unit file describes how a service should be started, what dependencies it has, and how it should behave. The most common type of unit is a service unit (with a .service extension).

6. Starting, Stopping, and Restarting Services

The following commands allow you to manage services with systemd:

Check the status of a service:

sudo systemctl status <service_name>

Example output:

● apache2.service - The Apache HTTP Server
   Loaded: loaded (/lib/systemd/system/apache2.service; enabled; vendor preset: enabled)
   Active: active (running) since Fri 2024-09-25 10:34:19 UTC; 1h 24min ago
     Docs: https://httpd.apache.org/docs/2.4/

Restart a service:

sudo systemctl restart <service_name>

Stop a service:

sudo systemctl stop <service_name>

Start a service:

sudo systemctl start <service_name>

Example:

sudo systemctl start apache2

This tells you whether the service is running, loaded, and enabled.

7. Enabling and Disabling Services on Boot

systemd allows you to configure whether services start automatically when the system boots.

Disable a service from starting on boot:

sudo systemctl disable <service_name>

Enable a service to start on boot:

sudo systemctl enable <service_name>

For example, to enable the Apache web server to start on boot:

sudo systemctl enable apache2

8. Using journalctl for Service Logs

systemd uses journald for logging. You can view service logs using the journalctl command.

To view logs for a specific service:

sudo journalctl -u <service_name>

To view all logs:

sudo journalctl

For example, to view logs for the apache2 service:

sudo journalctl -u apache2

To view the most recent logs and follow new log entries in real-time, use the -f flag (similar to tail -f):

sudo journalctl -f -u apache2

9. Killing or Stopping Processes

Sometimes a process becomes unresponsive or consumes too many resources, and you need to stop it manually.

You can kill a process using its PID:

Kill a process:

sudo kill <PID>

If a process does not terminate gracefully, you can forcefully kill it using the -9 signal:

sudo kill -9 <PID>

You can also use htop or top to interactively kill processes.

10. Best Practices for Process and Service Management

• Monitor system resources regularly: Use tools like top, htop, and ps to keep track of resource usage. This will help you catch issues early.
• Automate service management: Use systemctl to enable and manage services automatically on boot.
• Limit resource-hungry processes: Use resource limits (ulimit or cgroups) to prevent individual processes from consuming excessive resources.
• Check logs regularly: Use journalctl to monitor service logs for potential errors or warnings.
• Use nice and renice to prioritize processes: You can adjust the priority of processes using nice and renice, which allows you to allocate CPU time more effectively.

Conclusion

Managing processes and services effectively is a key aspect of advanced Ubuntu system administration. By using tools like ps, top, htop, and systemd, you can monitor system performance, troubleshoot problems, and control the behavior of system services. In this guide, we covered how to monitor processes, manage services, and take control of how your system operates.

With this knowledge, you can confidently ensure that your system remains stable, responsive, and secure.