Kubernetes hosts different resources for deploying the containerized application in the Kubernetes cluster. To control, manage, and communicate with these resources, kubectl is used. The kubectl is a Kubernetes command line tool that enables us to deploy, monitor, and manage the containerized application inside the cluster. To use and operate the Kubernetes resources, the “kubectl” tool is essential.

This article will demonstrate:

• Prerequisite: Install the kubectl Tool
• 15 Examples of kubectl Command
• Conclusion

Prerequisite: Install the “kubectl” Tool

Kubernetes cluster requires some implementation system and management tools like minikube to start the Kubernetes cluster and kubectl command line tool to manage, operate, and communicate with the Kubernetes resources. To understand Kubernetes and to install the kubectl CLI tool on Windows, follow our associated “Get started with Kubernetes and Kubectl” article.

15 Examples of “kubectl” Command

kubectl tool provides several commands to create, manage, edit, and run the Kubernetes resources. To understand the working of Kubernetes and kubectl, follow the below given examples.

Example 1: Config Kubernetes Context

The Kubernetes config command is utilized to find which cluster and namespace are currently used. It can also be used to switch between different contexts when the user is using multiple Kubernetes clusters.

Start Cluster

First, launch the Windows PowerShell with administrative rights. After that, run the “minikube start” command to start the Kubernetes cluster:

Configure Kubernetes Context

To configure or switch to a specific context if you are using multiple Kubernetes clusters, use the “kubectl config use-context <context-name>” command:

View Context

To view the currently used context, execute the given command:

Example 2: Kubernetes Namespace

Namespaces in Kubernetes are sub-clusters or modules of a single Kubernetes cluster. They can act as individual modules and can interact with other sub-cluster or modules when needed. These namespaces are used when users are required to deploy multi-module applications in the Kubernetes cluster. Basic kubectl commands used to manage Kubernetes namespace are listed below.

Create Namespace

To create a new namespace in the Kubernetes cluster, use the “kubectl create namespace <namespace-name>” command:

Get Namespace

To get all the cluster namespaces, use “kubectl get” command:

Delete Namespace

To remove the namespace from Kubernetes cluster, use “kubectl delete namespace <namespace-name>” command:

Example 3: Kubernetes Pod

In Kubernetes, pods are essential and smaller units of the cluster that encapsulate and deploy the containerized applications. The kubernetes can execute and operate one or more than one container in a single pod. To deploy and use pods, go through the following kubectl commands.

Create Pod

To create and deploy the Kubernetes pod, use the “kubectl run <pod-name> –image=<container-img>” command. Here, the “–image” flag is used to define the snapshot of the containerized application, and the “–port” flag defines the port where the container will be exposed:

Get Pod

To access all Kubernetes pod or to check the pod state, use “kubectl get pod” command:

In order to view the IP Address of pod and node, use wide output format using “-o” option in “kubectl get” command:

Delete Pod

To delete any Kubernetes pod, run the “kubectl delete pod <pod-name>” command:

Example 4: Interaction With Pods

Sometimes, the user may be required to interact with the running container or may want to run any command inside the pod. To do so, the kubectl tool provides a “kubectl exec” command to access the pod bash terminal:

Here, the “-it” option is used to access the pod TTY pseudo terminal interactively:

To access the running application inside the pod, use “curl <pod-ip address>” command:

Example 5: Kubernetes Resource Port Forward

Sometimes, the user wants to access the pod application outside the cluster on the user system. To do so, they can forward a pod or service port using the “kubectl port-forward <pod-name/service-name> <port-no>” command:

Here, you can see we have effectively accessed the containerized application on system:

Example 6: Kubernetes Deployment

The deployment is one of the core resources of the Kubernetes cluster that gives instructions and updates to the pod, ReplicaSet, and containerized application. The developer can easily deploy the application in the Kubernetes pod with the help of deployment. To create and use Kubernetes deployment, go through the following kubectl commands.

Create Deployment

To create a deployment in Kubernetes, use the “kubectl create deployment <deployment-name> –image=<container-image>” command:

Get Deployment

To list down all deployments, use “kubectl get deployment” command:

