kubecolor

https://kubecolor.github.io/
Admin
kubecolor is a kubectl wrapper that adds colorized output to make reading Kubernetes command results...
Tokens:22,814
Snippets:199
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install kubecolor with Zypper

Source: https://kubecolor.github.io/setup/install

Install kubecolor on openSUSE using Zypper. Adds the kubecolor repository and installs the package.

```bash
sudo zypper addrepo https://kubecolor.github.io/packages/rpm/kubecolor.repo
sudo zypper install kubecolor
```

--------------------------------

### Install kubecolor with winget

Source: https://kubecolor.github.io/setup/install

Install kubecolor on Windows using the winget package manager.

```bash
winget install --id Kubecolor.kubecolor
```

--------------------------------

### Install kubecolor with DNF5

Source: https://kubecolor.github.io/setup/install

Install kubecolor on Fedora 41 and later using DNF5. Requires dnf5-plugins and adds the kubecolor repository before installing. Verify DNF version with `dnf --version`.

```bash
sudo dnf install dnf5-plugins
sudo dnf config-manager addrepo --from-repofile https://kubecolor.github.io/packages/rpm/kubecolor.repo
sudo dnf install kubecolor
```

--------------------------------

### Install kubecolor with Scoop

Source: https://kubecolor.github.io/setup/install

Install kubecolor on Windows using the Scoop package manager.

```bash
scoop install kubecolor
```

--------------------------------

### Install kubecolor via mise

Source: https://kubecolor.github.io/setup/install

Install kubecolor using the mise-en-place package manager. This installs the aqua package behind the scenes.

```bash
mise install kubecolor
```

--------------------------------

### Install kubecolor on Debian-based systems

Source: https://kubecolor.github.io/setup/install

Scripted installation for Debian-based systems (Debian, Ubuntu, Pop!_OS, Linux Mint, Elementary OS). Downloads the .deb file from the custom repo and installs it, setting up the repository for future updates.

```bash
sudo apt-get update
sudo apt-get install apt-transport-https wget --yes
wget -O /tmp/kubecolor.deb https://kubecolor.github.io/packages/deb/pool/main/k/kubecolor/kubecolor_$(wget -q -O- https://kubecolor.github.io/packages/deb/version)_$(dpkg --print-architecture).deb
sudo dpkg -i /tmp/kubecolor.deb
sudo apt update
```

--------------------------------

### Install kubecolor with DNF4

Source: https://kubecolor.github.io/setup/install

Install kubecolor on Fedora 40 and earlier using DNF4. Requires the config-manager plugin and adds the kubecolor repository before installing. Verify DNF version with `dnf --version`.

```bash
sudo dnf install 'dnf-command(config-manager)'
sudo dnf config-manager --add-repo https://kubecolor.github.io/packages/rpm/kubecolor.repo
sudo dnf install kubecolor
```

--------------------------------

### Compile kubecolor from source

Source: https://kubecolor.github.io/setup/install

Compile and install kubecolor from source. Requires Go 1.22 or later.

```bash
go install github.com/kubecolor/kubecolor@latest
```

--------------------------------

### kubecolor --kubecolor-theme example

Source: https://kubecolor.github.io/reference/flags

Shows how to set the kubecolor color theme preset with --kubecolor-theme. A value is required for this flag.

```bash
kubecolor get pods --kubecolor-theme=dark

```

--------------------------------

### Install kubecolor with Homebrew

Source: https://kubecolor.github.io/setup/install

Installs kubecolor via Homebrew on macOS and some Linux systems.

```bash
brew install kubecolor
```

--------------------------------

### Install kubecolor with MacPorts

Source: https://kubecolor.github.io/setup/install

Installs kubecolor using MacPorts on macOS.

```bash
sudo port install kubecolor
```

--------------------------------

### Install kubectl completions in ~/.bashrc

Source: https://kubecolor.github.io/setup/shells/bash

Add this line to ~/.bashrc to install kubectl completions. This must be added before the complete commands.

```bash
# This needs to be added before "complete -o default -F __start_kubectl ..."
source <(kubectl completion bash)

```

--------------------------------

### Basic kubecolor usage: replacing kubectl

Source: https://kubecolor.github.io/usage/getting-started

Use kubecolor instead of kubectl to get colorized output. The example shows the equivalent commands for getting pods.

```bash
# instead of this:
kubectl get pods


# use this:
kubecolor get pods

```

