KubeQuest

Appearance

Tool Installations ​

Concise install instructions for a full development workstation. Linux-focused (adapt for macOS/Windows as needed). Each tool uses official install channels.

Quick Checklist ​

Languages and Runtimes

  • [ ] Node.js (via nvm)
  • [ ] Go (official tarball)

Editors

  • [ ] Zed (official install script)
  • [ ] VS Code (Microsoft APT repo)

Container and Kubernetes

  • [ ] Docker (convenience script)
  • [ ] kubectl (official binary)
  • [ ] kind (Kubernetes IN Docker)
  • [ ] Minikube (alternative to kind)
  • [ ] Helm (package manager)

Cloud CLIs

  • [ ] Azure CLI (Microsoft APT repo)
  • [ ] AWS CLI (official installer)

Infrastructure as Code

  • [ ] Terraform (HashiCorp binary)
  • [ ] OpenTofu (open-source Terraform fork)
  • [ ] Vagrant (HashiCorp APT repo)

CLI Utilities

  • [ ] jq / yq (JSON/YAML processing)
  • [ ] ripgrep (fast search)
  • [ ] fzf (fuzzy finder)
  • [ ] bat (better cat)
  • [ ] eza (better ls)
  • [ ] fd (better find)
  • [ ] tldr (simplified man pages)
  • [ ] kubectx + kubens (k8s context/namespace switching)
  • [ ] k9s (terminal k8s UI)
  • [ ] lazygit (terminal git UI)
  • [ ] lazydocker (terminal docker UI)
  • [ ] tmux (terminal multiplexer)
  • [ ] htop / btop (process viewers)
  • [ ] curlie (better curl)

Languages and Runtimes ​

Node.js (via nvm) ​

Use nvm to manage Node.js versions. This is the recommended approach over system package managers.

bash
# Install nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

# Reload shell
source ~/.bashrc  # or ~/.zshrc

# Install latest LTS
nvm install --lts
nvm use --lts

# Verify
node --version
npm --version

# Set default
nvm alias default node

TIP

nvm lets you switch between Node versions per project. Use nvm install 20 for a specific version, nvm ls to list installed versions.

Go ​

Install from the official Go downloads. Always use the latest stable.

bash
# Download and extract (update version as needed)
GO_VERSION="1.23.5"
wget "https://go.dev/dl/go${GO_VERSION}.linux-amd64.tar.gz"
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf "go${GO_VERSION}.linux-amd64.tar.gz"
rm "go${GO_VERSION}.linux-amd64.tar.gz"

# Add to PATH (add to ~/.bashrc or ~/.zshrc)
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bashrc
source ~/.bashrc

# Verify
go version
go env GOPATH

TIP

$HOME/go/bin is where go install puts binaries. Adding it to PATH lets you run tools installed with go install directly.

Editors ​

Zed ​

Zed is a high-performance editor built in Rust with native GPU rendering. Install from the official channel:

bash
# Official install script (recommended)
curl -f https://zed.dev/install.sh | sh

# Verify
zed --version

Zed updates automatically. The install script adds the binary to ~/.local/bin/zed.

Manual install (alternative)

Download from zed.dev/download and extract to ~/.local/:

bash
# Download the latest release
wget "https://zed.dev/api/releases/stable/latest/zed-linux-x86_64.tar.gz"
tar -xzf zed-linux-x86_64.tar.gz -C ~/.local/
rm zed-linux-x86_64.tar.gz

VS Code ​

Install from Microsoft's official APT repository (not snap):

bash
# Import Microsoft GPG key and repo
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -D -o root -g root -m 644 packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg
echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" | sudo tee /etc/apt/sources.list.d/vscode.list > /dev/null
rm -f packages.microsoft.gpg

# Install
sudo apt update
sudo apt install -y code

# Verify
code --version

TIP

This gives you the official Microsoft build with auto-updates via apt. Avoid the snap version - it has filesystem access limitations.

Container and Kubernetes ​

Docker ​

Quick install via the official convenience script:

