This article explores three frequently used Ansible modules—yum_repository, yum, and systemd—detailing their parameters, usage examples, and practical commands to streamline package management and service control, helping DevOps engineers boost automation efficiency in cloud and container environments.
This guide explains how systemd’s multi‑instance (template) services work, shows how to configure and manage them with concrete examples such as OpenVPN client instances, and highlights their core features, practical steps, logging, typical scenarios, and advantages for Linux administrators.
This guide walks through Linux logging fundamentals, covering rsyslog service architecture, journald configuration, and logrotate management, while showing how to customize log destinations, use selectors and actions, forward logs over the network, and employ systemd timers for automated rotation.
A recent incident with systemd‑tmpfiles – triggered by the ‑‑purge option in version 256 – caused unexpected deletion of files in /home, prompting a heated discussion among developers, a GitHub issue, and a rapid patch that clarified the command’s scope and added safeguards.
This guide walks you through checking the current partition layout, safely unmounting the volume, using fdisk to delete and recreate the partition with the same start sector, resizing the ext4 filesystem, remounting the disk, and configuring automatic mounts via fstab, systemd, or autofs.
This guide introduces Gitea—a Go‑based, open‑source Git service—covers its core features, compares it with GitLab and GitHub, and provides step‑by‑step instructions for binary installation, systemd service setup, Nginx reverse‑proxy configuration, and basic repository usage on Linux.
This guide walks you through expanding a Linux block device from 500 GB to 2 TB, adjusting the partition table with fdisk, resizing ext4 filesystems, remounting the volume, and configuring persistent or on‑demand mounts via fstab, rc.local, systemd, and autofs.
A Linux user’s attempt to clean /var/tmp with systemd‑tmpfiles --purge unintentionally deleted files in /home, exposing a documentation gap and prompting a GitHub discussion that led to clearer warnings and a protective pull request to prevent future data loss.
Linux 6.10 adds a new DRM Panic infrastructure that displays a blue‑screen‑of‑death style message on kernel crashes, supporting drivers like SimpleDRM, MGAG200, IMX and AST, while systemd‑255 introduces an experimental systemd‑bsod component for emergency error reporting.
Linux 6.10 adds a new DRM Panic infrastructure that displays a BSOD‑style screen on kernel crashes, supporting drivers like SimpleDRM, MGAG200, IMX and AST, while systemd‑255 introduces an experimental systemd‑bsod component for full‑screen emergency messages, offering a clearer way to diagnose panics.
This guide explains how to use the journalctl command to view, filter, and manage systemd-journald logs on Linux, covering help options, match expressions, persistent storage, disk usage, vacuuming, time ranges, unit filtering, priority levels, real‑time streaming, output formatting, and kernel log access.
This article demonstrates three methods for sending logs to the systemd journal—using the libc syslog() function, capturing stdout/stderr via printf(), and employing the native systemd sd_journal API—complete with C, Python, and Bash examples, service setup, and log filtering techniques.
This tutorial walks you through expanding a Linux disk from 500 GB to 2 TB using fdisk, resizing the ext4 filesystem with resize2fs, remounting the partition, and configuring persistent auto‑mounts via /etc/fstab, rc.local, systemd, or autofs, while also covering common error fixes.
This guide explains how to enable Linux components to start automatically at boot using systemd's systemctl commands, the legacy chkconfig tool, generic rc scripts, and crontab's @reboot syntax, and offers recommendations for production environments.
This guide walks through importing a CentOS 7 virtual machine in VMware, configuring network settings (dynamic or static IP), resolving common issues, then installing and configuring JDK 1.8, MySQL 5.7, and Tomcat 8.5, and finally creating systemd services for automatic startup of Java applications.
This article analyzes an intermittent failure where a MySQL instance managed by systemd in forking mode hangs because an automated test prematurely kills the newly created mysqld process, leading to a missing MAIN PID and a zombie process, and provides investigation steps and a practical fix.
This guide explains how to configure Linux services and applications to start automatically at boot using systemd (systemctl), legacy chkconfig, custom startup scripts, and crontab special keywords, offering practical commands, examples, and production‑grade recommendations for reliable operations.
This guide details how to configure Linux services to start on boot using systemd (systemctl), legacy SysV init (chkconfig), generic startup scripts, and crontab @reboot, and offers best‑practice recommendations for production environments.
This guide provides a comprehensive overview of the systemctl command, covering its basic operations like starting, stopping, restarting, reloading, and checking service status, as well as common options, practical examples, and advanced usage such as user services, remote execution, custom configurations, and pre/post execution hooks.
This guide explains how to create custom systemd service unit files, configure permissions, environment variables, logging, and resource limits, and shows how to start, stop, and monitor services using systemctl, with detailed examples and advanced options for Linux administrators.
This guide explains how to configure Linux resource limits using /etc/security/limits.conf, the limits.d directory, ulimit commands, and systemd unit files, covering syntax, override rules, common pitfalls, and practical examples for both temporary and permanent settings.
This guide explains how to enable systemd in WSL, configure /etc/wsl.conf, and install the Linux‑native Docker engine on Ubuntu within Windows, highlighting the benefits for container‑based development and Microsoft’s effort to improve cross‑platform tooling.
This tutorial walks through importing a CentOS7 virtual machine into VMware, configuring static or dynamic IP settings, installing JDK 1.8, setting up MySQL 5.7 with remote access, and deploying Tomcat 8.5 and a Spring Boot service for automatic startup, including common pitfalls and fixes.
This comprehensive guide walks through essential Linux administration techniques, including Bash scripts for summing user IDs, array and string manipulation, advanced variable usage, random number analysis, factorial recursion, process and thread concepts, job control, kernel design models, boot and GRUB workflows, service management with chkconfig and systemd, as well as CA creation, certificate handling, encryption fundamentals, and OpenSSH key‑based authentication.
This article provides a comprehensive guide to five methods for running Python scripts in the background on Linux, covering nohup with &, screen sessions, systemd services, Celery task queues, and supervisord, including command examples and configuration steps.
Systemd v255 introduces an experimental component called systemd‑bsod that displays a Windows‑style blue‑screen error page and QR code on Linux when a fatal startup failure occurs, aiming to make crash diagnostics clearer for users, especially newcomers.
This article explains three common Linux startup methods—traditional /etc/rc.local, legacy SysVinit scripts in /etc/init.d/, and the modern systemd unit system—detailing their roles, execution contexts, and how systemd has largely replaced older approaches.
This guide walks through installing the lightweight HFS HTTP file server on Ubuntu 22.04, creating a shared directory, configuring the binary, setting up port and admin access, and optionally configuring it as a systemd daemon with Node.js support for full background operation.
This guide walks through installing HFS on Ubuntu 22.04, creating a shared HTTP directory, configuring the server both as a regular process and as a systemd daemon, and accessing the shared folder via a web browser.
nginxWebUI is a web‑based graphical interface that simplifies configuring, managing, and deploying Nginx across single or multiple servers, offering HTTP/TCP forwarding, reverse proxy, load balancing, SSL automation, Docker support, systemd service setup, and detailed command‑line installation instructions.
This article explains Linux cgroups—how they group processes, limit and account for CPU, memory, and I/O usage, the differences between cgroup v1 and v2, key concepts like subsystems and hierarchies, and practical commands and configuration steps for managing resources with systemd and the command line.
This article explains common reasons why PHP-FPM processes may terminate unexpectedly and provides step‑by‑step instructions for configuring systemd and Supervisor to supervise PHP‑FPM, ensuring continuous and reliable operation on Linux servers.
This article explains the Linux firewall architecture, compares iptables and firewalld, details the netfilter chain and table model, and provides practical commands and examples for configuring, managing, and troubleshooting firewall rules on RHEL systems.
This article provides a comprehensive overview of Linux cgroups, explaining their purpose, architecture, versions, subsystems, and practical usage with systemd, including installation, configuration files, command‑line tools, and methods to monitor and limit CPU, memory, and I/O resources for containers and services.
This step‑by‑step guide shows how to prepare an Ubuntu 16.04 system, install all required dependencies, download OpenResty and its optional modules, configure the build with performance‑focused options, compile, install, set environment variables, and create a systemd service for automatic startup.
This tutorial walks you through creating a minimal Linux VM in VirtualBox, adding four virtual disks, formatting and mounting them, and then installing and configuring MinIO in a single‑node multi‑drive setup using systemd, complete with verification commands and screenshots.
The article investigates why a MySQL‑slave machine shows low free memory despite modest MySQL and Redis usage, revealing that massive hidden files under /run/systemd/users and tmpfs‑based shared memory consume several gigabytes, and proposes practical remediation steps.
nginxWebUI provides a graphical interface for configuring and managing Nginx, supporting HTTP/TCP forwarding, reverse proxy, load balancing, SSL automation, multi‑server clustering, Docker deployment, systemd startup, and detailed usage instructions, enabling administrators to generate and control nginx.conf without manual coding.
This article explains Linux cgroups, why they are essential for containerization, their architecture, subsystems, and practical commands for viewing, configuring, and limiting CPU, memory, and I/O resources using systemd and the cgroup filesystem.
This guide explains the advantages of cgroup v2 over v1, outlines the Linux distribution and kernel requirements, and provides detailed, command‑line instructions for enabling cgroup v2 on Debian, configuring kubelet and containerd, and updating monitoring tools for Kubernetes clusters.
This guide provides a comprehensive walkthrough of nginxWebUI—a graphical web interface for configuring and controlling Nginx—including feature overview, installation via JAR or Docker, systemd service setup, command‑line options, SSL automation, backup management, API usage, and password recovery.
This guide walks through the four essential stages of a Linux system’s startup—BIOS POST, the GRUB2 bootloader, kernel initialization, and systemd—explaining each step, the commands used to inspect targets, and how the process culminates in the user login prompt.
This guide explains how to turn a low‑cost Raspberry Pi into a Wi‑Fi hotspot, DHCP/DNS server, and offline PyPI mirror using minirepo, pypiserver, and nginx, enabling client devices to install Python packages without Internet access.
This guide explains what systemd is, its key advantages over traditional init, the basic systemctl syntax, how unit files are structured, and provides step‑by‑step examples for creating systemd services to manage Nginx, Tomcat, and a custom Java JAR application on CentOS 7 and similar Linux distributions.
Linux cgroups, a kernel mechanism for grouping and controlling processes, enable fine-grained resource allocation, monitoring, and isolation, forming the foundation of container technologies like Docker and Kubernetes; this guide explains their concepts, hierarchies, subsystems, versions, configuration, and practical usage on CentOS.
This guide explains why continuous Linux logging wears out SSDs, how Log2Ram redirects logs to RAM, and provides step‑by‑step commands to install, configure, and verify Log2Ram, helping you prolong disk lifespan while maintaining system diagnostics.
This article explains what cgroups, cgroupfs, and systemd are, compares their use in container runtimes, and provides step‑by‑step instructions for switching Docker’s default cgroup driver to systemd and configuring kubelet accordingly.
Kubernetes 1.25 officially ships cgroup v2 support, enabling the kubelet to leverage the latest Linux resource‑management features, and the article explains what cgroups are, the advantages of v2, how to enable it, migration considerations, and where to learn more.
This tutorial explains how to configure Docker on a Kubernetes node to transparently use a remote Docker daemon by modifying the systemd service, creating a custom Docker image with helper scripts, and committing it, so users can run Docker commands without explicitly specifying the remote host.
This article introduces systemd, explains its advantages over init, details unit concepts and key commands, outlines configuration file structures, and provides three hands‑on examples—managing Nginx, Tomcat, and a custom Java JAR service—demonstrating practical systemd usage on CentOS 7.
This guide explains how to install Fluentd via Docker or manual methods, configure the environment (NTP, file descriptors, kernel parameters), use the td-agent package, manage services with systemd, send test logs, and understand Fluentd's event lifecycle, filters, labels, and configuration directives.
This article introduces systemd, explains its features and unit file syntax, and provides step‑by‑step practical examples for managing Nginx, Tomcat, and custom Java JAR services with systemd on modern Linux distributions.
Microsoft researchers uncovered the Nimbuspwn vulnerability in systemd’s networkd-dispatcher, detailing how directory‑traversal, symlink‑race, and TOCTOU flaws let attackers replace root‑owned scripts, achieve privilege escalation, and why coordinated patching across hundreds of Linux distributions is critical.
This article shows how system administrators can use the systemd‑analyze tool to measure boot and startup times, identify slow services, visualize the critical chain, dump system state, generate SVG plots, test unit conditions, inspect configuration files, verify syntax, and assess security settings on a Linux workstation.
This guide introduces systemd, explains its key features and unit file syntax, and provides three hands‑on examples showing how to manage Nginx, Tomcat, and a custom JAR application with systemd on modern Linux distributions.
This Bash script automates the installation of GCC 11.2.0 and Redis 6.2.6 on a Linux system, configures Redis settings, creates a systemd service unit, and starts the Redis service, providing a reproducible setup procedure for developers and system administrators.
This guide walks through installing the Go‑based Node Exporter, configuring it as a systemd service or Docker container, exposing standard Prometheus metrics, and using PromQL to calculate CPU usage across multiple nodes.
This article explains the role of the Pod Lifecycle Event Generator (PLEG) in Kubelet, why the “PLEG is not healthy” error causes nodes to become NotReady, common failure scenarios, and a step‑by‑step troubleshooting method that ultimately resolves the issue by upgrading systemd.
This article presents a systematic investigation of MySQL's open_files_limit setting across three scenarios—conflict between my.cnf and systemd service, effectiveness when using mysqld_safe, and the impact of Docker's own limits—revealing which source actually controls the maximum number of open files.
The article explains how the MySQL "Can't create a new thread (errno 11)" error on SLES12SP5 was diagnosed as a TaskMax limit issue and resolved by increasing the system‑wide DefaultTasksMax or setting a per‑service TasksMax, followed by a MySQL restart to apply the changes.
Learn how to replace manual rc.local startup scripts with elegant solutions using Crontab's @reboot feature and Systemd services, including step‑by‑step commands and advanced scheduling tricks for reliable automatic execution after a reboot.
This guide walks through downloading the Docker 20.10.7 offline package, extracting it on a CentOS 7 host, configuring a systemd service, starting Docker, verifying the installation, and then fully removing Docker and its service files when needed.
This guide explains three methods to automatically execute scripts after a Linux system boots—using the traditional /etc/rc.local approach, the @reboot option in crontab, and creating a dedicated Systemd service—providing step‑by‑step commands and examples for each technique.
This guide shows three reliable ways to run custom scripts automatically after a Linux machine boots—by editing /etc/rc.local, using a crontab @reboot entry, or creating a dedicated systemd service—along with example commands and advanced timing options.
This article introduces systemd as the modern Linux service manager, explains its key features and unit file syntax, and provides step‑by‑step practical examples for controlling Nginx, Tomcat, and custom Java JAR applications with systemd commands.
This article introduces systemd as the modern Linux init replacement, explains its key features and unit file syntax, and provides three hands‑on examples showing how to manage nginx, Tomcat, and a custom JAR service with systemd commands and configuration files.
This comprehensive guide walks you through installing Nginx from source, configuring global settings, mastering common directives, enabling gzip compression, setting up reverse and forward proxies, load balancing, SSL, systemd service management, and troubleshooting, providing ready-to-use code snippets and practical examples for server administrators.
This guide explains how autossh automates SSH connections, provides reliable reverse and dynamic port forwarding, details installation steps, command‑line options, practical examples, and system‑level startup configuration for robust network tunneling.
When the root partition is too small for Docker's default storage at /var/lib/docker, you can reclaim space by moving the directory to a larger disk and updating Docker's storage path via symbolic links, daemon options, or systemd drop‑in files, ensuring the service continues to run smoothly.
This guide introduces systemd, explains its advantages over init, details unit concepts, command syntax, configuration files, and demonstrates practical setups for managing Nginx, Tomcat, and custom Java JAR services on CentOS 7, including installation, service files, and control commands.
This guide explains why static entries in /etc/fstab can waste resources, introduces the autofs daemon for dynamic mounting, and provides step‑by‑step commands to install, configure, and test autofs so that filesystems are mounted only when accessed.
This guide introduces systemd, explains its key features and unit file syntax, compares it with legacy init, and provides three hands‑on examples—setting up nginx, Tomcat, and a Java JAR—showing how to create, enable, and control services with systemctl on CentOS 7.
This guide walks you through using the systemctl tool on modern Linux distributions to start, stop, restart, reload, enable, disable, and query services, manage system power, work with targets, handle remote hosts, and leverage related utilities like journalctl, systemd-analyze, and hostnamectl.
This guide walks through installing Gogs, creating a start‑up script, configuring a systemd service, launching the server, checking its status, creating repositories via the web UI or command line, and pushing code with saved credentials, all on a Linux host.
Learn how to install Cntlm on Debian‑based Linux or Windows, configure its authentication and proxy settings, obtain NTLM hashes, and apply changes by reloading or restarting the systemd service, enabling secure multi‑user HTTP proxy access within restricted networks.
This guide explains practical techniques and command‑line tools—such as systemd‑detect‑virt, cgroup inspection, DMI data, and cloud‑provider metadata—to determine whether a given shell environment is running inside a container, a virtual machine, or on bare‑metal hardware, including scripts for Docker, rkt, AWS, OpenStack and more.
This tutorial walks through configuring three servers, generating CA and component certificates with cfssl, deploying an etcd cluster, installing Docker, creating Kubernetes API server, controller‑manager and scheduler configurations, setting up systemd services, and verifying the health of the high‑availability Kubernetes cluster.
This guide explains how to batch‑install Docker on Linux servers by creating a deployment directory, writing an Ansible playbook that unpacks the Docker binary, copies the service file, configures systemd, and verifies the installation with Docker commands.
This article explains how to set up frp, a high-performance reverse-proxy written in Go, to expose internal web and SSH services to the public Internet using domain-based virtual hosts, nginx reverse-proxy, and systemd on CentOS, complete with configuration examples and firewall considerations.
This guide explains Linux runlevels, essential systemctl commands, key service directories, and walks through creating an additional SSH service and a custom shell‑based service using systemd, complete with step‑by‑step commands and example unit files.
This guide explains how to set up HTTP/HTTPS proxy environment variables for the Docker daemon via systemd, configure per‑container proxy settings through the Docker client config.json, and pass proxy arguments during docker build, including special considerations for network isolation and host mode.
This guide explains how to configure HTTP/HTTPS proxies for Docker's daemon via systemd, set per‑container proxy settings through the Docker config file, and pass proxy arguments during image builds, covering common pitfalls and network isolation considerations.
This guide explains how to use systemctl and journalctl on CentOS 7 to list services that failed to start, check individual service status, interpret error messages, and filter logs for troubleshooting, providing concrete command examples and output analysis.
This article explains how to modify systemd unit files or use systemctl commands to set resource isolation parameters such as CPUQuota and MemoryLimit, demonstrates the changes with a MySQL CPU‑usage experiment, and describes the underlying cgroup and systemd mechanisms on Linux 7.
This guide shows three practical ways to execute custom scripts automatically after a Linux system starts—by editing /etc/rc.d/rc.local, configuring a crontab @reboot entry, or creating a systemd service—complete with commands, sample scripts, and troubleshooting tips.
This article explains ETCD's role as a distributed key‑value store, details its architecture and leader election mechanism, provides step‑by‑step cluster deployment on CentOS with systemd, and demonstrates a Go implementation of leader election to achieve high availability.
High AvailabilityLeader Electiondistributed-systems
This article explains how ulimit settings can cause hidden failures across SysVinit, Systemd, and container environments, details common pitfalls such as PAM overrides and Debian-specific bugs, and provides step‑by‑step solutions and troubleshooting tips to ensure reliable limit configurations.
This article shares practical experiences and detailed guidance on diagnosing and fixing ulimit-related problems in SysVinit, Systemd, and PAM environments, helping operators avoid common pitfalls and ensure reliable process limits on Linux systems.
This article walks through a low‑probability NotReady issue in Alibaba Cloud Kubernetes clusters, detailing how systemd’s 32‑bit cookie overflow in its dbus handling caused container runtime failures, the step‑by‑step debugging process, and the eventual upstream fix.
This guide explains how to use systemd’s systemctl tool to list all loaded services, filter by active or running state, create a handy alias for quick access, check which ports services listen on, and view firewall‑allowed services on a Linux server.
This guide explains the purpose of Linux runlevels, maps them to systemd targets, shows how to check the current runlevel, change it temporarily or permanently, list services per level, create custom levels, and improve system security through fine‑grained service control.
Researchers discovered CVE‑2019‑14899, a vulnerability that enables attackers on the same network to hijack VPN connections and inject arbitrary payloads into IPv4 and IPv6 TCP streams across many Unix‑like operating systems.
This guide explains how to identify and disable unnecessary Systemd services on typical Linux distributions, using commands like systemctl, journalctl, and systemd-analyze, to streamline the boot process while avoiding side‑effects from static services.
This article summarizes eight typical problems encountered when upgrading to RHEL 7—including service management, rc.local scripts, automatic file cleanup, time synchronization, hostname handling, MySQL installation, network configuration, and logging—providing command‑by‑command solutions and best‑practice recommendations.
This guide explains how to replace Docker with Podman for hosting a static Hugo site, using a sidecar Envoy proxy, shared network namespaces, Kubernetes‑compatible pod definitions, and systemd services to achieve automatic startup and reliable service discovery.
This guide explains why many Linux distributions start unused services at boot, and shows step‑by‑step how to list, disable, mask, and verify unwanted systemd services—such as Bluetooth—while also providing commands to inspect boot logs and identify slow‑starting units.
This guide explains how to prepare a Spring Boot application, set up a Debian server with Java, UFW and NGINX, configure the app as a systemd service, create an NGINX reverse‑proxy, and enable HTTPS using Certbot, providing a lightweight alternative to embedded Tomcat.
This article explains how to safely shut down or reboot Linux systems from the command line, covering the main commands, their Systemd origins, detailed usage options, scheduling tricks, and how to cancel pending shutdowns.
This guide explains Linux shutdown-related commands, their historical transition to systemd, detailed usage examples, option flags, scheduling formats, and how to safely cancel or force immediate shutdowns on servers and desktop systems.
This article explains the motivations behind Cgroups v2, outlines its unified hierarchy design, details the five key improvements over v1, describes controller management, subtree control, event and stat files, and provides practical commands for mounting and configuring the new cgroup subsystem.