Convert Figma logo to code with AI

ahmetb logokubectx

Faster way to switch between clusters and namespaces in kubectl

17,537
1,253
17,537
60

Top Related Projects

26,434

🐶 Kubernetes CLI To Manage Your Clusters In Style!

22,461

Lens - The way the world runs Kubernetes

3,207

⎈ Multi pod and container log tailing for Kubernetes -- Friendly fork of https://github.com/wercker/stern

6,327

📦 Find and install kubectl plugins

6,280

Highly extensible platform for developers to better understand the complexity of Kubernetes clusters.

3,755

Bulk port forwarding Kubernetes services for local development.

Quick Overview

kubectx is a command-line utility designed to enhance the Kubernetes user experience by simplifying the management of multiple Kubernetes contexts and namespaces. It provides an easy way to switch between clusters and namespaces, improving workflow efficiency for developers and operators working with Kubernetes.

Pros

  • Streamlines context and namespace switching in Kubernetes environments
  • Offers interactive menus for easier selection of contexts and namespaces
  • Integrates well with shell environments and supports various shells (bash, zsh, fish)
  • Lightweight and easy to install with minimal dependencies

Cons

  • Limited functionality beyond context and namespace switching
  • May require additional setup for some shell integrations
  • Not a native Kubernetes tool, which means it's an extra utility to maintain
  • Might be unnecessary for users working with a single Kubernetes cluster

Getting Started

To install kubectx and kubens on macOS using Homebrew:

brew install kubectx

For other installation methods, visit the project's GitHub repository.

Basic usage:

# List available contexts
kubectx

# Switch to a different context
kubectx my-cluster-name

# List available namespaces
kubens

# Switch to a different namespace
kubens my-namespace

For interactive mode, use the -i flag:

kubectx -i
kubens -i

Competitor Comparisons

26,434

🐶 Kubernetes CLI To Manage Your Clusters In Style!

Pros of k9s

  • Offers a rich, interactive terminal UI for managing Kubernetes clusters
  • Provides real-time monitoring and resource management capabilities
  • Supports multiple views and customizable keyboard shortcuts for efficient navigation

Cons of k9s

  • Steeper learning curve due to more complex interface and features
  • Requires more system resources to run compared to the lightweight kubectx
  • May be overwhelming for users who only need simple context switching

Code Comparison

kubectx:

kubectx my-cluster
kubens my-namespace

k9s:

k9s
# Navigate using arrow keys and shortcuts
# Press ':' to enter command mode
:context my-cluster
:namespace my-namespace

Summary

kubectx is a lightweight tool focused on quick context and namespace switching, while k9s is a comprehensive Kubernetes management tool with a feature-rich terminal UI. kubectx is simpler to use and requires fewer resources, making it ideal for basic operations. k9s offers more advanced features and real-time monitoring but has a steeper learning curve. The choice between the two depends on the user's needs and preferences for managing Kubernetes clusters.

22,461

Lens - The way the world runs Kubernetes

Pros of Lens

  • Provides a full-featured GUI for managing Kubernetes clusters
  • Offers real-time cluster monitoring and resource visualization
  • Includes built-in terminal and log viewing capabilities

Cons of Lens

  • Requires more system resources due to its graphical interface
  • Has a steeper learning curve for users new to Kubernetes
  • May be overkill for simple context switching tasks

Code Comparison

While a direct code comparison isn't particularly relevant due to the different nature of these tools, we can look at how they approach context switching:

kubectx:

kubectx my-cluster

Lens:

// Context switching is done through the GUI, but the underlying API call might look like:
api.switchContext('my-cluster');

Summary

kubectx is a lightweight CLI tool focused on quick context and namespace switching, while Lens is a comprehensive Kubernetes IDE with a graphical interface. kubectx is ideal for users who prefer command-line operations and quick context changes, whereas Lens provides a more visual and feature-rich experience for managing Kubernetes clusters. The choice between them depends on the user's specific needs and workflow preferences.

3,207

