How to Install and Set Up kubectl on Linux?

kubectl (pronounced “kube-control” or “kube-c-t-l”) is the command-line tool for interacting with Kubernetes clusters. Whether you’re managing containers, deploying applications, or troubleshooting cluster issues, kubectl is your primary interface to the Kubernetes API server.

In this comprehensive guide, you’ll learn multiple methods to install kubectl on Linux, configure it properly, and start managing your Kubernetes clusters like a pro.

What is kubectl?

kubectl is the Kubernetes command-line client that allows you to:

Deploy and manage applications on Kubernetes
Inspect cluster resources and logs
Create, update, and delete Kubernetes objects
Troubleshoot cluster issues
Execute commands inside containers

Prerequisites

Before installing kubectl, ensure you have:

A Linux distribution (Ubuntu, Debian, RHEL, CentOS, or Fedora)
Root or sudo privileges
Internet connectivity
Basic familiarity with terminal commands

System Requirements:

Minimum 2GB RAM
1GB free disk space
Linux kernel version 3.10+

Method 1: Install kubectl Using Native Package Management

For Debian/Ubuntu-based Systems

This is the recommended method for Ubuntu and Debian users as it ensures automatic updates.

Step 1: Update Package Index

sudo apt-get update

Step 2: Install Required Dependencies

sudo apt-get install -y apt-transport-https ca-certificates curl gnupg

Step 3: Add Kubernetes APT Repository

# Download the Kubernetes signing key
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.31/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

# Add Kubernetes repository
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.31/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

Step 4: Install kubectl

sudo apt-get update
sudo apt-get install -y kubectl

Step 5: Verify Installation

kubectl version --client

Expected Output:

Client Version: v1.31.0
Kustomize Version: v5.4.2

For RHEL/CentOS/Fedora Systems

Step 1: Add Kubernetes YUM Repository

cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo

[kubernetes]

name=Kubernetes baseurl=https://pkgs.k8s.io/core:/stable:/v1.31/rpm/ enabled=1 gpgcheck=1 gpgkey=https://pkgs.k8s.io/core:/stable:/v1.31/rpm/repodata/repomd.xml.key EOF

Step 2: Install kubectl

sudo yum install -y kubectl

Or for Fedora:

sudo dnf install -y kubectl

Step 3: Verify Installation

kubectl version --client --output=yaml

Method 2: Install kubectl Binary Directly

This method gives you more control over the kubectl version and doesn’t require package manager configuration.

Download the Latest Stable Release

# Download the latest stable release
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Download a Specific Version

# Replace v1.31.0 with your desired version
curl -LO "https://dl.k8s.io/release/v1.31.0/bin/linux/amd64/kubectl"

Validate the Binary (Optional but Recommended)

# Download the checksum file
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"

# Validate against the checksum
echo "$(cat kubectl.sha256)  kubectl" | sha256sum --check

Expected Output:

kubectl: OK

Install kubectl Binary

# Make the binary executable
chmod +x kubectl

# Move to system path
sudo mv kubectl /usr/local/bin/

# Verify installation
kubectl version --client

Method 3: Install kubectl Using Snap

Snap provides an easy installation method with automatic updates.

# Install kubectl via snap
sudo snap install kubectl --classic

# Verify installation
kubectl version --client

Note: The --classic flag is required as kubectl needs access to system resources.

Method 4: Install kubectl Using Docker

If you already have Docker installed, you can use kubectl via a container.

Create an Alias

# Add to your ~/.bashrc or ~/.zshrc
alias kubectl='docker run --rm -it -v ~/.kube:/root/.kube -v $(pwd):/work -w /work bitnami/kubectl:latest'

# Reload shell configuration
source ~/.bashrc

# Use kubectl
kubectl version --client

Post-Installation Configuration

1. Enable kubectl Autocompletion

Autocompletion makes working with kubectl much faster and reduces typos.

For Bash

# Install bash-completion if not already installed
sudo apt-get install bash-completion

# Enable kubectl autocompletion for current session
source <(kubectl completion bash)

# Add to your .bashrc for persistence
echo 'source <(kubectl completion bash)' >>~/.bashrc

# Create alias with autocompletion
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -o default -F __start_kubectl k' >>~/.bashrc

For Zsh

# Enable autocompletion
source <(kubectl completion zsh)

# Add to your .zshrc
echo 'source <(kubectl completion zsh)' >>~/.zshrc

# Create alias
echo 'alias k=kubectl' >>~/.zshrc
echo 'compdef __start_kubectl k' >>~/.zshrc

2. Configure kubectl Context

