How to Run Shell Commands in Kubernetes Pods or Containers

 Kubernetes—commonly known as K8s—is an open-source container orchestration platform originally developed by Google and now maintained by the Cloud Native Computing Foundation (CNCF). It is designed to automate the deployment, scaling, and management of containerized applications, helping organizations achieve agility and consistency across environments.

Running shell commands inside Kubernetes Pods or containers is a fundamental skill for developers and DevOps engineers managing applications in Kubernetes clusters. This guide will walk you through how to do it step-by-step, using Minikube for demonstration.

---

Setting Up a Kubernetes Cluster

Before executing shell commands, ensure that your Kubernetes cluster is properly set up. You can do this in one of two ways:

1. Full Cluster Setup – A production-grade environment with multiple nodes.

2. Single-Node Setup with Minikube – A lightweight local Kubernetes environment ideal for testing and development.

The main difference is that Minikube runs on a single node, making it simpler to configure and manage. You can install Minikube based on your system’s OS and architecture. (For more details, refer to: Setting Up Minikube in Your Local System.)

---

Understanding Kubernetes Pods and Containers

In Kubernetes, Pods are the smallest deployable units. A pod encapsulates one or more tightly coupled containers that share the same network namespace and storage volumes.

Think of a Pod as an abstraction layer on top of containers that adds metadata and orchestration capabilities. It contains the application’s code, libraries, runtime, and dependencies—ensuring consistent behavior across environments.

Now, let’s learn how to execute shell commands inside a Kubernetes Pod.

---

Executing Commands Inside a Kubernetes Pod

In this example, we’ll use Minikube to demonstrate the process.

Step 1: Start Minikube

Run the following command to start your local Kubernetes cluster:

minikube start

This initializes and configures a single-node Kubernetes cluster.

---

Step 2: Check Minikube Status

Verify that Minikube is running:

minikube status

If everything is working correctly, you should see the cluster components listed as Running.

---

Step 3: Create a Pod Using an NGINX Image

Run the following command to create a Pod:

kubectl run nginx-pod --image=nginx

This command pulls the NGINX image from Docker Hub and creates a pod named nginx-pod.

---

Step 4: List All Pods

Confirm that your pod is created and running:

kubectl get pods

You should see nginx-pod listed with a Running status.

---

Step 5: Access the Minikube Environment

Connect to your Minikube instance via SSH:

minikube ssh

This allows you to interact directly with the underlying virtual machine hosting your Kubernetes cluster.

---

Step 6: List Running Containers

Inside the Minikube environment, list all containers:

docker ps -a

You’ll see containers corresponding to your Kubernetes pods, including the NGINX container.

---

Step 7: Access the Container Shell

To enter the NGINX container, use:

docker exec -it <container_id> /bin/bash

Once inside, you can run Linux shell commands such as:

ls
pwd
cd /usr/share/nginx/html

You are now working directly within the containerized environment of your Kubernetes pod.

---

Alternative: Using kubectl exec (Recommended)

Instead of SSHing into Minikube and using Docker, you can directly execute commands in your pod from your local terminal:

kubectl exec -it nginx-pod -- /bin/bash

This command opens an interactive shell inside the nginx-pod container without requiring Docker commands.

---

Best Practices for Running Shell Commands in Kubernetes

1. Use kubectl exec Carefully
   Always specify the exact pod and container when executing commands to avoid unintentional changes.

2. Use the -c Flag for Multi-Container Pods
   When a pod has multiple containers, access a specific one by adding the -c flag:

   kubectl exec -it <pod_name> -c <container_name> -- /bin/bash
   

3. Execute Sequential Commands with &&
   For running multiple commands in sequence:

   kubectl exec -it nginx-pod -- sh -c "cd /usr/share/nginx/html && ls && cat index.html"
   

4. Debug with kubectl debug
   Launch a debugging session in a running pod:

   kubectl debug -it nginx-pod --image=busybox
   

   This is useful for troubleshooting live workloads.

5. Use Non-Interactive Execution for Automation
   For scripts or CI/CD pipelines, run non-interactive commands:

   kubectl exec nginx-pod --stdin=false --tty=false -- ls /var/log/nginx
   

---

Conclusion

Understanding how to run shell commands inside Kubernetes Pods is essential for managing, debugging, and maintaining containerized applications.

Using tools like Minikube simplifies learning and experimentation, while kubectl exec provides a direct and efficient way to interact with your containers.

Mastering these techniques will help developers and DevOps engineers manage Kubernetes environments with greater confidence, agility, and control—boosting both development speed and operational reliability.