Boost Your Ops Efficiency: 20 Must-Have Tools for Faster Server Management

Overview

The article presents a practical toolbox of twenty open‑source utilities that significantly boost the efficiency of daily operations work. It explains the selection criteria—free, actively maintained, easy to install, focused on real problems, and performant in production—and provides a high‑level classification of the tools.

Tool Classification

The tools are grouped into six core scenarios:

Terminal enhancement (zsh, starship, tmux, fzf)

File handling (fd, ripgrep, bat)

System monitoring (htop, btop, dstat, glances)

Network diagnostics (mtr, HTTPie, bandwhich)

Text processing (jq, lnav, diff‑so‑fancy)

Container operations (lazydocker, ctop, dive)

Environment Requirements

Supported operating systems are recent Rocky/CentOS 9, Rocky 9, and Ubuntu 24.04. A Linux kernel 5.14+ is required for some tools. The recommended terminal emulator supports true‑color (e.g., Alacritty, iTerm2, Windows Terminal). The shell should be Zsh 5.8+ (or Bash 5.0+). Python 3.11+, Go 1.21+, and Rust 1.70+ are needed for building certain utilities.

Installation Steps

Preparation

Install basic development packages and enable the EPEL repository on Rocky/CentOS. On Ubuntu, update the package index and install the build‑essential set.

# Rocky/CentOS base preparation
sudo dnf install -y epel-release
sudo dnf groupinstall -y "Development Tools"
sudo dnf install -y git curl wget unzip tar gzip
# Install Rust (for compiling some tools)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source ~/.cargo/env
# Install Go (for compiling some tools)
sudo dnf install -y golang
# Ubuntu base preparation
sudo apt update
sudo apt install -y build-essential git curl wget unzip
# Install Rust on Ubuntu
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source ~/.cargo/env
# Install Go on Ubuntu
sudo apt install -y golang-go

Core Configuration

Install and configure the terminal, shell, and essential plugins.

# Install Zsh and Oh My Zsh
sudo dnf install -y zsh   # or sudo apt install -y zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" --unattended
# Install Oh My Zsh plugins
git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions 2>/dev/null || true
git clone https://github.com/zsh-users/zsh-syntax-highlighting ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting 2>/dev/null || true
# Install Starship prompt
curl -sS https://starship.rs/install.sh | sh -s -- -y
# Install tmux with a custom configuration
sudo dnf install -y tmux   # or sudo apt install -y tmux
cat > ~/.tmux.conf <<'EOF'
set -g prefix C
unbind C-b
bind C send-prefix
set -g mouse on
set -g default-terminal "screen-256color"
# ... (additional key bindings and status bar settings)
EOF
# Install fzf (fuzzy finder)
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install --all
# Install Rust‑based tools (fd, ripgrep, bat, bandwhich)
source ~/.cargo/env
cargo install fd-find ripgrep bat bandwhich
# Install Go‑based tools (lazydocker)
export PATH=$PATH:/usr/local/go/bin:~/go/bin
go install github.com/jesseduffield/lazydocker@latest
# Install other utilities (btop, dstat, glances, HTTPie, diff‑so‑fancy, ctop, dive)
sudo dnf install -y btop dstat glances httpie   # or apt equivalents
npm install -g diff-so-fancy
wget -q https://github.com/bcicen/ctop/releases/download/v0.7.7/ctop-0.7.7-linux-amd64 -O /tmp/ctop && sudo mv /tmp/ctop /usr/local/bin/ctop && sudo chmod +x /usr/local/bin/ctop
wget -q https://github.com/wagoodman/dive/releases/download/v0.12.0/dive_0.12.0_linux_amd64.tar.gz -O /tmp/dive.tar.gz && tar -xzf /tmp/dive.tar.gz -C /tmp && sudo mv /tmp/dive /usr/local/bin/

Configuration Files

Sample snippets for .zshrc, .tmux.conf, and starship.toml illustrate how to enable the prompt, set useful aliases, and customize the appearance.