⎈ Multi pod and container log tailing for Kubernetes -- Friendly fork of https://github.com/wercker/stern

Pros of stern

  • Focuses on log tailing across multiple pods, providing a more specialized and powerful logging solution
  • Offers color-coded output for easier log reading and differentiation
  • Supports regular expressions for pod name matching, allowing for more flexible log filtering

Cons of stern

  • Limited to log-related operations, lacking broader cluster management features
  • May require additional tools for complete Kubernetes workflow management
  • Steeper learning curve for users who need a simple context-switching solution

Code comparison

stern:

stern pod-query [flags]

kubectx:

kubectx [<context_name>]
kubens [<namespace_name>]

Summary

stern is a specialized tool for tailing logs from multiple Kubernetes pods, offering advanced filtering and colorized output. It excels in log management but has a narrower focus compared to kubectx.

kubectx provides a broader set of utilities for managing Kubernetes contexts and namespaces, making it more versatile for general cluster management tasks. However, it lacks the advanced logging capabilities of stern.

The choice between these tools depends on the specific needs of the user. stern is ideal for developers and operators who require detailed log analysis, while kubectx is better suited for users who frequently switch between different Kubernetes contexts and namespaces.

6,327

📦 Find and install kubectl plugins

Pros of krew

  • Broader plugin ecosystem: Krew is a plugin manager for kubectl, offering a wide range of plugins beyond just context and namespace switching
  • Official Kubernetes SIG project: Being part of kubernetes-sigs gives it more visibility and community support
  • Standardized plugin installation and management: Provides a consistent way to discover, install, and manage kubectl plugins

Cons of krew

  • More complex setup: Requires installation of Krew itself before accessing plugins
  • Potentially overwhelming for new users: The large number of available plugins might be confusing for those just starting with Kubernetes

Code comparison

kubectx:

# Switch context
kubectx my-context

# Switch namespace
kubens my-namespace

krew:

# Install a plugin
kubectl krew install ctx

# Use the installed plugin
kubectl ctx my-context

Summary

While kubectx focuses specifically on context and namespace switching with a simple, easy-to-use interface, krew offers a more comprehensive plugin management system for kubectl. kubectx is more straightforward for users who only need context and namespace management, while krew provides a broader range of functionality through its plugin ecosystem. The choice between the two depends on the user's specific needs and familiarity with Kubernetes tooling.

6,280

Highly extensible platform for developers to better understand the complexity of Kubernetes clusters.

Pros of Octant

  • Provides a rich, interactive web-based UI for visualizing Kubernetes clusters
  • Offers a more comprehensive view of cluster resources and their relationships
  • Supports plugins for extending functionality and customizing views

Cons of Octant

  • Requires more setup and resources to run compared to the lightweight kubectx
  • Has a steeper learning curve due to its more complex interface and features
  • Less suitable for quick command-line operations and context switching

Code Comparison

kubectx:

kubectx my-cluster
kubectx -
kubectx -c

Octant:

apiVersion: config.octant.dev/v1alpha1
kind: Plugin
metadata:
  name: my-plugin

Summary

kubectx is a lightweight command-line tool for managing and switching between Kubernetes contexts quickly. It's ideal for users who prefer simple, fast context switching from the terminal.

Octant, on the other hand, is a more comprehensive web-based dashboard for visualizing and managing Kubernetes clusters. It offers a richer set of features and a graphical interface, making it suitable for users who need a detailed overview of their cluster resources and relationships.

The choice between the two depends on the user's specific needs, workflow preferences, and the level of detail required for cluster management.

3,755

Bulk port forwarding Kubernetes services for local development.

Pros of kubefwd

  • Provides port forwarding for multiple services simultaneously
  • Allows access to Kubernetes services as if they were running locally
  • Supports namespaces and label selectors for flexible service targeting

Cons of kubefwd

  • More complex setup and usage compared to kubectx
  • Requires root/sudo access for modifying /etc/hosts
  • May introduce network overhead due to port forwarding

Code Comparison

kubefwd:

