In this article, we’re going to explore a few tips and tricks that will make it easier to work with Kubernetes.
Most of the tips given below are using kubectl, a powerful command-line tool that allows you to execute commands against Kubernetes clusters.
If you need some background on Kubernetes before jumping into these tips, see the following resources:
- What is Kubernetes?
- VIDEO – Container Orchestration Explained
- Kubernetes Clusters: Architecture for Rapid, Controlled Cloud App Delivery
- What is Kubernetes Ingress?
- Kubernetes Tutorials: 5 Ways to Get You Building Fast
- Get started with IBM Cloud Kubernetes Service
1. Set default namespaces
You can divide a Kubernetes cluster into multiple environments by using namespaces (e.g., Dev1, Dev2, QA1, QA2, etc.), and each environment can be managed by a different user. One of the inconveniences of writing kubectl commands is that every time you write a command, you need the
--namespace option at the end. People often forget this and end up creating objects (pods, services, deployments) in the wrong namespace.
With this trick, you can set the namespace preference before running kubectl commands. Run the following command before executing the kubectl commands, and it will save the namespace for all subsequent kubectl commands for your current context:
Some of the most common and useful commands with namespace are listed below:
kubectl get namespaces
kubectl create namespace mynamespace
kubectl get pods --all-namespaces(List all pods with status from all namespaces.)
kubectl get po -o wide -n <namspace1> -n <namespace2> -n <namespace3>(This command will identify the pods in each namespace)
kubectl describe namespace <namespace>
kubectl config view --minify | grep namespace(This command will ensure that you set the namespace correctly for your current context.)
2. Helpful aliases to save time
Kubernetes commands can be quite lengthy, so setting up some aliases for running kubectl is very helpful. You will no longer need to spell out the full command over and over again, making your life a lot easier when you want to execute multiple Kubernetes commands in one session.
We have listed aliases for some frequently used commands below. Run these before executing kubectl commands to save yourself some time. Example: You just need to type
k instead of typing
alias kc='k config view --minify | grep name'
alias kdp='kubectl describe pod'
alias krh='kubectl run --help | more'
alias ugh='kubectl get --help | more'
alias kd='kubectl describe pod'
alias ke='kubectl explain'
alias kf='kubectl create -f'
alias kg='kubectl get pods --show-labels'
alias kr='kubectl replace -f'
alias kh='kubectl --help | more'
alias krh='kubectl run --help | more'
alias ks='kubectl get namespaces'
alias l='ls -lrt'
alias ll='vils -rt | tail -1
alias kga='k get pod --all-namespaces'
alias kgaa='kubectl get all --show-labels'
3. YAML editing with vi
There are many different editors available to write YAML files, but there are many times where you may need to quickly tweak a generated YAML and while working on a terminal. This is a great place to use our trusty vi, the text editor originally created for the Unix operating system.
The vi editor is well documented and has support from a vibrant open source community. One of the problems with the vi editor while creating YAML files, however, is the space issue. We need a way to indent with tabs and align with spaces. Using tabs vs. spaces for whitespace has always created syntax issues while writing YAML files (e.g., getting the 2-space YAML as the default when hitting carriage return).
The solution? Create a
~/.vimrc file with these lines before creating YAML files with the vi editor to make editing easier:
4. Create YAML from kubectl commands
We can create complex YAML files from the command line using kubectl commands.
Most people would agree that working with YAML files is no fun, and Kubernetes YAML files can be very verbose and hard to create from scratch. It is much easier to create the YAML file from kubectl commands instead of from a blank page using an editor.
The following commands will create a YAML file with name
yamlfile. Once you create the YAML file from these kubectl commands, you can modify it based on your requirements and use it instead of writing from scratch:
kubectl run busybox --image=busybox --dry-run=client -o yaml --restart=Never > yamlfile.yaml
kubectl create job my-job --dry-run=client -o yaml --image=busybox -- date > yamlfile.yaml
kubectl get -o yaml deploy/nginx > 1.yaml (Ensure that you have a deployment named as nginx)
kubectl run busybox --image=busybox --dry-run=client -o yaml --restart=Never -- /bin/sh -c "while true; do echo hello; echo hello again;done" > yamlfile.yaml
kubectl run wordpress --image=wordpress –-expose –-port=8989 --restart=Never -o yaml
kubectl run test --image=busybox --restart=Never --dry-run=client -o yaml -- bin/sh -c 'echo test;sleep 100' > yamlfile.yaml(Notice that
--bincomes at the end. This will create yaml file.)
Another good idea for creating the YAML file is obtaining the file directly from the internet using the
5. Switching between Kubernetes namespaces
In Tip 1, we learned some useful commands to use Kubernetes namespaces and save them so that you don't have to add to every command. Let's expand the tip to make it easier to switch between namespaces and kubectl contexts.
There are several tools that can help, but we like kubectx and kubens for managing contexts and namespaces, respectively. You can find details of kubectx and kubens here.
Here is how to download the Linux binaries for kubectx and kubens utility:
Then you extract them with the following commands:
tar -xvf kubectx_v0.9.0_linux_x86_64.tar.gz
tar -xvf kubens_v0.9.0_linux_x86_64.tar.gz
Finally, you move them to your PATH:
sudo mv kubectx /usr/local/bin
sudo mv kubens /usr/local/bin
Once installed, you can simply use kubens to list the namespaces and switch between them:
When working with multiple clusters, kubectx makes switching between contexts a breeze:
6. Shell auto-completion
Did you know that kubectl provides auto-completion for BASH and ZSH? This is an optional configuration.
Let’s say you understand the concepts of Kubernetes and have some experience with kubectl, but perhaps you aren’t so good at memorizing commands. First you install bash-completion, and then you enable kubectl autocompletion. You can find all the details in the “Install and Set Up kubectl“ documentation page for your environment.
Below are the config options with the autocompletion feature:
Now, just tab away!
7. Viewing resource utilization
The top command is probably one of the most popular tools to monitor processes and system resources. It provides a simple character-based interface and quick access to crucial information.
You can see resource utilization per node:
Resource utilization per pod:
And the handy watch command can help you display the command in a desirable interval without having to run it over and over again. The following example makes it run every five seconds (the default is two seconds):
Note: The watch command needs to be downloaded for your environment.
Your Kubernetes cluster also needs to be running heapster in order for the top command work, otherwise you'll get the following error: “Error from server (NotFound): the server could not find the requested resource (get services http:heapster:)”
8. Extend kubectl and create your own commands using raw outputs
The kubectl command provides a summarized view of the resources stored by the apiserver. There are many more fields stored by the apiserver that are not shown. You can use the kubectl get command with the raw resource output to create your own visualization and commands.
You can print the raw resources in JSON with the following command:
You can also call the resource directly using the api call:
You can even combine the output with tools like jq to provide different visualizations, filter the output, or feed the output to other tools for advance automation.
For example, it can be hard to find issues on clusters with multiple namespaces and deployments, but the example below uses the raw API to scan all deployments in the cluster and filter only the deployments with failing replicas:
The following is a quick explanation of the command above:
- First, we call the Kubernetes API to return all deployments. The default output is in JSON. It is hard to visualize the structure of the JSON document, but you can pipe to jq to get a better idea like in the example below:
- Notice that the response document has an array of items for each deployment. We want to inspect the status field of this array all the way in the end. The command below shows how to print just the data you need and a default value of 0 when the field is not available:
- The final piece of the puzzle is using the select function to only display deployments with unavailable replicas:
We hope you find some of these tips and tricks useful as you work with Kubernetes. Let us know if you have a favorite tip or a tip of your own that you would like to share.
Don't forget to check out the IBM Cloud Kubernetes Service and put these tips and tricks to use.
Want to get some free, hands-on experience with Kubernetes? Take advantage of IBM CloudLab, a new interactive platform that offers Kubernetes tutorials with a certification—no cost or configuration needed.