This article explains various methods for scheduled MySQL backups, covering mysqldump command usage, example backup commands for whole or specific databases, a Bash script to retain a fixed number of backups, and configuring cron jobs to automate the backup and restoration processes.
This article explains the fundamentals of Linux shells, covering why they’re called shells, prompt behavior, echo usage, quoting differences, variable handling, export, command grouping, arithmetic expansion, special parameters, redirection, conditional statements, loops, and provides practical Bash code examples for each concept.
This article compiles a collection of practical Bash scripts for Linux system administrators, covering automatic DDoS IP blocking, email alert setup, single‑ and multi‑database MySQL backups, Nginx log rotation and analysis, real‑time network traffic monitoring, server initialization, and bulk disk‑usage checks across many hosts.
This article provides a collection of ready‑to‑use Bash scripts that automate DoS attack blocking, email alerts, MySQL single‑ and multi‑database backups, Nginx log rotation and analysis, network traffic monitoring, system initialization, and disk usage checks across many servers.
This article presents a collection of practical Bash scripts for Linux servers, covering DOS attack IP blocking, alert emailing, MySQL backup (single and multi‑loop), Nginx log rotation and analysis, real‑time network traffic monitoring, system initialization, and disk usage checks across multiple hosts.
This article compiles a comprehensive set of Linux command‑line shortcuts covering system shutdown, hardware inspection, user management, networking, file handling, compression, performance monitoring, and many other routine administration tasks, providing a handy reference for developers and sysadmins alike.
This guide explains the importance of shell coding standards, outlines core principles such as correctness, readability and maintainability, defines mandatory and optional rules for file naming, indentation, comments, variable handling, control structures, error handling, and provides concrete examples and best‑practice recommendations for Bash scripts.
This article consolidates practical shell scripting standards—covering shebang usage, commenting, parameter validation, naming conventions, encoding, indentation, function structuring, variable scope, efficient command patterns, parallel execution, and static analysis with ShellCheck—to help developers write readable, maintainable, and performant Bash scripts.
This guide outlines comprehensive shell scripting standards—including why they matter, core principles, file naming, encoding, line length, indentation, naming conventions, comment rules, error handling, and best‑practice patterns—to improve readability, maintainability, and consistency across Bash scripts in production environments.
This guide explains how the Linux shell stores command history, how to view, search, repeat, and manage entries, and how to configure environment variables for timestamps, size limits, custom files, and security, helping administrators streamline their workflow.
This article explains how to use mysqldump for various MySQL backup scenarios, provides command‑line examples for full, structure‑only, and selective backups, shows how to restore dumps, and demonstrates a Bash script combined with crontab to automate daily backups with retention management.
This guide explains why ls -lh shows only the directory entry size, introduces the du command for real disk usage, details its most useful options, and provides step‑by‑step examples for measuring directory sizes on a Linux system.
This article explains how to use the mysqldump command to back up MySQL databases, provides various command examples for full or partial backups, demonstrates a Bash script for automated daily backups with log management, and shows how to schedule these tasks using crontab.
This article introduces the role of shell scripts in automating system operations, presents a free 70‑page practical handbook covering fundamentals to advanced topics, and offers 100 ready‑to‑run script examples ranging from basic hello‑world to complex monitoring and deployment tasks, helping readers quickly boost their scripting skills.
This tutorial walks Java developers through the fundamentals of Linux shell scripting, covering how to create and run scripts, check and set the default shell, manage permissions, define and manipulate variables, and implement flow‑control constructs such as if/else, case, for, and while loops with practical code examples.
This article provides a complete Bash script that performs daily health checks on a Linux host, gathering information on disk usage, memory, CPU, processes, services, network configuration, user accounts, password policies, firewall, SELinux, NTP, SNMP, JDK, and more, then formats the results into a report and emails it.
This guide demonstrates how to batch‑replace text with sed, rename files using Bash substring expansion, and change file extensions efficiently on a Linux system, providing clear command examples and practical one‑liners for everyday operations.
This guide details how to protect MySQL databases from errors and crashes by using mysqldump for manual dumps, creating Bash scripts for automated daily backups, and scheduling them with Linux cron, including command examples, restoration methods, and crontab syntax for reliable periodic backups.
This tutorial explains how to install the SHC tool on CentOS 8, create a simple shell script, encrypt it into a binary executable, verify the file types, run the encrypted script, and optionally set an expiration date or custom expiration message.
This guide explains how to use the Linux history command to display past commands, manipulate the history list with options like clearing, appending, reading, writing, deleting entries, and provides practical examples and key notes for effective shell command management.
Learn how to use the Linux bash alias command to create, list, and manage command shortcuts, understand its temporary nature, and make aliases permanent by editing the appropriate initialization files such as /etc/bashrc or ~/.bashrc, with practical examples included.
This guide explains how to use the built‑in unalias command in Bash to delete individual or all command aliases, shows the syntax and common options, provides practical examples, and highlights important considerations when running scripts that modify alias settings.
Learn how to use the Linux watch command to run any command at regular intervals, customize its behavior with options like -n, -d, and -t, and see practical examples such as monitoring memory usage and tracking file changes.
Learn how to use the Linux echo command to display strings and variables, explore its syntax and options like -n and -e, and discover advanced techniques for colored, formatted, and escaped output through practical examples.
This guide walks you through using mysqldump to back up MySQL databases, restoring backups, and creating a Bash script with crontab to automate daily backups while retaining only the most recent 31 days of dump files.
This article explains the behavior of key Bash special parameters—$*, $@, $#, $$, and $!—through three practical scripts that demonstrate argument expansion, counting, arithmetic operations, and process ID retrieval, highlighting the differences and typical use cases.
This guide explains how to install the GNU coreutils stat command, interpret its comprehensive default output, use the terse option for compact results, and craft custom formats with --printf, providing practical examples and a reference list of format sequences for Linux file metadata extraction.
This guide introduces the most commonly used Linux shell utilities—find, grep, xargs, sort, uniq, tr, cut, paste, wc, sed, and awk—explaining their core options and providing practical examples to help you efficiently manipulate and process text files from the command line.
This guide demonstrates three practical methods for bulk renaming files on Linux: using sed for in‑place text replacement, applying Bash variable substring manipulation, and changing file extensions with parameter expansion, each illustrated with complete command‑line examples.
This article provides a step‑by‑step Bash script for installing, configuring, and starting MySQL 8.0 on a Linux system, including user creation, directory setup, permission handling, initialization checks, and service management, and ensures proper environment variables.
This guide explains how the Linux history mechanism works, shows essential commands for viewing, filtering, and replaying past commands, demonstrates timestamping, adjusting record limits, changing the history file, disabling logging, and shares a hidden trick for keeping sensitive commands out of the log.
This guide explains how to use and name shell variables, manipulate strings, create and run Bash scripts, manage environment variables, perform arithmetic and relational operations, read user input, and handle common file‑system tasks, providing clear examples and command‑line snippets for each topic.
This article provides a concise reference of 50 essential Linux commands covering file management, user administration, system monitoring, networking, permission handling, and editor shortcuts, offering clear examples and explanations for each command to help both beginners and seasoned administrators work efficiently.
This article explains how a command’s exit status indicates success or failure in Unix shells, describes the meaning of common return codes, introduces the special $? variable, and provides a comprehensive Bash script example demonstrating various exit scenarios and custom status handling.
This guide explains how Linux aliases work, shows how to create temporary and permanent shortcuts for long commands like rsync, demonstrates listing and removing aliases, and provides step‑by‑step instructions for storing aliases in ~/.bashrc or a separate file.
This guide walks through a collection of frequently used Linux shell commands—grep, custom alias shortcuts, pwd, find, history, od, and for loops—explaining their common scenarios, key options, example usages, and handy tricks to boost productivity in everyday development and scripting tasks.
This guide presents 27 practical Linux command-line techniques—from safe file deletion and alias management to process monitoring, log handling, and advanced shell shortcuts—designed to help heavy users work more efficiently and avoid common pitfalls.
This article explains why a simple Bash loop may output zero when trying to sum the second column of a text file, demonstrates three different line‑by‑line approaches, shows common pitfalls such as pipeline subshells and whitespace handling, and provides correct solutions with shellcheck recommendations.
Learn how to create temporary and permanent Linux aliases to replace lengthy commands, streamline file synchronization with rsync, manage aliases via the alias and unalias commands, and store them in dedicated files for persistent shell customization.
This guide presents 27 practical Linux command‑line techniques—from safe file deletion and alias management to cursor shortcuts, process monitoring, log handling, and advanced scripting—helping power users work faster and avoid common pitfalls.
This guide shows how to use shell commands and simple Bash scripts on CentOS 7 to list active network interfaces, extract their IPv4/IPv6 addresses, display MAC addresses, and check link speed using ip, awk, ethtool, and other standard utilities.
This article provides a comprehensive guide to Bash scripting, covering if/elif/else conditionals, case statements, four types of loops (for, while, until, select), signal trapping with trap, useful one‑liners for randomness and colored output, and several fun scripts such as a multiplication table, colored triangle, and chessboard.
This article explains the purpose and behavior of key shell special parameters—$*, $@, $#, $$, and $!—through three practical scripts that demonstrate expanding positional arguments, counting arguments, and accessing process IDs, complete with code snippets and expected output.
This guide explains the Linux source command, covering its syntax, how to refresh the current shell environment, execute scripts within the same session, import functions, and read variables from other scripts, with practical examples and command-line illustrations.
This article provides a comprehensive guide to Bash scripting, covering conditional statements (if/elif/else), case selections, various loop constructs (for, while, until, select), loop control commands, parameter shifting, signal trapping with trap, and includes numerous practical code examples with detailed analysis.
This guide demonstrates four practical techniques—input redirection, cat with a pipe, passing the filename as a parameter, and using awk—to read a text file line by line in a Bash script, complete with code snippets and expected output.
This guide provides a comprehensive walkthrough of Bash scripting fundamentals, covering conditional statements, various loop constructs, signal handling with trap, and a collection of useful one‑line scripts and visual examples for everyday tasks.
This article explains how Linux shells store command history in .bash_history, shows basic and advanced usage of the history command—including listing, searching, repeating, timestamping, and configuring history size—and provides practical tricks for auditing, backup, and even disabling history for security purposes.
This article compiles a comprehensive set of Bash scripts that automate common Linux server tasks such as file consistency checks, log cleanup, network traffic monitoring, port scanning, user management, firewall rules, and service health checks, providing sysadmins with ready‑to‑use solutions for efficient operations.
This article explains how to efficiently use the Linux history command, covering its underlying mechanism, basic usage, repeat execution, searching, interactive search, timestamp display, history size control, file name changes, disabling history, and a useful security tip, helping administrators improve productivity and auditability.
This guide provides a comprehensive overview of Bash’s various bracket types—including parentheses, double parentheses, square brackets, double square brackets, and curly braces—detailing their syntax, typical use‑cases, parameter‑expansion forms, pattern‑matching capabilities, and practical code examples for effective shell scripting.
This article presents seven hands‑on Bash script examples that cover concurrent hostname collection, process state counting, bulk file renaming, automated jstack logging, GC log analysis, high‑traffic IP detection with conditional reporting, and moving large files while sorting them by size, each with complete code snippets.
This article provides a detailed Bash scripting tutorial covering conditional statements (if/elif/else, case), various loop constructs (for, while, until, select), control commands (break, continue, shift), signal handling with trap, and several practical example scripts such as a multiplication table, colored triangle, and chessboard pattern.
This guide explains how to configure Linux environment variables using various methods such as export, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment, and details the loading sequence and practical tips for effective management.
This article provides a comprehensive introduction to the Bash shell, covering its purpose, user prompts, shebang syntax, execution methods, basic commands like echo and printf, variable handling, environment variables, arithmetic operations, and conditional statements for writing effective shell scripts.
This guide introduces Bash shell fundamentals, covering script shebangs, execution methods, echo and printf usage, color output, variable handling, PATH manipulation, arithmetic operations, and conditional expressions, providing practical examples for Linux command‑line users.
This article provides a step‑by‑step Bash script that gathers Linux server IP, CPU core count, utilization percentages, context switches, load averages, memory statistics, swap usage, and disk I/O metrics, explaining each command and its output for effective system monitoring.
This guide shows how to enrich Linux Bash history with execution timestamps, associate each command with the user and IP address, and forward the logs to syslog—providing reliable audit trails and protecting against attackers tampering with history records.
This guide explains how Linux uses the LS_COLORS environment variable to assign distinct colors to file types in terminal listings, shows where the default definitions reside, details attribute, text, and background codes, and provides step‑by‑step instructions for creating custom color schemes via your bash configuration.
This guide introduces eighteen entertaining Linux command‑line tools—ranging from the train‑displaying sl to the matrix‑style cmatrix—detailing their installation, usage options, and playful effects, while also offering tips for creative combinations and safety warnings.
This article explains how to use the Linux history command to view past commands, search with Ctrl +r, repeat previous entries, adjust the number of stored records, and clear the history, providing practical examples and configuration tips for effective shell management.
This guide explains how to install the Rust‑based Starship prompt, add it to Bash, create a basic TOML configuration, and customize its appearance across Linux, macOS, and Windows shells, providing practical commands and examples for a sleek, fast terminal experience.
This guide presents a comprehensive set of Bash and AWK one‑liners for analyzing web server logs, counting unique IPs, tracking page visits, sorting traffic by time, identifying heavy‑weight requests, monitoring Apache processes, and examining network connection states, helping you detect anomalies and optimize performance.
This guide shows how to prevent a Bash script from being executed multiple times by detecting existing instances, using lock files with process checks, and employing the flock command for reliable atomic locking, complete with practical code examples and pitfalls to avoid.
This article lists ten dangerous Linux commands—including variations of rm, fork bombs, raw device writes, and hidden hex‑encoded scripts—explains how each can cause irreversible data loss or system crashes, and offers practical safeguards such as using aliases and testing only in virtual environments.
This guide explains how the Linux export command works, shows how to list, set, and export variables and functions, and demonstrates configuring persistent environment settings for Bash users.
This guide compiles practical Linux shell commands and scripts—including file searching, batch extraction, sed editing, directory checks, disk‑space monitoring, log analysis, firewall rules, and network capture—to help system administrators automate routine tasks efficiently.
This guide walks you through creating a .sh Bash script, adding a simple “Hello World” program, granting execute permission with chmod, and running it directly or via sh/bash, plus a practical backup script example that archives /var/log using tar.
This guide shows how to enrich Linux Bash history with execution timestamps, user and IP information, and forward logs to syslog or a remote server, improving auditability and protecting against tampering during security incident response.
This guide explains how to create, test, and apply boolean-like variables in Bash, covering numeric (0/1) and string (true/false) representations, conditional checks, and practical examples for cron jobs and backup scripts on Linux/Unix systems.
This guide explains how to enhance Linux Bash history logging by adding timestamps, recording user IPs and commands, configuring environment variables, and modifying Bash source to send history entries to syslog, ensuring more reliable audit trails for security incident response.
Learn how to efficiently switch between directories in Linux using the built‑in bash commands pushd, popd, and dirs, covering basic usage, stack manipulation, and advanced options to eliminate repetitive typing and streamline your workflow.
This article provides a comprehensive guide to the various bracket types used in Bash scripting—including (), (( )), [], [[ ]], and {}, explaining their syntax, behavior, and practical examples for command grouping, arithmetic evaluation, testing, and parameter expansion.
This article explains the recent Docker command restructuring, introduces the Management Command and sub‑command syntax, and provides detailed instructions for enabling powerful tab‑completion on macOS using Bash or Zsh, complete with code snippets and screenshots.
This guide explains how to configure Linux environment variables—especially PATH for MySQL—using various methods such as export commands, editing ~/.bashrc, ~/.bash_profile, /etc/bashrc, /etc/profile, and /etc/environment, and details the exact order Linux reads these files during login and shell startup.
This guide explains Bash’s various bracket types—single and double parentheses, single and double square brackets, and curly braces—including their syntax, common use cases, command and arithmetic expansions, pattern removal, and practical examples for reliable shell scripting.
This guide explains how to manually back up a MySQL database using mysqldump, import the backup file, and set up a Bash script with crontab for daily automated backups, including handling of MySQL event tables and path configuration.
This guide explains multiple methods for configuring Linux environment variables—especially PATH—on Ubuntu, covering user‑level files like ~/.bashrc and system‑wide files such as /etc/profile, and details the exact loading order Linux follows when initializing shells.
This article introduces ten useful but often overlooked Linux commands—pgrep, pstree, bc, split, nl, mkfifo, ldd, col, xmlwf, and lsof—explaining their purpose, typical use cases, and providing concrete examples to help system administrators work more efficiently.
This article presents a comprehensive set of guidelines for writing clean, maintainable, and efficient Bash/Shell scripts, covering shebang usage, comments, parameter validation, variable handling, indentation, naming, encoding, permissions, logging, security, parallel execution, and tooling such as ShellCheck.
This guide consolidates practical conventions for writing clean, maintainable shell scripts, covering shebang usage, commenting, parameter validation, variable handling, indentation, naming, encoding, efficiency tricks, and static analysis with ShellCheck.
This article introduces ten essential Git commands—including diff, log, reset, revert, clean, and commit‑amend—explains how to escape Vim, change the default editor, and create Bash aliases for faster Git operations, providing practical examples and code snippets for developers.
This guide shows how to efficiently verify whether millions of file paths exist on remote servers by splitting a large list into smaller chunks and processing each chunk concurrently with a Bash script, dramatically reducing runtime compared to a single‑threaded approach.
This article explains why Bash scripts need unit testing, outlines common testing challenges, defines what constitutes a Bash unit test, and demonstrates how to write safe, fast, and cross‑platform tests using the Bach Testing Framework with practical code examples.
This article presents ten common Linux shell interview questions, providing clear explanations, command-line solutions, code examples, and step‑by‑step guidance on script termination, file header removal, line length checking, non‑printable character display, directory permissions, process states, cut, cmp vs diff, echo vs ls, and inode basics.
bashtop is a Bash‑written Linux resource monitor that visualizes CPU, memory, disk, network and process usage, offers a game‑inspired UI with fast navigation, configurable settings, and real‑time graphs, and is available on GitHub with detailed configuration examples and usage instructions.
This guide explains the importance of shell script coding standards, outlines core principles such as correctness, readability, maintainability, and consistency, and provides detailed recommendations on file naming, encoding, line length, indentation, comments, testing, and safe use of commands to improve script quality and reduce maintenance costs.
This guide explores Bash's built‑in history command, revealing hidden features like event designators, string search, relative indexing, and quick substitution to boost shell productivity.
This article explains why Bash scripts need unit testing, outlines common testing challenges, and demonstrates how the Bach Testing Framework provides safe, fast, and environment‑agnostic unit tests for Bash scripts by mocking external commands and isolating execution logic.
This guide explains the difference between Linux environment and shell variables, shows how to view, set, export, and unset them with commands like env, printenv, export, unset, and demonstrates how to make variables persistent by editing common startup files such as /etc/profile and ~/.bashrc.
This article explains why Linux's `free` command often reports higher used memory than the RSS values shown by `ps aux`, covering buffer/cache reclaimable memory, slab and page‑table consumption, and provides Bash scripts to accurately calculate total memory usage.
This guide presents practical techniques for creating reliable Bash scripts, covering syntax checking, automatic exit on errors, execution tracing, undefined‑variable detection, pipe‑fail handling, readonly variables, default values, command chaining, and function usage, with concrete code examples and tool recommendations.
This article introduces k1s, a minimalist Bash‑based Kubernetes dashboard that watches any resource type across namespaces, explains how to install it via Homebrew or a raw script, details its command‑line syntax, walks through the full source code line by line, and discusses its limitations and potential extensions.
This guide explains the drawbacks of fixed positional parameters in shell scripts, demonstrates simple examples, and introduces the getopts utility to handle named options, optional arguments, and error suppression, enabling more flexible, readable, and maintainable command-line interfaces.
This article compiles practical shell‑script coding standards—covering shebang usage, commenting, parameter validation, variable handling, indentation, naming, encoding, logging, security, modular design, parallel execution, and static analysis with shellcheck—to help developers write readable, maintainable, and performant Bash scripts.
The article introduces Bach, a lightweight Bash unit‑testing framework that lets developers safely detect dangerous commands like rm ‑rf in scripts, explains how to import it, use its @do‑not‑panic API and other mock commands, and outlines its principles, limitations, and real‑world adoption.
When using sudo, Linux resets the environment, causing custom variables to disappear; this guide explains why, shows the relevant lines in /etc/sudoers, and presents three practical methods—including sudo -E, editing env_keep and secure_path, and creating aliases—to retain needed variables.
This tutorial shows Linux system administrators and DevOps engineers how to create a fully customizable, distributed monitoring dashboard by installing and configuring Prometheus, Pushgateway, and Grafana, writing a Bash script to push process metrics, and visualizing CPU and memory usage with Grafana panels and PromQL queries.
This guide explains why the standard cat command lacks syntax highlighting, introduces the ccat utility that adds colored output for many programming languages, and provides step‑by‑step installation instructions for Arch and other Linux distributions, along with practical usage examples and troubleshooting tips.
Learn how to verify the ngx_http_stub_status_module compilation, configure Nginx stub_status endpoint, create Bash monitoring scripts, set up Zabbix user parameters, and build templates, triggers, and graphs to monitor Nginx performance metrics such as active connections, requests, and waiting clients.