kubectl uses a configuration file (kubeconfig) to connect to clusters. The default location is ~/.kube/config.

View Current Configuration

kubectl config view

Set Default Namespace

kubectl config set-context --current --namespace=development

List Available Contexts

kubectl config get-contexts

Switch Between Contexts

kubectl config use-context production-cluster

3. Create a Basic kubeconfig File

If you’re connecting to a new cluster, you’ll need to configure your kubeconfig:

# Create .kube directory
mkdir -p ~/.kube

# Create a basic config file
cat <<EOF > ~/.kube/config
apiVersion: v1
kind: Config
clusters:
- cluster:
    certificate-authority-data: <CA_CERT>
    server: https://kubernetes.example.com:6443
  name: my-cluster
contexts:
- context:
    cluster: my-cluster
    user: my-user
    namespace: default
  name: my-context
current-context: my-context
users:
- name: my-user
  user:
    client-certificate-data: <CLIENT_CERT>
    client-key-data: <CLIENT_KEY>
EOF

# Set proper permissions
chmod 600 ~/.kube/config

Essential kubectl Commands for Beginners

Now that kubectl is installed, here are some essential commands to get started:

Cluster Information

# Check cluster information
kubectl cluster-info

# View cluster nodes
kubectl get nodes

# Get detailed node information
kubectl describe node <node-name>

Working with Pods

# List all pods in current namespace
kubectl get pods

# List pods in all namespaces
kubectl get pods --all-namespaces

# Get detailed pod information
kubectl describe pod <pod-name>

# View pod logs
kubectl logs <pod-name>

# Execute command in a pod
kubectl exec -it <pod-name> -- /bin/bash

Managing Deployments

# Create a deployment
kubectl create deployment nginx --image=nginx

# List deployments
kubectl get deployments

# Scale a deployment
kubectl scale deployment nginx --replicas=3

# Update deployment image
kubectl set image deployment/nginx nginx=nginx:1.21

# View deployment status
kubectl rollout status deployment/nginx

Working with Services

# Expose a deployment
kubectl expose deployment nginx --port=80 --type=LoadBalancer

# List services
kubectl get services

# Get service details
kubectl describe service nginx

Advanced Configuration Tips

1. Use kubectl Plugins with Krew

Krew is a plugin manager for kubectl that extends its functionality.

# Install krew
(
  set -x; cd "$(mktemp -d)" &&
  OS="$(uname | tr '[:upper:]' '[:lower:]')" &&
  ARCH="$(uname -m | sed -e 's/x86_64/amd64/' -e 's/\(arm\)\(64\)\?.*/\1\2/' -e 's/aarch64$/arm64/')" &&
  KREW="krew-${OS}_${ARCH}" &&
  curl -fsSLO "https://github.com/kubernetes-sigs/krew/releases/latest/download/${KREW}.tar.gz" &&
  tar zxvf "${KREW}.tar.gz" &&
  ./"${KREW}" install krew
)

# Add to PATH
echo 'export PATH="${KREW_ROOT:-$HOME/.krew}/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

# Install useful plugins
kubectl krew install ctx      # Switch contexts
kubectl krew install ns       # Switch namespaces
kubectl krew install tree     # Show resource hierarchy

2. Set Up kubectl Aliases

Create shortcuts for frequently used commands:

# Add to ~/.bashrc or ~/.zshrc
alias k='kubectl'
alias kgp='kubectl get pods'
alias kgd='kubectl get deployments'
alias kgs='kubectl get services'
alias kgn='kubectl get nodes'
alias kdp='kubectl describe pod'
alias kdd='kubectl describe deployment'
alias klf='kubectl logs -f'
alias kex='kubectl exec -it'
alias kaf='kubectl apply -f'
alias kdelf='kubectl delete -f'

3. Configure Multiple Clusters

# Add a new cluster
kubectl config set-cluster production \
  --server=https://prod.example.com:6443 \
  --certificate-authority=/path/to/ca.crt

# Add user credentials
kubectl config set-credentials prod-user \
  --client-certificate=/path/to/client.crt \
  --client-key=/path/to/client.key

# Create context
kubectl config set-context prod-context \
  --cluster=production \
  --user=prod-user \
  --namespace=production

# Use the context
kubectl config use-context prod-context

Troubleshooting Common Issues

Issue 1: “kubectl: command not found”

Solution: Ensure kubectl is in your PATH.

# Check if kubectl is installed
which kubectl

# If not in PATH, add to ~/.bashrc
echo 'export PATH=$PATH:/usr/local/bin' >> ~/.bashrc
source ~/.bashrc

