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.
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.
This guide walks you through essential Linux performance diagnostics—examining CPU details, startup services, load averages, memory usage, and disk I/O—providing commands and practical solutions to identify bottlenecks and improve system responsiveness for your workstation.
An Alibaba Cloud expert walks through a rare Kubernetes node NotReady issue, detailing how PLEG failures, Docker daemon stack traces, runC’s D‑Bus interactions, and a systemd cookie overflow combine to stall nodes, and explains the debugging steps and eventual fix.
This guide explains how to list all running Linux services, inspect their status, and examine service configurations using systemd commands, netstat, and the /etc/services file on CentOS/RHEL and older SysV init systems.
This article explains how a service registry works in microservice architectures, covering self‑registration and third‑party registration, client‑side and server‑side discovery, and provides practical Node.js code examples and a systemd unit for managing service registration.
This guide explains how Supervisor, a Python‑based process manager, can daemonize command‑line programs, monitor their health, auto‑restart on failure, and be managed via configuration files, systemd commands, the supervisorctl client, a web UI, and practical examples.
This guide explains how Linux distributions start many default services, how to use Systemd tools to view and analyze boot processes, and provides step‑by‑step instructions for safely disabling or masking unneeded services to improve startup performance.
This article details a company's migration from commercial load balancers to an open‑source Nginx‑based Layer‑4 solution, covering project background, technical selection, architecture design, network and Nginx configurations, operational scripts, health‑check automation, performance testing, and data analysis using Elasticsearch and Grafana.
This guide explains why many Linux distributions start unused services at boot, shows how to list and inspect them with systemd tools, and provides step‑by‑step methods to safely mask or disable specific services to speed up system startup.
This guide explains how to wrap a Java JAR into a systemd service on Ubuntu, create a startup script, enable automatic boot‑time launch, and monitor logs using journald, providing a reusable pattern for other languages and Linux distributions.
This guide explains how to install, enable, and manage FirewallD on Linux, covering zones, services, ports, rich rules, port forwarding, and direct iptables integration, with step‑by‑step commands and visual examples to help administrators configure persistent, dynamic firewalls efficiently.
This guide explains the Linux boot sequence, the role of GRUB2, initramfs, and systemd, then walks through a step‑by‑step method to break a lost root password by interrupting the boot process, remounting the filesystem, and resetting the password.
This guide explains the complete boot sequence of CentOS 5, 6, and 7, covering GRUB stages, initrd, rc scripts, chkconfig, and the transition to systemd with its units, targets, and systemctl commands, providing practical commands and configuration examples.
This guide walks through installing MySQL Server 5.7 on CentOS 7 via the official RPM repository, explains why the default root login fails, and provides step‑by‑step commands to stop the service, start it with skip‑grant‑tables, update the root password, and restart MySQL for successful login.
This article provides a comprehensive overview of systemd, the modern Linux init system, covering its design goals, compatibility with SysVinit, parallel boot advantages, on‑demand activation, CGroup‑based process tracking, unit types, dependency handling, snapshot and journal capabilities, as well as practical guidance for developers and system administrators.
This article explains the evolution of Linux init systems, focusing on Upstart's event‑driven design, core concepts such as jobs and events, configuration syntax, and practical commands for developers and administrators, highlighting its advantages over traditional SysVinit.
This article introduces the evolution of Linux init systems—from the classic SysVinit to Upstart and systemd—explaining their history, runlevel concepts, startup sequences, management tools, and the reasons behind the shift toward faster, more modern init solutions.
This article introduces Linux From Scratch (LFS) and Beyond Linux From Scratch (BLFS), highlights the upgrades in LFS 7.6—including a newer toolchain, 26 package updates, eight new packages, and Systemd support—and provides online reading and download links for both projects.
This hands‑on diary chronicles the author’s experience installing CentOS 7, highlighting differences from earlier RHEL‑based releases such as single‑package selection, XFS default partitions, systemd‑based service management, network interface renaming, and challenges with LVM resizing and DHCP configuration.