--------------------------------

### Install kubecolor via Termux

Source: https://kubecolor.github.io/setup/install

Install kubecolor on Android using the Termux app.

```bash
pkg install kubecolor
```

--------------------------------

### Install kubecolor with YUM

Source: https://kubecolor.github.io/setup/install

Install kubecolor on RPM-based distributions using YUM. Ensures yum-config-manager is available, adds the kubecolor repository, and installs the package.

```bash
type -p yum-config-manager >/dev/null || sudo yum install yum-utils
sudo yum-config-manager --add-repo https://kubecolor.github.io/packages/rpm/kubecolor.repo
sudo yum install kubecolor
```

--------------------------------

### Configure default theme in ~/.kube/color.yaml

Source: https://kubecolor.github.io/customizing/themes

Set the default theme by adding a 'preset' key to the configuration file at ~/.kube/color.yaml. The example sets it to 'protanopia-dark'.

```yaml
preset: protanopia-dark
```

--------------------------------

### Install kubecolor via Nix

Source: https://kubecolor.github.io/setup/install

Install kubecolor using Nix package manager. The first two commands are alternative ways to use nix-shell and nix shell, while flox is a separate package manager built on top of Nix.

```bash
nix-shell -p kubecolor
```

```bash
nix shell nixpkgs#kubecolor
```

```bash
flox install kubecolor
```

--------------------------------

### Install kubecolor via AUR

Source: https://kubecolor.github.io/setup/install

Install kubecolor from the Arch User Repository using yay. Applies to Manjaro, ChimeraOS, and EndeavourOS.

```bash
yay -Syu kubecolor
```

--------------------------------

### Install kubectl completions for PowerShell

Source: https://kubecolor.github.io/setup/shells/powershell

Add this to your profile before the Register-ArgumentCompleter line to set up kubectl completions, which also registers the $__kubectlCompleterBlock variable.

```powershell
# Completion for kubectl
# This needs to be added before Register-ArgumentCompleter
if (Get-Command kubectl -ErrorAction SilentlyContinue) {
  # This also registers the $__kubectlCompleterBlock variable
  kubectl completion powershell | Out-String | Invoke-Expression
}

```

--------------------------------

### Install kubectl completions for fish

Source: https://kubecolor.github.io/setup/shells/fish

Adds kubectl completions to the fish config. This must be placed before the function definitions that use --wraps kubectl.

```fish
# This needs to be added before "function ... --wraps kubectl"
kubectl completion fish | source
```

--------------------------------

### Example kubecolor command with theme and pager flags

Source: https://kubecolor.github.io/usage/how-it-works

Shows a kubecolor invocation with the --kubecolor-theme and --pager flags, used to illustrate argument parsing.

```bash
kubecolor --kubecolor-theme="light" get --pager="less -RF" pods -o wide --watch
```

--------------------------------

### Install kubecolor via aqua

Source: https://kubecolor.github.io/setup/install

Install kubecolor using the aqua package manager. The command adds the package to the aqua configuration.

```bash
aqua g -i kubecolor/kubecolor
```

--------------------------------

### Install kubecolor via asdf

Source: https://kubecolor.github.io/setup/install

Install the latest version of kubecolor using the asdf package manager. In asdf-plugins this refers to dex4er/asdf-kubecolor, which uses the latest version from GitHub releases.

```bash
asdf install kubecolor latest
```

--------------------------------

### Source kubectl zsh completions

Source: https://kubecolor.github.io/setup/shells/zsh

Add this to ~/.zshrc before the compdef line to install kubectl completions if they are not already present.

```zsh
# This needs to be added before "compdef kubecolor=kubectl"
source <(kubectl completion zsh)
```

--------------------------------

### Dynamic TTY support examples

Source: https://kubecolor.github.io/usage/how-it-works

Shows how kubecolor automatically disables color codes when output is redirected or piped, and how to force colors with --force-colors.

```bash
# Prints with color codes
kubecolor get pods
```

```bash
# Automatically disables color codes for these two:
kubecolor get pods > result.txt
kubecolor get pods | grep Running
```

```bash
# Force kubecolor to print color codes anyways
kubecolor get pods --force-colors > result.txt
```

--------------------------------

### Reinstall kubecolor after removing old tap

Source: https://kubecolor.github.io/setup/install

Removes an old kubecolor installation from the kubecolor/tap and reinstalls it via Homebrew. Run this if you previously used `brew install kubecolor/tap/kubecolor`.