# ~/.zshrc (excerpt)
plugins=(git docker kubectl zsh-autosuggestions zsh-syntax-highlighting)
eval "$(starship init zsh)"
export FZF_DEFAULT_OPTS='--height 60% --layout=reverse --border'
alias ll='ls -alh'
alias cat='bat --paging=never'
# ~/.tmux.conf (excerpt)
set -g prefix C
unbind C-b
bind C send-prefix
set -g mouse on
# ~/.config/starship.toml (excerpt)
format = "${username}@${hostname} ${directory} ${git_branch} ${git_state} ${cmd_duration} $
$"

Tool Usage Examples

Terminal Enhancements

Examples show how to switch sessions, split panes, and use fzf with a custom preview that leverages bat for syntax‑highlighted file display.

# tmux session management
tmux new -s work          # create a new session
tmux attach -t work       # attach to an existing session
# fzf with bat preview
fzf --preview 'bat --style=numbers --color=always {}'

File Handling

Use fd as a fast replacement for find, rg for recursive content search, and bat for colorful file cat.

# Find all Go files under src
fd -e go src/
# Search for the word "error" in logs, showing 5 context lines
rg -C 5 "error" /var/log/*.log
# View a log file with line numbers and syntax highlighting
bat /var/log/syslog

System Monitoring

Launch htop, btop, dstat, or glances for interactive monitoring. The article lists useful key bindings for each tool.

# Real‑time system view
htop
btop
# dstat with custom modules
dstat -cdngy --top-cpu
# Glances web UI (default port 61208)
glances -w

Network Diagnostics

Run mtr for traceroute‑style diagnostics, http (HTTPie) for quick API calls, and bandwhich for per‑process bandwidth monitoring.

# Trace the route to google.com
mtr -r -c 20 google.com
# Simple GET request with JSON output
http GET https://api.github.com/repos/ohmyzsh/ohmyzsh
# Interactive bandwidth monitor (requires sudo)
sudo bandwhich

Text Processing

Parse JSON logs with jq, navigate large log files with lnav, and beautify Git diffs using diff‑so‑fancy.

# Extract all error messages from a JSON log
cat logs.json | jq -r '.items[] | select(.level=="error") | .message'
# Open multiple logs in lnav
lnav /var/log/nginx/*.log
# View a Git diff with colors
git diff | diff-so-fancy | less -R

Container Operations

Manage Docker containers with lazydocker, monitor resource usage with ctop, and analyze image layers using dive.

# Start the lazydocker UI
lazydocker
# Sort containers by CPU usage in ctop
ctop -s cpu
# Inspect an image interactively
dive nginx:latest

Best Practices and Caveats

Performance Optimisation

Use fd as the default search backend for fzf to gain a ten‑fold speed increase. Configure ripgrep with a .rgignore file to skip irrelevant paths. Enable tmux pipelining to reduce SSH latency, and lower the refresh interval of glances to minimise its own CPU usage.

Security Hardening

Set HISTIGNORE to omit sensitive commands from shell history, lock idle tmux sessions, enable SSH agent forwarding with AddKeysToAgent yes, and alias destructive commands (rm, mv, cp) with interactive prompts.

High‑Availability Tips

Install the tmux‑resurrect and tmux‑continuum plugins to automatically save and restore sessions, ensuring that long‑running workspaces survive reboots or disconnections.

Troubleshooting

Common Issues

Command not found: Verify that ~/.local/bin and language‑specific bin directories are in $PATH.

Permission denied: Check file permissions or prepend sudo where required.

Color glitches: Ensure TERM=xterm-256color and install a Nerd Font.

Slow SSH: Enable ControlMaster multiplexing in ~/.ssh/config.

Diagnostic Commands

# Verify installed tools
for tool in zsh starship tmux fzf fd rg bat htop btop dstat glances mtr http bandwhich jq lnav diff-so-fancy lazydocker ctop dive; do
  cmd=$(echo $tool | cut -d' ' -f1)
  if command -v $cmd &>/dev/null; then
    echo "[OK] $cmd: $($tool --version 2>/dev/null | head -1)"
  else
    echo "[MISSING] $cmd"
  fi
done

Conclusion

The curated toolbox equips sysadmins with modern, high‑performance utilities that replace legacy commands, provide richer visual feedback, and integrate seamlessly into automated workflows. By adopting these tools and the accompanying configuration patterns, teams can reduce manual effort, minimise errors, and maintain a more observable and resilient production environment.