The deployment drives different Kubernetes resources such as Pod, ReplicaSet, and sometimes service. To get all deployment components or all Kubernetes resources, use the “kubectl get all” command:

The below-highlighted components are running within the newly created deployment:

Delete Deployment

To delete the Kubernetes deployment, use the below command. This will remove specified deployment along with ReplicaSet and all associated pods:

Example 7: Scale Deployment

Scaling of deployment means increasing or deleting the replicas of running pods. With the help of multiple replicas, the user can ensure the availability of the application and manage the increasing load.

To scale the deployment in Kubernetes, the user can use the “kubectl scale deployment <deployment-name> –replicas=<no of pod replicas>” command. For instance, we have scaled the deployment with 2 pod replicas:

For verification, again access all the Kubernetes resources using the “kubectl get all” command:

Here, you can see we have effectively run two replicas of pod within “demo-deployment”:

Example 8: Rollout Deployment

Whenever any change occurs in deployment or when the deployment is created for the first time, it fires or creates a rollout to manage the deployment history. To view the rollout history or to revert the deployment changes, the kubectl tool provides the following commands.

View Rollout History

To view the rollout history of deployment, use the “kubectl rollout history deployment/<deployment-name>” command:

Currently we have two revisions of the “demo-deployment” deployment:

To view the specific revision of deployment, the user can use the “–revision” option along with the “kubectl rollout history” command:

Currently, this version of deployment is using the “html-img:2.0” image:

Rollback to Previous Deployment

To rollback to a previous revision, use the “kubectl rollout undo deployment/<deployment-name>” command:

This will create new rollout revision history in Kubernetes rollout:

To view the new revision history of deployment, use the given command:

Here, you can see we have successfully reverted to a previous revision and currently using the “html-img:1.0” image:

Example 9: Kubernetes Service

The Kubernetes service enables us to expose the containerized application within a cluster or outside the cluster. It can expose service on NodePort, ClusterIP, and LoadBalancer. To create and manage the Kubernetes services, use the following kubectl commands.

Create Service

To create the Kubernetes service for deployment, use the “kubectl expose deployment <name>” command. Here, the “–type” option is used to specify the expose type, and “–port” sets the exposing port for service:

The “kubectl expose” command can also be used to expose service for Replica controllers and pods.

Get Service

To access the Kubernetes service, use “kubectl get service” command:

Delete Service

To delete the Kubernetes service, utilize the “kubectl delete service <service-name>” command:

Example 10: Apply Manifest to Create and Update Kubernetes Resources

Applying changes on Kubernetes resources or creating resources using Manifest is the declarative approach. In which, the developer performs implementation by specifying all the instructions in Yaml or Json manifest. Then, these instructions can be applied to resources in Kubernetes using the “kubectl apply” command.

For demonstration, follow the below procedure.

Create Yaml File

First, create a file named “pod.yml” and add the below snippet into the file. The below snippet contains the instructions to create the pod and a pod service:

Apply Yaml Manifest to Create a Pod and Service

After creating the Yaml manifest, apply the instructions using the “kubectl apply -f <filename.yml>” command:

Here, the output shows that we have successfully created the “html” pod and “html-service” service:

Example 11: Kubernetes Nodes

All the Kubernetes processing is done within Kubernetes nodes. However, minikube can execute the one-node cluster. To run a multi-node cluster using minikube, the user needs to run minikube on a Docker driver. For this purpose, first, install and start Docker. After that, run the multi-node minikube cluster.

Start Multi-Node Kubernetes Cluster

To start the multi-node minikube cluster, use the below command. This will automatically choose the “Docker” driver if the Docker engine is running on the system:

Get Nodes

To get the Kubernetes node, use the “kubectl get nodes” command:

Here, you can see currently our cluster has two nodes:

Un-schedule the Node

All the working nodes of Kubernetes are managed through the API scheduler of the control plane node. The unscheduling of a node may be performed to stop the running application, to gracefully drain the node, or to reschedule the node.

To set any Kubernetes node as unschedulable, use the “kubectl cordon <node-name>” command:

Drain Node

Draining the node means terminating and removing all running pods specified node. To drain any node, utilize the below command. Here “–ignore-daemonsets” option is used to ignore the pods of other nodes:

Schedule or Restart the Node