```bash
brew uninstall kubecolor
brew untap kubecolor/tap
brew update
brew install kubecolor
```

--------------------------------

### Borrow kubectl completions with compdef

Source: https://kubecolor.github.io/setup/shells/zsh

Add this to ~/.zshrc to make kubecolor use the same completion logic as kubectl. Requires kubectl completions to be installed first.

```zsh
# Make "kubecolor" borrow the same completion logic as "kubectl"
compdef kubecolor=kubectl
```

--------------------------------

### YAML color configuration for scale, uncordon, and version

Source: https://kubecolor.github.io/reference/config

Example YAML configuration for kubecolor, defining color settings for scale, uncordon, and version commands. Each entry uses !color or !color-list tags with comments indicating defaults. The defaults reference theme variables such as $theme.base.warning and $theme.apply.dryrun.

```yaml
  scale:
    # used on "deployment.apps/foo scaled"
    scaled: !color # default = $theme.base.warning


    # used on "(dry run)" and "(server dry run)"
    dryRun: !color # default = $theme.apply.dryrun


    # used when outputs unknown format
    fallback: !color # default = $theme.base.warning


  uncordon:
    # used on "node/my-worker-node-01 uncordoned"
    uncordoned: !color # default = $theme.base.secondary


    # used on "(dry run)" and "(server dry run)"
    dryRun: !color # default = $theme.apply.dryrun


    # used when outputs unknown format
    fallback: !color # default = $theme.base.warning


  version:
    # used on the key
    key: !color-list # default = $theme.base.key
```

--------------------------------

### kubecolor --kubecolor-stdin reading from a file

Source: https://kubecolor.github.io/reference/flags

Shows how to use --kubecolor-stdin with a file path to read from that file instead of stdin. The file contains the output of kubectl get pods.

```bash
kubectl get pods > results.txt
kubecolor get pods --kubecolor-stdin=results.txt

```

--------------------------------

### Setting color environment variables

Source: https://kubecolor.github.io/reference/types/color

Examples of setting color values as environment variables, including named colors with style modifiers and a hexadecimal color.

```bash
export KUBECOLOR_THEME_DATA_NULL="gray:italic"
export KUBECOLOR_THEME_TABLE_HEADER="fg=white:bold:underline"
export KUBECOLOR_THEME_STDERR_ERROR="fg=yellow:bg=red:bold"
export KUBECOLOR_THEME_STDERR_ERROR="#c0ffee"
```

--------------------------------

### Register kubecolor argument completer

Source: https://kubecolor.github.io/setup/shells/powershell

Add this to your profile to reuse kubectl completion for kubecolor and its aliases. Requires kubectl completions installed.

```powershell
# Reuse the kubectl completion on kubecolor and the aliases
Register-ArgumentCompleter -CommandName 'k','kubectl','kubecolor' -ScriptBlock $__kubectlCompleterBlock

```

--------------------------------

### kubecolor flag filtering example

Source: https://kubecolor.github.io/reference/flags

Shows how kubecolor filters its own flags before passing the remaining arguments to kubectl. The first command is what the user runs; the second is the translated kubectl invocation.

```bash
kubecolor get pods --force-colors --namespace=kube-system

```

```bash
kubectl get pods --namespace=kube-system

```

--------------------------------

### Enable kubecolor completions in fish

Source: https://kubecolor.github.io/setup/shells/fish

Defines a fish function 'kubecolor' that wraps kubectl to reuse its completions. This is required to get completions for kubecolor itself.

```fish
# reuse "kubectl" completions on "kubecolor"
function kubecolor --wraps kubectl
  command kubecolor $argv
end
```

--------------------------------

### Set theme via KUBECOLOR_PRESET environment variable

Source: https://kubecolor.github.io/customizing/themes

Set the KUBECOLOR_PRESET environment variable to a specific theme to change the default theme for all commands. The example sets it to 'protanopia-dark'.

```bash
export KUBECOLOR_PRESET="protanopia-dark"
```

--------------------------------

### Switch theme temporarily with --kubecolor-theme flag

Source: https://kubecolor.github.io/customizing/themes

Use the --kubecolor-theme flag to temporarily use a different theme for a single kubecolor command. The example uses the 'protanopia-dark' theme.

```bash
kubecolor get pods --kubecolor-theme=protanopia-dark
```

--------------------------------