bash
curl -fsSL https://get.docker.com | sh

# Post-install: run without sudo
sudo usermod -aG docker $USER
newgrp docker  # or log out and back in

# Start and enable
sudo systemctl start docker
sudo systemctl enable docker

# Verify
docker version
docker run --rm hello-world

kubectl ​

Install the latest stable binary from kubernetes.io:

bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
rm kubectl

# Verify
kubectl version --client

kind (Kubernetes IN Docker) ​

Create throwaway clusters for testing:

bash
# Install latest from GitHub releases
go install sigs.k8s.io/kind@latest
# Or download binary directly:
# curl -Lo ./kind "https://kind.sigs.k8s.io/dl/v0.25.0/kind-linux-amd64"
# chmod +x ./kind && sudo mv ./kind /usr/local/bin/kind

# Create a cluster
kind create cluster --name dev
kubectl cluster-info --context kind-dev

# Verify
kind --version

Minikube ​

Single-node cluster alternative to kind:

bash
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/

minikube start --driver=docker
minikube status

Helm ​

Kubernetes package manager:

bash
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Verify
helm version

Cloud CLIs ​

Azure CLI ​

Install from Microsoft's official APT repo:

bash
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Verify
az version
az login

AWS CLI ​

Install from AWS official installer:

bash
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
rm -rf aws awscliv2.zip

# Verify
aws --version

Infrastructure as Code ​

Terraform ​

Install from HashiCorp releases:

bash
TERRAFORM_VERSION="1.10.4"
wget "https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_linux_amd64.zip"
unzip "terraform_${TERRAFORM_VERSION}_linux_amd64.zip"
sudo mv terraform /usr/local/bin/
rm "terraform_${TERRAFORM_VERSION}_linux_amd64.zip"

# Verify
terraform version

OpenTofu ​

Open-source fork of Terraform, managed by the Linux Foundation:

bash
# Official install script
curl --proto '=https' --tlsv1.2 -fsSL https://get.opentofu.org/install-opentofu.sh -o install-opentofu.sh
chmod +x install-opentofu.sh
./install-opentofu.sh --install-method deb
rm install-opentofu.sh

# Verify
tofu version

Vagrant ​

VM provisioning tool from HashiCorp. Install from the official APT repository:

bash
# Add HashiCorp GPG key and repo
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" \
  | sudo tee /etc/apt/sources.list.d/hashicorp.list > /dev/null

# Install
sudo apt update
sudo apt install -y vagrant

# Verify
vagrant --version

TIP

Vagrant needs a provider - VirtualBox, libvirt, or Docker. For Linux, libvirt is recommended:

bash
sudo apt install -y vagrant-libvirt qemu-kvm libvirt-daemon-system
vagrant plugin install vagrant-libvirt

CLI Utilities ​

jq and yq ​

JSON and YAML processors - essential for working with Kubernetes manifests, API responses, and config files:

bash
# jq - JSON processor
sudo apt install -y jq

# yq - YAML processor (by Mike Farah, Go-based)
go install github.com/mikefarah/yq/v4@latest
# Or download binary:
# wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O yq
# chmod +x yq && sudo mv yq /usr/local/bin/

# Verify
jq --version
yq --version

ripgrep ​

Faster than grep, respects .gitignore:

bash
sudo apt install -y ripgrep

# Verify
rg --version

fzf ​

Fuzzy finder for files, history, processes - integrates with shell:

bash
# Official git install (includes shell integrations)
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install --all

# Verify
fzf --version

TIP

After install, press Ctrl+R for fuzzy history search, Ctrl+T for file finder, Alt+C for directory jump.

bat ​

cat with syntax highlighting and git integration:

bash
sudo apt install -y bat
# Note: on Ubuntu, the binary is 'batcat' due to name conflict
# Create alias or symlink:
mkdir -p ~/.local/bin
ln -sf /usr/bin/batcat ~/.local/bin/bat

# Verify
bat --version

eza ​

Modern replacement for ls with icons, git status, and tree view:

