This guide explains how to use a Jenkins‑triggered shell script with Expect to regularly log into multiple remote VMs, record results, allow users to add hostnames, and commit changes to a Git repository for automated DevOps operations.
Learn how to efficiently execute every script in a folder using three distinct Linux techniques—run-parts with regex filtering, the versatile find command with -exec, and a simple for loop—while avoiding common pitfalls and ensuring safe execution.
Learn three practical methods to add your custom script directory to the PATH environment variable on Linux, enabling you to execute your scripts from any location without navigating to their folder.
Discover how the open‑source “Pure Bash Bible” compiles essential Bash snippets—ranging from trimming whitespace and regex matching to array deduplication—providing fast, dependency‑free solutions, complete with example commands and a GitHub repository that has amassed over 24 000 stars.
This guide presents practical Bash scripting techniques—including strict mode, file locking, graceful termination, timeout handling, and pipeline debugging—to help developers write more robust, maintainable, and error‑resilient shell scripts for automation and system tasks.
This guide consolidates essential shell scripting conventions—including shebang usage, comprehensive commenting, parameter validation, variable handling, indentation, naming, encoding, permission settings, logging, password safety, line continuation, code brevity, quoting, main‑function patterns, scope control, indirect references, heredocs, path resolution, parallel execution, and static analysis with ShellCheck—to help developers write readable, maintainable, and performant scripts.
Learn how to efficiently update root passwords across dozens or hundreds of Linux servers by creating Expect scripts that automate SSH logins, parse IP and password lists, and execute batch password changes, complete with step-by-step instructions, required environment setup, and script explanations.
This guide explains how to rename files on Linux using the mv and rename commands, covering basic single‑file renaming, batch renaming with patterns, handling different OS syntaxes, and advanced strategies for generating name mappings from custom files or filename patterns.
Explore essential Linux operations interview topics—including key Nginx modules, load‑balancing architectures, network connection checks, file‑descriptor tuning, traffic analysis with tcpdump, IP discovery scripts, log‑retention strategies, system hardening tips, SecureCRT shortcuts, and a nightly backup cron job—all with ready‑to‑run command examples.
This guide explains how to efficiently locate executables, files, and content on Linux using commands like whereis, which, locate, find, and grep, with practical examples for filtering by name, time, size, depth, and pattern matching.
This article presents a comprehensive guide to writing reliable Bash shell scripts, covering shebang selection, quoting variables, function encapsulation, readonly constants, variable scope, uninitialized variable protection, tracing, error handling, path management, argument parsing with shift, trap usage, and numerous practical tips for robust script development.
When log files grow massive, traditional tools like vim, cat, grep, and awk become slow and memory‑hungry, but Linux’s split command lets you divide a huge file by line count or size, process the pieces individually, and later recombine them, dramatically improving analysis efficiency.
This article presents a comprehensive set of best‑practice guidelines for writing reliable Bash shell scripts, covering shebang selection, quoting variables, function encapsulation, readonly constants, variable scope, error handling, debugging, path management, argument parsing with shift, signal trapping, and helpful tips to improve script robustness and maintainability.
This guide explains how the xargs utility transforms piped or stdin data into command arguments, covering its syntax, options for limiting arguments, running multiple commands, custom delimiters, reading from files, and combining with find for efficient batch operations on Linux systems.
This guide presents four practical Bash scripts for production Linux servers, covering MySQL full backup with remote sync, Nginx process monitoring that triggers Keepalived failover, MySQL slave status alerts, and a comprehensive CentOS 7 system initialization routine.
This article provides a comprehensive guide to Bash programming, covering variable types and naming rules, assignment and quoting, environment and positional variables, arithmetic and logical operations, conditional statements, loops, functions, arrays, string manipulation, signal handling, and essential command‑line utilities for Linux system scripting.
Learn how to achieve zero‑downtime application upgrades by using Gunicorn’s HUP reload, uWSGI’s chained reload, load‑balancer node draining, and custom health‑check scripts that coordinate process restarts, ensuring minimal service interruption even for apps with long startup times.
This article provides a comprehensive guide to awk, covering its origins, syntax, options, keywords, operators, built‑in variables, regular‑expression meta‑characters, functions, control flow, system interaction, and practical examples that help readers efficiently process and analyze text data on the command line.
This guide explains how to use the Linux seq command to create numeric sequences, customize start, end, and step values, apply separators, pipe results to calculators like bc, and highlights performance tips and limitations for effective shell scripting.
This guide walks you through the Linux find command, covering essential options for locating directories, hidden files, size‑based matches, recent modifications, permission‑restricted items, and more, while also comparing find with locate and showing how to limit CPU and I/O impact.
This comprehensive AWK tutorial, translated and refined from an original English guide, walks readers through the language’s history, variants, typical uses, workflow, program structure, syntax, command‑line options, built‑in variables, operators, regular expressions, arrays, control flow, functions, I/O redirection, and output formatting, providing practical examples and code snippets for rapid mastery.
This article outlines the evolution from manual to automated operations, then presents a comprehensive set of shell‑script guidelines—including header conventions, formatting, safety checks, variable handling, loop pitfalls, logging, concurrency locks, and risk‑avoidance techniques—to help engineers write robust, maintainable automation scripts.
This article outlines how to transform manual and scripted operations into automated and intelligent processes by applying comprehensive shell scripting standards, avoiding common pitfalls, and implementing risk‑mitigation techniques such as proper headers, quoting, logging, concurrency locks, and safe file handling.
This guide introduces the Pure Bash Bible—a popular GitHub repository that compiles essential built‑in Bash commands for string manipulation, arrays, loops, and file handling—providing concise examples and practical code snippets to boost your shell scripting efficiency.
This article introduces the open‑source "Pure Bash Bible"—a comprehensive collection of Bash code snippets that streamline scripting tasks, reduce dependencies, and boost performance, featuring examples for trimming strings, regex matching, color validation, and array deduplication, along with the GitHub repository link.
This guide outlines a practical roadmap for Linux newcomers, covering the purpose of learning, essential command‑line tools, recommended resources, habits for working in the shell, Unix‑style thinking, and key skills like Shell scripting, Python, DevOps, and cloud automation.
This guide explains how to use the Linux time command to accurately measure script or command execution duration, covering basic usage, output redirection, detailed statistics, and custom formatting for precise performance testing in time‑critical environments.
This guide explains how to use the Linux tee command to capture command output, append to files, write to multiple destinations, ignore interrupts, pipe results to other commands, and integrate tee into shell scripts, providing practical examples and syntax details.
This guide explains how to use the Linux time command to benchmark scripts, capture real, user, and system durations, redirect results to files, obtain detailed statistics with the -v option, and create custom output formats using format specifiers and escape sequences.
This article provides a collection of practical Bash scripts for generating random strings, colorized output, batch user creation, package and service checks, host ping monitoring, CPU/memory/disk utilization alerts, website availability testing, and MySQL replication status verification, all useful for Linux system administration and interview preparation.
This guide explains how the stream editor sed works, covering its basic workflow, command‑line options, core commands for substitution, deletion, insertion, appending, changing, transliteration, and file I/O, as well as line‑addressing techniques with practical examples.
This article provides a comprehensive guide to the Linux stream editor sed, covering its batch processing workflow, core options (-e, -f, -n), common commands for substitution, deletion, insertion, line addressing, pattern filtering, transliteration, and file I/O with clear examples and code snippets.
This guide presents a collection of practical Bash snippets for Linux administrators, covering random string generation, colored output, batch user creation, package and service checks, host ping testing, CPU/memory/disk monitoring, remote disk usage, website availability, and MySQL replication status verification.
This tutorial explains how awk works, demonstrates printing specific columns, changing field separators, applying conditional filters, using BEGIN/END blocks for headers and footers, performing calculations, and leveraging built‑in variables and functions for advanced text processing on Linux.
This article provides a comprehensive overview of the curl command-line tool, detailing its purpose, basic syntax, frequently used options, and practical examples for file downloading, uploading, and HTTP request testing, helping readers effectively leverage curl for network and data transfer tasks.
This guide shows how to list dataset numbers where algorithm A failed by generating a full sequence with seq, extracting successful runs via ls, grep, cut, and Python, and then using comm to identify missing entries.
This guide consolidates best‑practice conventions for writing readable, maintainable, and efficient shell scripts, covering shebang usage, commenting, parameter validation, variable naming, indentation, quoting, function structuring, scope handling, heredocs, path resolution, performance tricks, parallel execution, and static analysis with ShellCheck.
Learn how to create high‑entropy, hard‑to‑guess passwords on Linux using three command‑line tools—pwgen, OpenSSL, and GPG—covering installation, usage options, batch generation scripts, and additional utilities for secure credential management.
This article compiles the most common shell script interview questions, providing clear explanations of script basics, variable types, redirection, control structures, special variables, file testing, arithmetic, functions, and debugging techniques to help candidates master Linux automation.
This article compiles the most frequently asked shell script interview questions, providing clear explanations, essential concepts, and practical code examples to help Linux and cloud engineers master scripting for automation, debugging, and system administration tasks.
This article introduces Linux regular expressions, explains the two types of metacharacters—shell and regex—shows how to enable colored output with grep, provides a sample test file, and demonstrates numerous practical pattern-matching examples ranging from simple word searches to complex character class and repetition constructs.
This article provides a comprehensive introduction to AWK, covering its origins, basic syntax, command‑line usage, built‑in variables, printing functions, programming constructs such as conditionals, loops, and arrays, and includes numerous practical examples for extracting and formatting data on Linux systems.
This guide presents practical Bash scripting techniques—including precautions, random string generation, color output functions, bulk user creation, package checks, service status verification, host liveness testing, resource monitoring, disk usage audits, and website availability checks—to help you automate Linux system administration tasks effectively.
This guide walks you through 35 practical examples of the Linux find command, covering name searches, permission filters, owner/group queries, date‑based queries, and size‑based searches, each illustrated with clear explanations and screenshots to help sysadmins and developers locate files efficiently.
This article compiles the most frequently asked shell script interview questions, providing clear explanations, code examples, and practical tips on topics such as script basics, variables, redirection, control structures, debugging, and common commands for Linux operations.
This guide presents practical Bash scripting techniques—including safety flags, function definitions, variable annotations, modern command substitution, double‑bracket tests, string manipulation, process substitution, built‑in variables, and debugging methods—to help you write robust, maintainable shell scripts.
Linux pipes transmit data between commands concurrently, not after one finishes, and their behavior depends on kernel buffering, I/O modes, and signals like SIGPIPE; this article explains pipe internals, real‑time data flow, buffering strategies, read/write rules, and practical tips with illustrative experiments.
AWK is a versatile text-processing language that reads files line by line, splits fields by default spaces, and applies pattern-action rules to analyze data, generate reports, and perform complex tasks such as extracting columns, counting records, and scripting with built-in variables, loops, and conditional statements.
A comprehensive collection of Linux commands and shell scripts covering mounting Windows shares, monitoring HTTP concurrency, network sniffing, log analysis, file system checks, boot sequence, link types, partition handling, FTP modes, and various automation tasks for effective system administration.
This guide introduces Shell scripting, explains its purpose and advantages, outlines scenarios where it excels and its limitations, describes its interpreter-based execution model, and walks through fundamental concepts such as variables, arithmetic, strings, arrays, control structures, functions, redirection, and practical automation examples.
This article explains how the Linux nohup command lets a process continue running after the terminal is closed, demonstrates it with an infinite-loop PHP script, and clarifies why the jobs command cannot list background tasks across different sessions.
This guide presents essential Bash scripting best practices and a collection of practical Linux monitoring scripts, covering topics such as random string generation, colored output functions, batch user creation, package and service checks, host ping, CPU/memory/disk utilization monitoring, remote disk checks, and website availability testing.
This article presents a comprehensive set of Linux interview questions covering basic file handling, process management, networking, security concepts, HTTP protocols, load balancing, and Python scripting, providing clear tasks and explanations for each topic.
This guide presents eight practical recommendations for writing robust Bash scripts, covering shebang selection, debugging flags, static analysis with ShellCheck, variable expansion, proper use of local, signal trapping, thoughtful coding habits, and choosing the right tool for the job.
This tutorial explains how to install ImageMagick, use its core command‑line tools such as magick, convert, identify, mogrify and composite, format image resize commands, add watermarks, generate captchas, clone and append images, convert between GIF, PDF and other formats, and integrate the tool with Node.js scripts.
This tutorial presents a collection of Bash scripts demonstrating how to calculate sums with for, while, and until loops, compute the sum of even numbers, generate a 9×9 multiplication table, monitor user login status, and retrieve system information via a case menu.
This article explains how to use Bash shell scripts on Linux to automate MySQL database testing tasks such as creating tables, inserting, updating, and monitoring dynamic database states, providing step‑by‑step code examples and execution instructions for efficient test automation.
This guide presents essential Bash scripting practices—including safety flags, function definitions, variable annotations, modern command substitution, double‑bracket tests, powerful string manipulation, process substitution, here‑documents, debugging techniques, and advice on when to avoid Bash—in a concise, example‑driven format for reliable shell scripts.
This article compiles the most common shell scripting interview questions, covering fundamentals such as script basics, variables, redirection, control structures, special parameters, file tests, debugging techniques, and practical code examples to help Linux engineers prepare effectively.
This comprehensive guide explains Awk’s role as a versatile, stream‑oriented editor and pattern‑matching language, covering its command‑line syntax, records and fields, scripts, patterns, regular expressions, operators, statements, built‑in variables, functions, I/O handling, and practical code examples for Linux users.
This guide introduces the AWK text‑processing language, explains its syntax, shows three ways to invoke it, and provides practical examples—from extracting fields in /etc/passwd to counting users, computing file sizes, and using built‑in variables, conditionals, loops, and arrays for advanced scripting.
This comprehensive guide walks you through the essentials of Bash shell scripting, covering variable definitions, printing, arithmetic, control structures, loops, arrays, functions, file I/O, sed stream editing, modular scripts, and interactive menus, all illustrated with clear code examples.
This guide explains the essential syntax of the Linux find command and demonstrates how to locate files by name, pattern, path, type, depth, size, timestamps, permissions, ownership, and how to execute actions on matched files, with clear examples for each use case.
This article compiles the most common shell script interview questions, covering fundamentals such as script purpose, default login shells, variable types, redirection, control structures, debugging, file testing, and special Bash variables, providing concise answers and practical code examples for each topic.
This article introduces AWK—a versatile text‑analysis language—explaining its origins, core concepts, command‑line usage, built‑in variables, printing functions, programming constructs, conditionals, loops, and associative arrays, and provides practical Linux examples for extracting and summarizing data.
This guide introduces grep—a ubiquitous Linux command‑line tool—and demonstrates twelve practical techniques for searching, filtering, counting, and automating text processing tasks across files, directories, and compressed logs.
This guide compiles essential Linux command‑line techniques—from mastering Bash, Vim, and SSH to advanced file, process, and network management—helping users automate tasks, debug systems, and handle data efficiently, all without relying on graphical tools.
Discover a collection of practical Bash script snippets covering random string generation, colored output functions, batch user creation, package and service checks, host reachability, CPU/memory/disk monitoring, remote disk usage collection, and website availability testing, with essential scripting best‑practice tips.
This comprehensive guide introduces Awk, explains its command‑line syntax, script structure, patterns, built‑in variables, arrays, functions, operators, statements, I/O handling, and practical examples, enabling readers to harness Awk for powerful text processing tasks on Unix-like systems.
This guide walks you through configuring Jenkins to build a SpringBoot Maven project, automating post‑build steps, managing the workspace, and securely transferring the resulting JAR to another server using SSH keys or an Expect script.
This article explains common scenarios where Bash variables, spaces, or special characters cause unintended rm -rf deletions and provides practical safeguards such as parameter expansion checks, quoting, set options, logical short‑circuiting, and friendly prompts to avoid catastrophic data loss.
This article shares a single‑image cheat sheet that condenses Bash shell programming concepts from chapters 25‑37 of "The Linux Command Line" and provides a PDF download link with access password.
This article compiles the most common shell script interview questions—from basic concepts and variable types to redirection, control structures, debugging, and special Bash variables—providing concise answers and code examples to help candidates prepare effectively.
This comprehensive guide walks you through Bash scripting fundamentals, covering conditional statements (if, case), four types of loops (for, while, until, select), loop control commands, signal trapping with trap, useful one‑liners, and a collection of fun mini‑scripts, all illustrated with clear examples and diagrams.
This article compiles comprehensive shell scripting best‑practice guidelines—including shebang usage, commenting, parameter validation, variable handling, indentation, naming conventions, encoding, permissions, logging, password safety, line continuation, efficiency tricks, quoting, function structuring, scope control, indirect references, heredocs, path resolution, parallel execution, modern syntax, and static analysis with ShellCheck—to help developers write readable, maintainable, and performant Bash scripts.
This guide introduces Bash scripting fundamentals, covering predefined variables, declaration operators, and practical examples of single‑, double‑, and multi‑branch if statements for tasks such as checking user privileges, disk usage, and service status on Linux systems.
This article shares eight hard‑earned recommendations for writing robust Bash scripts, covering shebang selection, debugging flags, static analysis, variable expansion, proper scoping, signal trapping, defensive coding, and knowing when to switch to a more suitable language.
This article introduces shell scripting fundamentals, explores practical use cases, explains how the shell works, demonstrates variables, operators, control structures, functions, redirection, and provides example scripts for automating tasks on Windows, Unix, and Linux systems.
This guide outlines why learning a single Linux distribution like CentOS or RHEL provides a solid foundation, recommends a practical beginner's book, lists core knowledge areas and essential tools, and highlights the importance of hardware basics and automation for aspiring Linux operations engineers.
This guide provides concise Bash scripting best practices, code snippets for generating random strings, color output functions, bulk user creation, package and service checks, host liveness verification, resource utilization monitoring, and website availability testing, all useful for system administration and interview preparation.
Learn ten practical Bash scripting techniques—including adding comments, exiting on errors, proper variable quoting, using functions, correct string comparisons, modern command substitution, readonly variables, naming conventions, and debugging—to write more efficient, reliable, and maintainable scripts for Linux automation tasks.
This article presents two comprehensive Shell scripts—one to validate Oracle RMAN backup sets and another to perform a full backup‑restore experiment—detailing SSH trust configuration, source information collection, log transfer, directory preparation, and step‑by‑step RMAN restore commands, all illustrated with practical screenshots and a GitHub repository link.
This article presents practical Bash scripting techniques—including safety flags, function definitions, variable annotations, modern command substitution, double‑bracket tests, powerful string manipulation, process substitution, here‑documents, built‑in variables, and debugging methods—to write more reliable and maintainable shell scripts.
This article walks through Bash scripting fundamentals—including variable assignment, quoting, loops, conditionals, functions, return codes, and background jobs—while highlighting common pitfalls and safety practices such as always quoting variables and using the shellcheck linter.
This tutorial shows how ordinary users can replace spreadsheet work by using Linux command‑line utilities such as head, tail, wc, grep, tr, sort, sed, cut, uniq and awk to quickly explore, filter, transform and summarize CSV/TSV data sets.
This article introduces awk as a versatile text‑processing language, explains its origins and variants, details command‑line syntax and three invocation methods, and walks through practical examples—from extracting fields in system files to using built‑in variables, conditionals, loops, arrays, and formatted output with print and printf.
This article introduces the Linux shell as an interface and scripting language, explains how to execute scripts, manage system and user variables, use special variables, operators, conditional statements, loops, case constructs, and define functions, providing concrete syntax examples for each feature.
This article introduces the Linux shell as the user‑kernel interface, explains why Bash is the most popular shell, and covers script execution methods, variable handling, operators, control structures, and custom functions with concrete command examples.
This article explains how to make robust MySQL backup shell scripts by adding logging, usage instructions, file locking, and proper comments to avoid rogue behavior and ensure reliable operation.
This article introduces the stream editor sed, covering how to select lines, use common options, apply basic commands, and demonstrates practical scripts for cleaning and formatting text files on Linux.
This article compiles 70 typical Linux shell scripting interview questions covering script arguments, parameter handling, condition checks, loops, string manipulation, array operations, file I/O, and common command usages, each accompanied by concise Bash code examples to help candidates prepare effectively.
This guide walks through Linux system startup fundamentals, covering nohup usage, nice value adjustments, runlevel inspection, initramfs handling, detailed boot sequence steps, chkconfig and GRUB configuration, and hands‑on exercises for creating services and building a custom Linux system.
This article shares eight hard‑earned recommendations for crafting reliable Bash scripts, covering interpreter selection, debugging flags, static analysis tools, variable expansion, proper scoping, signal trapping, thoughtful design, and recognizing when to switch to more suitable languages.
This article explains how to extract valuable performance and traffic insights from Nginx access logs using shell commands and awk, covering request volume, peak rates, bandwidth usage, slow‑query detection, URL normalization, and practical optimization recommendations for web operations.
This article shows how to reliably obtain a filename’s extension in Bash using parameter expansion, explains why assuming a three‑character suffix can be wrong, and offers practical advice on providing clear information when seeking help with scripting problems.
This article walks through the shortcomings of manual code releases, designs a multi‑environment automated deployment workflow, details step‑by‑step implementation—including code fetching, configuration handling, logging, parallel execution, and rollback—while sharing practical scripts and common pitfalls for large‑scale clusters.
This article provides a concise collection of practical sed command examples, demonstrating how to print, delete, substitute, and transform lines and characters in a text file using regular expressions, including techniques for case conversion, line numbering, and in‑place editing.
Learn how to use Bash's flow-control structures—including if, elif, else, case, for, and while loops—through clear explanations and practical code examples that demonstrate testing conditions, handling files, and automating tasks in shell scripts.
This article demystifies Bash's test constructs—including test, [, [[, and (( ))—explaining their syntax, return codes, common operators, and practical examples so readers can confidently write conditional logic in shell scripts.
This comprehensive guide covers essential Linux command‑line techniques—from basic Bash navigation and file management to advanced text processing, system debugging, one‑liner tricks, and Mac‑specific tips—providing both beginners and experienced users with practical examples and shortcuts to boost productivity.