### Set custom theme colors via config file

Source: https://kubecolor.github.io/customizing/themes

Define custom colors for null data, table headers, and stderr errors in the config file (~/.kube/color.yaml). This is the YAML equivalent of the environment variable example.

```yaml
theme:
  data:
    "null": gray:italic
  table:
    header: fg=white:bold:underline
  stderr:
    error: fg=yellow:bg=red:bold
```

--------------------------------

### kubecolor --kubecolor-stdin reading from stdin

Source: https://kubecolor.github.io/reference/flags

Shows how to use --kubecolor-stdin without a value to read from stdin. The output of kubectl get pods is piped into kubecolor for parsing and colorizing.

```bash
kubectl get pods > results.txt
cat results.txt | kubecolor get pods --kubecolor-stdin

```

--------------------------------

### Run kubecolor via Docker and fix permission error

Source: https://kubecolor.github.io/setup/install

Run kubecolor via Docker, mounting the kube config read-only. If you get a permission denied error (common in WSL), change the permission of ~/.kube/config with chmod 644.

```bash
docker run --rm -it -v $HOME/.kube:/home/nonroot/.kube:ro --env COLORTERM ghcr.io/kubecolor/kubecolor get pods
```

```text
error: error loading config file "/home/nonroot/.kube/config": open /home/nonroot/.kube/config: permission denied
```

```bash
chmod 644 ~/.kube/config
```

--------------------------------

### Logs theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for log output elements: keys, quoted strings, dates, source references, GUIDs, and severity levels.

```bash
export KUBECOLOR_THEME_LOGS_KEY="$KUBECOLOR_THEME_DATA_KEY"
```

```bash
export KUBECOLOR_THEME_LOGS_QUOTEDSTRING="$KUBECOLOR_THEME_DATA_STRING"
```

```bash
export KUBECOLOR_THEME_LOGS_DATE="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LOGS_SOURCEREF="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LOGS_GUID="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_TRACE="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_DEBUG="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_INFO="$KUBECOLOR_THEME_BASE_SUCCESS"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_WARN="$KUBECOLOR_THEME_BASE_WARNING"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_ERROR="$KUBECOLOR_THEME_BASE_DANGER"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_FATAL="$KUBECOLOR_THEME_BASE_DANGER"
```

```bash
export KUBECOLOR_THEME_LOGS_SEVERITY_PANIC="$KUBECOLOR_THEME_BASE_DANGER"
```

--------------------------------

### explain theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variables for kubectl explain output, covering keys and the required marker.

```bash
# (color-list) used on keys. The multiple colors are cycled based on indentation.
export KUBECOLOR_THEME_EXPLAIN_KEY="$KUBECOLOR_THEME_BASE_KEY"


# (color) used on the trailing "-required-" string
export KUBECOLOR_THEME_EXPLAIN_REQUIRED="$KUBECOLOR_THEME_BASE_DANGER"
```

--------------------------------

### kubecolor --kubecolor-stdin with docker logs

Source: https://kubecolor.github.io/reference/flags

Shows how to colorize arbitrary output, such as Docker logs, by piping it into kubecolor with --kubecolor-stdin and the appropriate subcommand (logs).

```bash
docker logs my-container | kubecolor logs --kubecolor-stdin

```

--------------------------------

### help theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variables for kubectl help output, covering headers, flags, flag descriptions, URLs, and fallback text.