sudo kubefwd services -n mynamespace

kubectx:

kubectx my-cluster
kubectl config set-context --current --namespace=mynamespace

Key Differences

kubefwd focuses on port forwarding and local access to Kubernetes services, while kubectx is primarily used for managing and switching between Kubernetes contexts and namespaces. kubefwd is more suited for developers who need to interact with multiple services locally, whereas kubectx is ideal for users who frequently switch between different clusters or namespaces.

kubefwd requires more system-level access and may have a steeper learning curve, but it provides a more comprehensive local development environment for Kubernetes services. kubectx, on the other hand, is simpler to use and doesn't require elevated permissions, making it more suitable for quick context and namespace management tasks.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

kubectx + kubens: Power tools for kubectl

Latest GitHub release GitHub stars Homebrew downloads Go implementation (CI) Proudly written in Bash

This repository provides both kubectx and kubens tools. Install →

What are kubectx and kubens?

kubectx is a tool to switch between contexts (clusters) on kubectl faster.
kubens is a tool to switch between Kubernetes namespaces (and configure them for kubectl) easily.

Here's a kubectx demo: kubectx demo GIF

...and here's a kubens demo: kubens demo GIF

Examples

# switch to another cluster that's in kubeconfig
$ kubectx minikube
Switched to context "minikube".

# switch back to previous cluster
$ kubectx -
Switched to context "oregon".

# rename context
$ kubectx dublin=gke_ahmetb_europe-west1-b_dublin
Context "gke_ahmetb_europe-west1-b_dublin" renamed to "dublin".

# change the active namespace on kubectl
$ kubens kube-system
Context "test" set.
Active namespace is "kube-system".

# go back to the previous namespace
$ kubens -
Context "test" set.
Active namespace is "default".

# change the active namespace even if it doesn't exist
$ kubens not-found-namespace --force
Context "test" set.
Active namespace is "not-found-namespace".
---
$ kubens not-found-namespace -f
Context "test" set.
Active namespace is "not-found-namespace".

If you have fzf installed, you can also interactively select a context or cluster, or fuzzy-search by typing a few characters. To learn more, read interactive mode →

Both kubectx and kubens support Tab completion on bash/zsh/fish shells to help with long context names. You don't have to remember full context names anymore.


Installation

Stable versions of kubectx and kubens are small bash scripts that you can find in this repository.