To schedule or restart the unschedulable node in Kubernetes, use the “kubectl uncordon <node-name>” command:

Example 12: Kubernetes ConfigMap

ConfigMap is a Kubernetes API object also known as a configuration settings dictionary. It stores the pod configurations, environment variables, and nonconfidential information of Pods in the form of a key-value pair. Some basic kubectl commands are stated below that can be used to create and manage the Kubernetes ConfigMap.

Create ConfigMap

To create the Kubernetes Configmap, first, create a file that contains data, environment variables, or any non-confidential information. After that, use the below command:

In the above command, “demo-cm” is the name of ConfigMap and the “–from-file” option is used to specify the file from which data will be read and saved in ConfigMap:

Get ConfigMap

To access the Kubernetes ConfigMaps, use “kubectl get configmap” command:

Delete ConfigMap

To delete the ConfigMap from the Kubernetes cluster, use the “kubectl delete configmap <configmap-name>” command:

Example 13: Kubernetes Secret

Kubernetes Secrets is a separate Kubernetes resource that can be used or required by the Pod application to provide or save critical information or credentials such as certificates, tokens, and username/password. To create and manage secrets, the following kubectl commands are used.

Create Secret

To create a secret in Kubernetes, first, create a file that contains user confidential data. For demonstration, we have created two files “username.txt” and “password.txt” to store the username and password, respectively.

After that, create a secret using the “kubectl create secret” command. Here, the “generic” is a type of secret, and the “–from-file” option is used to specify the filename from where data will be read and stored in secret:

Get Secret

To get a secret in Kubernetes, use the “kubectl get secret” command:

Delete Secret

To delete the secret from the cluster, run the “kubectl delete secret <secret-name>” command:

Example 14: Kubernetes Role

Kubernetes roles define the action that the user can perform. To create and manage the role, use the below-given kubectl commands.

Create Role

To create a role in Kubernetes, use the “kubectl role <role-name>” –verb=<value> –resource=<resource-name>” command.

Get Role

Access all Kubernetes roles using the “kubectl get role” command:

Delete Role

To delete the Kubernetes role, utilize the “kubectl delete role <role-name>” command:

Example 15: Kubernetes Logs

The logs are the information about what is happening in the currently executing application and what is going wrong. In Kubernetes, the logs are used to interact with running applications in a pod and to debug the application. To view Kubernetes logs, use the below given kubectl commands.

View Pod Logs

To view the logs of the executing pod, use the “kubectl logs <pod-name>” command:

Sometimes, the user wants to view the log in real-time while running the pod. For this purpose, use the “kubectl logs -f <pod-name>” command. Here the “-f” option is used to follow the pod logs live:

View Deployment Logs

To view the log of Kubernetes deployment, use “kubectl logs deployment/<deployment-name>” command:

The deployment can run multiple pods and a single pod can execute multiple containers. To view the log of a specific container, use the “kubectl log deployment/<deployment-name> -c <container-name>” command:

Example 16: Describe Kubernetes Resource

Sometimes, Kubernetes users want to inspect the Kubernetes resources or find the details about API calls. To show the description of Kubernetes resources, the “kubectl describe” command is utilized. This command combines the API calls and displays a detailed description of resources in Kubernetes.

Describe Pod

Inspect the pod using the “kubectl describe pod <pod-name>” command:

Describe Deployment

To describe the Kubernetes deployment, run the given command:

Describe Service

To view the detailed description of the exposing service, use the “kubectl describe service <service-name>” command:

Describe ConfigMap

To view the data stored in ConfigMap, describe it using the “kubectl describe configmap <configmap-name>” command:

Describe Secret

When the user describes the kubectl secret, this will never show the original value or confidential information. This will only describe the data size in bytes. To describe the secret, use the “kubectl describe secret <secret-name>” command:

That is all about Kubernetes or kubectl commands.

Conclusion

The kubectl is a Kubernetes command line tool utilized to manage and operate the kubernetes cluster and its components. It offers various commands to create, get, update, and delete Kubernetes resources. It also provides kubectl commands to monitor, interact, and debug the containerized application running in the Kubernetes cluster. This blog has provided the different kubectl command examples with proper illustrations.