```bash
# (color) e.g "Examples:" or "Options:"
export KUBECOLOR_THEME_HELP_HEADER="$KUBECOLOR_THEME_TABLE_HEADER"


# (color) e.g "--kubeconfig"
export KUBECOLOR_THEME_HELP_FLAG="$KUBECOLOR_THEME_BASE_SECONDARY"


# (color) Flag descripion under "Options:" heading
export KUBECOLOR_THEME_HELP_FLAGDESC="$KUBECOLOR_THEME_BASE_INFO"


# (color) e.g `[https://example.com]`
export KUBECOLOR_THEME_HELP_URL="$KUBECOLOR_THEME_BASE_SECONDARY"


# (color) Fallback text color
export KUBECOLOR_THEME_HELP_TEXT="$KUBECOLOR_THEME_BASE_INFO"
```

--------------------------------

### create theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variables for kubectl create output, covering created, dry run, and fallback.

```bash
# (color) used on "deployment.apps/foo created"
export KUBECOLOR_THEME_CREATE_CREATED="$KUBECOLOR_THEME_BASE_SUCCESS"


# (color) used on "(dry run)" and "(server dry run)"
export KUBECOLOR_THEME_CREATE_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"


# (color) used when outputs unknown format
export KUBECOLOR_THEME_CREATE_FALLBACK="$KUBECOLOR_THEME_BASE_SUCCESS"
```

--------------------------------

### Add alias and completions for k

Source: https://kubecolor.github.io/setup/shells/bash

If you use an alias like k=kubectl, add these lines to ~/.bashrc to enable completions for k.

```bash
alias k=kubectl
complete -o default -F __start_kubectl k

```

--------------------------------

### Version key theme variable

Source: https://kubecolor.github.io/reference/environment-variables

Defines the color for the version key.

```bash
export KUBECOLOR_THEME_VERSION_KEY="$KUBECOLOR_THEME_BASE_KEY"
```

--------------------------------

### Set KUBECOLOR_LIGHT_BACKGROUND to enable light background

Source: https://kubecolor.github.io/reference/environment-variables

Shows how to set the deprecated KUBECOLOR_LIGHT_BACKGROUND environment variable to true, which defaults to false. Use KUBECOLOR_PRESET=light instead.

```bash
export KUBECOLOR_LIGHT_BACKGROUND=true

```

--------------------------------

### expose theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variables for kubectl expose output, covering exposed, dry run, and fallback.

```bash
# (color) used on "deployment.apps/foo created"
export KUBECOLOR_THEME_EXPOSE_EXPOSED="$KUBECOLOR_THEME_BASE_PRIMARY"


# (color) used on "(dry run)" and "(server dry run)"
export KUBECOLOR_THEME_EXPOSE_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"


# (color) used when outputs unknown format
export KUBECOLOR_THEME_EXPOSE_FALLBACK="$KUBECOLOR_THEME_BASE_PRIMARY"
```

--------------------------------

### describe theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variable for kubectl describe output, used on keys with colors cycled by indentation.

```bash
# (color-list) used on keys. The multiple colors are cycled based on indentation.
export KUBECOLOR_THEME_DESCRIBE_KEY="$KUBECOLOR_THEME_BASE_KEY"
```

--------------------------------

### Forcing colors with --force-colors

Source: https://kubecolor.github.io/usage/getting-started

Kubecolor disables colors when output is not a terminal. Use --force-colors to override. The example shows output piped to cat -A, with and without the flag, demonstrating ANSI escape codes.

```bash
kubecolor get pods | cat -A
#NAME          READY   STATUS    RESTARTS   AGE
#nginx-dnmv5   1/1     Running   0          6d6h
#nginx-m8pbc   1/1     Running   0          6d6h
#nginx-qdf9b   1/1     Running   0          6d6h


kubecolor get pods --force-colors | cat -A
#^[[1mNAME          READY   STATUS    RESTARTS   AGE^[[0m$
#^[[37mnginx-dnmv5^[[0m   ^[[36m1/1^[[0m     ^[[32mRunning^[[0m   ^[[36m0^[[0m          ^[[37m6d6h^[[0m$
#^[[37mnginx-m8pbc^[[0m   ^[[36m1/1^[[0m     ^[[32mRunning^[[0m   ^[[36m0^[[0m          ^[[37m6d6h^[[0m$
#^[[37mnginx-qdf9b^[[0m   ^[[36m1/1^[[0m     ^[[32mRunning^[[0m   ^[[36m0^[[0m          ^[[37m6d6h^[[0m$

```

--------------------------------

### apply theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Theme variables for kubectl apply output, covering created, configured, unchanged, serverside-applied, dry run, and fallback messages.

```bash
# (color) used on "deployment.apps/foo created"
export KUBECOLOR_THEME_APPLY_CREATED="$KUBECOLOR_THEME_BASE_SUCCESS"


# (color) used on "deployment.apps/bar configured"
export KUBECOLOR_THEME_APPLY_CONFIGURED="$KUBECOLOR_THEME_BASE_WARNING"


# (color) used on "deployment.apps/quux unchanged"
export KUBECOLOR_THEME_APPLY_UNCHANGED="$KUBECOLOR_THEME_BASE_PRIMARY"


# (color) used on "deployment.apps/quux serverside-applied"
export KUBECOLOR_THEME_APPLY_SERVERSIDE="$KUBECOLOR_THEME_BASE_WARNING"


# (color) used on "(dry run)" and "(server dry run)"
export KUBECOLOR_THEME_APPLY_DRYRUN="$KUBECOLOR_THEME_BASE_SECONDARY"


# (color) used when outputs unknown format
export KUBECOLOR_THEME_APPLY_FALLBACK="$KUBECOLOR_THEME_BASE_SUCCESS"
```

--------------------------------

### Set KUBECOLOR_FORCE_COLORS alias for watch command

Source: https://kubecolor.github.io/reference/environment-variables

Forces color output when using kubecolor in the watch command. Add the alias line to your shell config, then use watch kubecolor get pods. The trailing space in the alias is required for alias expansion; without it, commands like watch kgp would fail.

```bash
# Add this line to your ~/.bashrc, ~/.zshrc, or similar:
alias watch='KUBECOLOR_FORCE_COLORS=auto watch --color '


# Usage:
watch kubecolor get pods

```

--------------------------------

### Rollout theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for rollout output: rolled back, paused, resumed, restarted, dry run, and fallback.

```bash
export KUBECOLOR_THEME_ROLLOUT_ROLLEDBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

```bash
export KUBECOLOR_THEME_ROLLOUT_PAUSED="$KUBECOLOR_THEME_BASE_PRIMARY"
```

```bash
export KUBECOLOR_THEME_ROLLOUT_RESUMED="$KUBECOLOR_THEME_BASE_SECONDARY"
```

```bash
export KUBECOLOR_THEME_ROLLOUT_RESTARTED="$KUBECOLOR_THEME_BASE_WARNING"
```

```bash
export KUBECOLOR_THEME_ROLLOUT_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"
```

```bash
export KUBECOLOR_THEME_ROLLOUT_FALLBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

--------------------------------

### Enable kubecolor completions in Bash

Source: https://kubecolor.github.io/setup/shells/bash

Add this line to ~/.bashrc to make kubecolor use kubectl's completion logic when running kubecolor explicitly.

```bash
# Make "kubecolor" borrow the same completion logic as "kubectl"
complete -o default -F __start_kubectl kubecolor

```

--------------------------------

### Customize theme with KUBECOLOR_THEME_* variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines color values for various kubecolor UI elements. Each variable accepts a color string or color-list (e.g., 'red', 'gray:italic', or 'info/secondary').

```bash
# (color) general color for when things are bad
export KUBECOLOR_THEME_BASE_DANGER="red"


# (color) general color for when things are informational
export KUBECOLOR_THEME_BASE_INFO="white"


# (color) general color for when things are less relevant
export KUBECOLOR_THEME_BASE_MUTED="gray:italic"


# (color) general color for when things are focus
export KUBECOLOR_THEME_BASE_PRIMARY="magenta"


# (color) general color for when things are secondary focus
export KUBECOLOR_THEME_BASE_SECONDARY="cyan"


# (color) general color for when things are good
export KUBECOLOR_THEME_BASE_SUCCESS="green"


# (color) general color for when things are wrong
export KUBECOLOR_THEME_BASE_WARNING="yellow"


# (color-list) general color for keys
export KUBECOLOR_THEME_BASE_KEY="$KUBECOLOR_THEME_BASE_SECONDARY"


# (color) default when no specific mapping is found for the command
export KUBECOLOR_THEME_DEFAULT="green"




# (color) used on comments, e.g `# this is a comment`
export KUBECOLOR_THEME_SHELL_COMMENT="$KUBECOLOR_THEME_BASE_MUTED"


# (color) used on commands, e.g `kubectl` or `echo`
export KUBECOLOR_THEME_SHELL_COMMAND="$KUBECOLOR_THEME_BASE_SUCCESS"


# (color) used on arguments, e.g `get pods` in `kubectl get pods`
export KUBECOLOR_THEME_SHELL_ARG="$KUBECOLOR_THEME_BASE_INFO"


# (color) used on flags, e.g `--watch` in `kubectl get pods --watch`
export KUBECOLOR_THEME_SHELL_FLAG="$KUBECOLOR_THEME_BASE_SECONDARY"




# (color-list) used for the key
export KUBECOLOR_THEME_DATA_KEY="$KUBECOLOR_THEME_BASE_KEY"


# (color) used when value is a string
export KUBECOLOR_THEME_DATA_STRING="$KUBECOLOR_THEME_BASE_INFO"


# (color) used when value is true
export KUBECOLOR_THEME_DATA_TRUE="$KUBECOLOR_THEME_BASE_SUCCESS"


# (color) used when value is false
export KUBECOLOR_THEME_DATA_FALSE="$KUBECOLOR_THEME_BASE_DANGER"


# (color) used when the value is a number
export KUBECOLOR_THEME_DATA_NUMBER="$KUBECOLOR_THEME_BASE_PRIMARY"


# (color) used when the value is null, nil, or none
export KUBECOLOR_THEME_DATA_NULL="$KUBECOLOR_THEME_BASE_MUTED"


# (color) used when the value is a quantity, e.g "100m" or "5Gi"
export KUBECOLOR_THEME_DATA_QUANTITY="$KUBECOLOR_THEME_DATA_NUMBER"


# (color) used when the value is a duration, e.g "12m" or "1d12h"
export KUBECOLOR_THEME_DATA_DURATION=""


# (color) color used when the time value is under a certain delay
export KUBECOLOR_THEME_DATA_DURATIONFRESH="$KUBECOLOR_THEME_BASE_SUCCESS"




# (color) used for "0/0"
export KUBECOLOR_THEME_DATA_RATIO_ZERO="$KUBECOLOR_THEME_BASE_MUTED"


# (color) used for "n/n", e.g "1/1"
export KUBECOLOR_THEME_DATA_RATIO_EQUAL=""


# (color) used for "n/m", e.g "0/1"
export KUBECOLOR_THEME_DATA_RATIO_UNEQUAL="$KUBECOLOR_THEME_BASE_WARNING"




# (color) used in status keywords, e.g "Running", "Ready"
export KUBECOLOR_THEME_STATUS_SUCCESS="$KUBECOLOR_THEME_BASE_SUCCESS"


# (color) used in status keywords, e.g "Terminating"
export KUBECOLOR_THEME_STATUS_WARNING="$KUBECOLOR_THEME_BASE_WARNING"


# (color) used in status keywords, e.g "Failed", "Unhealthy"
export KUBECOLOR_THEME_STATUS_ERROR="$KUBECOLOR_THEME_BASE_DANGER"




# (color) used on table headers
export KUBECOLOR_THEME_TABLE_HEADER="$KUBECOLOR_THEME_BASE_INFO"


# (color-list) used on table columns when no other coloring applies such as status or duration coloring. The multiple colors are cycled based on column ID, from left to right.
export KUBECOLOR_THEME_TABLE_COLUMNS="$KUBECOLOR_THEME_BASE_INFO/$KUBECOLOR_THEME_BASE_SECONDARY"

```

--------------------------------

### Generate kubectl zsh completion file

Source: https://kubecolor.github.io/setup/shells/zsh

Run this command to write kubectl's zsh completion script to the first directory in fpath, making it available for compdef.

```zsh
kubectl completion zsh > "${fpath[1]}/_kubectl"
```

--------------------------------

### Add kubectl and k aliases to kubecolor in fish

Source: https://kubecolor.github.io/setup/shells/fish

Defines fish functions 'kubectl' and 'k' that wrap the kubectl command and delegate to kubecolor, preserving completions. Use this to replace kubectl with kubecolor in the fish shell.

```fish
# adds alias for "kubectl" to "kubecolor" with completions
function kubectl --wraps kubectl
  command kubecolor $argv
end


# adds alias for "k" to "kubecolor" with completions
function k --wraps kubectl
  command kubecolor $argv
end
```

--------------------------------

### Set header color to truecolor and force color modes

Source: https://kubecolor.github.io/usage/how-it-works

Shows setting a truecolor theme value and using --force-colors with each supported value (auto, basic, 256, truecolor, none). The basic, 256, and truecolor modes produce the documented escape codes.

```bash
export KUBECOLOR_THEME_TABLE_HEADER='#5a8487'


# Automatically detect color support,
# but fallback to basic/4-bit colors if detection fails
kubecolor get pods --force-colors=auto


# Force colors to basic/4-bit colors,
# resulting in header color code `␛[37m`
kubecolor get pods --force-colors=basic


# Force colors to 256/8-bit colors,
# resulting in header color code `␛[38;5;66m`
kubecolor get pods --force-colors=256


# Force colors to truecolor/24-bit colors,
# resulting in header color code `␛[38;2;90;132;135m`
kubecolor get pods --force-colors=truecolor


# Forcing no colors, i.e. disabling colors
kubecolor get pods --force-colors=none
```

--------------------------------

### Set KUBECTL_COMMAND to change kubectl command

Source: https://kubecolor.github.io/reference/environment-variables

Shows how to set the deprecated KUBECTL_COMMAND environment variable to select the kubectl binary or an alternative like oc. The default is kubectl. Use KUBECOLOR_KUBECTL=kubectl instead.

```bash
export KUBECTL_COMMAND=kubectl      # default
export KUBECTL_COMMAND=kubectl1.19
export KUBECTL_COMMAND=oc           # openshift

```

--------------------------------

### Uncordon theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for uncordon output: uncordoned, dry run, and fallback.

```bash
export KUBECOLOR_THEME_UNCORDON_UNCORDONED="$KUBECOLOR_THEME_BASE_SECONDARY"
```

```bash
export KUBECOLOR_THEME_UNCORDON_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"
```

```bash
export KUBECOLOR_THEME_UNCORDON_FALLBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

--------------------------------

### kubecolor flag value syntax (good vs bad)

Source: https://kubecolor.github.io/reference/flags

Demonstrates the required --flag=value syntax for kubecolor command-line flags. Values must be in the same string as the flag; separate arguments are not accepted.

```bash
# good:
kubecolor --kubecolor-stdin=foo
kubecolor --pager=foo


# bad:
kubecolor --kubecolor-stdin foo
kubecolor --pager foo

```

--------------------------------

### Options flag theme variable

Source: https://kubecolor.github.io/reference/environment-variables

Defines the color for command-line flags like --kubeconfig.

```bash
export KUBECOLOR_THEME_OPTIONS_FLAG="$KUBECOLOR_THEME_BASE_SECONDARY"
```

--------------------------------

### Enable paging with KUBECOLOR_PAGING

Source: https://kubecolor.github.io/reference/environment-variables

Controls whether supported subcommands are piped to a pager. Valid values are 'auto' or 'never', defaulting to 'never'.

```bash
export KUBECOLOR_PAGING="auto"
export KUBECOLOR_PAGING="never" # default

```

--------------------------------

### Set custom theme colors via environment variables

Source: https://kubecolor.github.io/customizing/themes

Define custom colors for null data, table headers, and stderr errors using environment variables. These variables override the default theme.

```bash
export KUBECOLOR_THEME_DATA_NULL="gray:italic"
export KUBECOLOR_THEME_TABLE_HEADER="fg=white:bold:underline"
export KUBECOLOR_THEME_STDERR_ERROR="fg=yellow:bg=red:bold"
```

--------------------------------

### Patch theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for patch output: patched, dry run, and fallback.

```bash
export KUBECOLOR_THEME_PATCH_PATCHED="$KUBECOLOR_THEME_BASE_WARNING"
```

```bash
export KUBECOLOR_THEME_PATCH_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"
```

```bash
export KUBECOLOR_THEME_PATCH_FALLBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

--------------------------------

### Label theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for labels: not labeled, dry run, and fallback.

```bash
export KUBECOLOR_THEME_LABEL_NOTLABELED="$KUBECOLOR_THEME_BASE_MUTED"
```

```bash
export KUBECOLOR_THEME_LABEL_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"
```

```bash
export KUBECOLOR_THEME_LABEL_FALLBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

--------------------------------

### Use OpenShift CLI via config file

Source: https://kubecolor.github.io/customizing/custom-kubectl

Set the kubectl field in the config file to 'oc' to use kubecolor with the OpenShift CLI.

```yaml
kubectl: oc
```

--------------------------------

### Scale theme variables

Source: https://kubecolor.github.io/reference/environment-variables

Defines colors for scale output: scaled, dry run, and fallback.

```bash
export KUBECOLOR_THEME_SCALE_SCALED="$KUBECOLOR_THEME_BASE_WARNING"
```

```bash
export KUBECOLOR_THEME_SCALE_DRYRUN="$KUBECOLOR_THEME_APPLY_DRYRUN"
```

```bash
export KUBECOLOR_THEME_SCALE_FALLBACK="$KUBECOLOR_THEME_BASE_WARNING"
```

--------------------------------

### Alias oc to kubecolor

Source: https://kubecolor.github.io/customizing/custom-kubectl

Set an alias so that 'oc' runs kubecolor, which will use the OpenShift CLI as configured.

```bash
alias oc="kubecolor"
```
Tokens:
Raw