Starting with v0.9.0, kubectx and kubens are now rewritten in Go. They should work the same way (and we'll keep the bash-based implementations around) but the new features will be added to the new Go programs. Please help us test this new Go implementation by downloading the binaries from the Releases page →

Installation options:

If you like to add context/namespace information to your shell prompt ($PS1), you can try out kube-ps1.

Kubectl Plugins (macOS and Linux)

You can install and use the Krew kubectl plugin manager to get kubectx and kubens.

Note: This will not install the shell completion scripts. If you want them, *choose another installation method or install the scripts manually.

kubectl krew install ctx
kubectl krew install ns

After installing, the tools will be available as kubectl ctx and kubectl ns.

Homebrew (macOS and Linux)

If you use Homebrew you can install like this:

brew install kubectx

This command will set up bash/zsh/fish completion scripts automatically. Make sure you configure your shell to load completions for installed Homebrew formulas.

MacPorts (macOS)

If you use MacPorts you can install like this:

sudo port install kubectx

apt (Debian)

sudo apt install kubectx

Newer versions might be available on repos like Debian Buster (testing), Sid (unstable) (if you are unfamiliar with the Debian release process and how to enable testing/unstable repos, check out the Debian Wiki):

pacman (Arch Linux)

Available as official Arch Linux package. Install it via:

sudo pacman -S kubectx

Windows Installation (using Chocolatey)

Available as packages on Chocolatey

choco install kubens kubectx

Windows Installation (using Scoop)

Available as packages on Scoop

scoop bucket add main
scoop install main/kubens main/kubectx

Windows Installation (using winget)

Available as packages on winget

winget install --id ahmetb.kubectx
winget install --id ahmetb.kubens

Manual Installation (macOS and Linux)

Since kubectx and kubens are written in Bash, you should be able to install them to any POSIX environment that has Bash installed.

  • Download the kubectx, and kubens scripts.
  • Either:
    • save them all to somewhere in your PATH,
    • or save them to a directory, then create symlinks to kubectx/kubens from somewhere in your PATH, like /usr/local/bin
  • Make kubectx and kubens executable (chmod +x ...)

Example installation steps:

sudo git clone https://github.com/ahmetb/kubectx /opt/kubectx
sudo ln -s /opt/kubectx/kubectx /usr/local/bin/kubectx
sudo ln -s /opt/kubectx/kubens /usr/local/bin/kubens

If you also want to have shell completions, pick an installation method for the completion scripts that fits your system best: zsh with antibody, plain zsh, bash or fish.

Completion scripts for zsh with antibody

Add this line to your Plugins File (e.g. ~/.zsh_plugins.txt):

ahmetb/kubectx path:completion kind:fpath

Depending on your setup, you might or might not need to call compinit or autoload -U compinit && compinit in your ~/.zshrc after you load the Plugins file. If you use oh-my-zsh, load the completions before you load oh-my-zsh because oh-my-zsh will call compinit.

Completion scripts for plain zsh

The completion scripts have to be in a path that belongs to $fpath. Either link or copy them to an existing folder.

Example with oh-my-zsh:

mkdir -p ~/.oh-my-zsh/custom/completions
chmod -R 755 ~/.oh-my-zsh/custom/completions
ln -s /opt/kubectx/completion/_kubectx.zsh ~/.oh-my-zsh/custom/completions/_kubectx.zsh
ln -s /opt/kubectx/completion/_kubens.zsh ~/.oh-my-zsh/custom/completions/_kubens.zsh
echo "fpath=($ZSH/custom/completions $fpath)" >> ~/.zshrc

If completion doesn't work, add autoload -U compinit && compinit to your .zshrc (similar to zsh-completions).

If you are not using oh-my-zsh, you could link to /usr/share/zsh/functions/Completion (might require sudo), depending on the $fpath of your zsh installation.

In case of errors, calling compaudit might help.

Completion scripts for bash

git clone https://github.com/ahmetb/kubectx.git ~/.kubectx
COMPDIR=$(pkg-config --variable=completionsdir bash-completion)
ln -sf ~/.kubectx/completion/kubens.bash $COMPDIR/kubens
ln -sf ~/.kubectx/completion/kubectx.bash $COMPDIR/kubectx
cat << EOF >> ~/.bashrc


#kubectx and kubens
export PATH=~/.kubectx:\$PATH
EOF

Completion scripts for fish

mkdir -p ~/.config/fish/completions
ln -s /opt/kubectx/completion/kubectx.fish ~/.config/fish/completions/
ln -s /opt/kubectx/completion/kubens.fish ~/.config/fish/completions/

Interactive mode

If you want kubectx and kubens commands to present you an interactive menu with fuzzy searching, you just need to install fzf in your $PATH.

kubectx interactive search with fzf

If you have fzf installed, but want to opt out of using this feature, set the environment variable KUBECTX_IGNORE_FZF=1.

If you want to keep fzf interactive mode but need the default behavior of the command, you can do it by piping the output to another command (e.g. kubectx | cat ).


Customizing colors

If you like to customize the colors indicating the current namespace or context, set the environment variables KUBECTX_CURRENT_FGCOLOR and KUBECTX_CURRENT_BGCOLOR (refer color codes here):

export KUBECTX_CURRENT_FGCOLOR=$(tput setaf 6) # blue text
export KUBECTX_CURRENT_BGCOLOR=$(tput setab 7) # white background

Colors in the output can be disabled by setting the NO_COLOR environment variable.


If you liked kubectx, you may like my kubectl-aliases project, too. I recommend pairing kubectx and kubens with fzf and kube-ps1.

Stargazers over time

Stargazers over time Google Analytics