bash
sudo apt install -y eza
# If not available in apt, install from cargo:
# cargo install eza

# Verify
eza --version

# Useful aliases (add to ~/.bashrc):
# alias ls='eza --icons'
# alias ll='eza -la --icons --git'
# alias tree='eza --tree --icons'

fd ​

Fast, user-friendly alternative to find:

bash
sudo apt install -y fd-find
# Ubuntu names it fdfind - create symlink:
mkdir -p ~/.local/bin
ln -sf /usr/bin/fdfind ~/.local/bin/fd

# Verify
fd --version

tldr ​

Simplified, practical man pages with examples:

bash
# Via npm (if Node.js installed)
npm install -g tldr

# Or via pip
# pip3 install tldr

# Verify
tldr --version
tldr tar  # example usage

kubectx and kubens ​

Fast Kubernetes context and namespace switching:

bash
# Via go install
go install github.com/ahmetb/kubectx/cmd/kubectx@latest
go install github.com/ahmetb/kubectx/cmd/kubens@latest

# Verify
kubectx --help
kubens --help

k9s ​

Terminal UI for Kubernetes - monitor pods, logs, exec into containers:

bash
go install github.com/derailed/k9s@latest

# Verify
k9s version

lazygit ​

Terminal UI for git - staging, committing, branching, rebasing:

bash
go install github.com/jesseduffield/lazygit@latest

# Verify
lazygit --version

lazydocker ​

Terminal UI for Docker - containers, images, volumes, logs:

bash
go install github.com/jesseduffield/lazydocker@latest

# Verify
lazydocker --version

tmux ​

Terminal multiplexer - split panes, detachable sessions:

bash
sudo apt install -y tmux

# Verify
tmux -V

htop and btop ​

Interactive process viewers:

bash
sudo apt install -y htop btop

# Verify
htop --version
btop --version

curlie ​

curl with httpie-like output but curl-compatible flags:

bash
go install github.com/rs/curlie@latest

# Verify
curlie --version

Git ​

bash
sudo apt install -y git

# Configure
git config --global user.name "Your Name"
git config --global user.email "your@email.com"
git config --global init.defaultBranch main

# Verify
git --version

Automation Script ​

The install script at scripts/install-deps.sh is modular - each group lives in its own file under scripts/modules/:

scripts/
  install-deps.sh        # Main orchestrator
  modules/
    languages.sh         # Node.js, Go
    editors.sh           # Zed, VS Code
    containers.sh        # Docker, kubectl, kind, Minikube, Helm
    cloud.sh             # Azure CLI, AWS CLI
    iac.sh               # Terraform, OpenTofu, Vagrant
    utilities.sh         # jq, yq, ripgrep, fzf, bat, eza, fd, tldr,
                         # kubectx, k9s, lazygit, lazydocker, etc.

Usage ​

bash
chmod +x scripts/install-deps.sh

# Install by group
./scripts/install-deps.sh --languages --editors
./scripts/install-deps.sh --containers --iac
./scripts/install-deps.sh --utils

# Install individual tools
./scripts/install-deps.sh --node --go --vagrant --vscode

# Install everything
./scripts/install-deps.sh --all

# Dry run - see what would happen
./scripts/install-deps.sh --dry-run --all

# Check what's installed
./scripts/install-deps.sh --verify

The script checks if tools are already installed, supports --dry-run mode, and prompts before running.

Environment Notes ​

  • WSL2: Docker Desktop + WSL2 integration recommended. Or use native Docker Engine in WSL. host.docker.internal may behave differently - use explicit IPs.
  • PATH priority: Tools in ~/.local/bin and $HOME/go/bin should be in your PATH. Add to ~/.bashrc:
    bash
    export PATH="$HOME/.local/bin:$HOME/go/bin:/usr/local/go/bin:$PATH"
  • Shell reload: After modifying ~/.bashrc, run source ~/.bashrc or open a new terminal.

Released under the MIT License.

Copyright © 2026 OpsAlchemy