Issue 2: “Unable to connect to the server”

Solution: Check your kubeconfig and cluster connectivity.

# Verify kubeconfig
kubectl config view

# Check cluster endpoint
ping <cluster-endpoint>

# Verify kubectl can reach the API server
kubectl cluster-info

Issue 3: Permission Denied Errors

Solution: Check kubeconfig file permissions.

# Set correct permissions
chmod 600 ~/.kube/config

# Verify ownership
ls -la ~/.kube/config

Issue 4: Version Mismatch Warning

Solution: Ensure kubectl version is within one minor version of cluster.

# Check kubectl version
kubectl version --client

# Check server version
kubectl version --short

# Upgrade kubectl if needed
sudo apt-get update && sudo apt-get install --only-upgrade kubectl

Testing Your kubectl Installation

Create a simple test to ensure everything works:

1. Create a Test Namespace

kubectl create namespace kubectl-test

2. Deploy a Sample Application

kubectl create deployment hello-world \
  --image=gcr.io/google-samples/hello-app:1.0 \
  --namespace=kubectl-test

3. Verify Deployment

kubectl get all -n kubectl-test

4. Clean Up

kubectl delete namespace kubectl-test

Best Practices for kubectl Usage

Always specify namespace to avoid accidental changes to the default namespace
Use --dry-run=client -o yaml to preview changes before applying
Enable audit logging for production clusters
Use RBAC to limit kubectl access based on user roles
Keep kubectl updated within one minor version of your cluster
Use labels and selectors for efficient resource management
Store kubeconfig securely and never commit to version control

Example: Dry Run Before Applying

# Preview what will be created
kubectl create deployment test --image=nginx \
  --dry-run=client -o yaml

# Apply only after verification
kubectl create deployment test --image=nginx

kubectl with Docker Desktop and Minikube

Using kubectl with Docker Desktop

If you have Docker Desktop installed with Kubernetes enabled:

# Check Docker Desktop Kubernetes context
kubectl config get-contexts

# Switch to Docker Desktop context
kubectl config use-context docker-desktop

# Verify connection
kubectl get nodes

Using kubectl with Minikube

# Start minikube
minikube start

# Minikube automatically configures kubectl
kubectl get nodes

# View minikube dashboard
minikube dashboard

Security Considerations

1. Secure Your kubeconfig

# Encrypt kubeconfig at rest
gpg -c ~/.kube/config

# Use temporary credentials
kubectl config set-credentials temp-user \
  --token=$(cat /tmp/token) \
  --client-certificate=/dev/null

2. Use Service Accounts

# Create service account
kubectl create serviceaccount my-service-account

# Create role binding
kubectl create rolebinding my-role-binding \
  --clusterrole=view \
  --serviceaccount=default:my-service-account

3. Audit kubectl Commands

Enable kubectl audit logging for compliance:

# Add to .bashrc for command logging
export KUBECTL_EXTERNAL_DIFF="diff -u"
alias kubectl='kubectl --v=6'

Upgrading kubectl

Using Package Manager (Recommended)

# For Ubuntu/Debian
sudo apt-get update
sudo apt-get install --only-upgrade kubectl

# For RHEL/CentOS/Fedora
sudo yum update kubectl

Manual Binary Upgrade

# Download latest version
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

# Replace existing binary
sudo mv kubectl /usr/local/bin/kubectl
chmod +x /usr/local/bin/kubectl

# Verify upgrade
kubectl version --client

Uninstalling kubectl

If you need to remove kubectl:

For APT-based Systems

sudo apt-get remove kubectl
sudo apt-get purge kubectl

For YUM/DNF-based Systems

sudo yum remove kubectl

For Binary Installation

sudo rm /usr/local/bin/kubectl

Clean Up Configuration

rm -rf ~/.kube

Conclusion

You’ve successfully installed and configured kubectl on your Linux system! You’re now ready to manage Kubernetes clusters, deploy applications, and troubleshoot issues using the command line.

Quick Recap

✅ Installed kubectl using multiple methods
✅ Configured autocompletion for faster workflows
✅ Set up kubeconfig for cluster access
✅ Learned essential kubectl commands
✅ Implemented best practices and security measures

Next Steps

Deploy Your First Application – Try creating a deployment and service
Learn Kubernetes Objects – Understand Pods, Deployments, Services, and ConfigMaps
Explore kubectl Plugins – Extend functionality with Krew plugins
Practice with Minikube – Set up a local Kubernetes cluster for testing
Join the Collabnix Community – Connect with 17,000+ DevOps enthusiasts on Collabnix Slack