Kubernetes is an open-source container orchestration system that automates the deployment, scaling, and management of containerized applications. One of the key building blocks in Kubernetes is the pod, which is the smallest and simplest unit in the Kubernetes object model. In this blog post, we'll go over how to create a Kubernetes pod.
What is a Kubernetes Pod?
A pod is the smallest deployable unit in the Kubernetes object model. It represents a single instance of a running process in a cluster. A pod encapsulates one or more containers, storage resources, and network resources that are needed to run a specific application or service.
A pod can contain one or more containers that share the same network namespace, which means they can communicate with each other over the localhost interface. A pod also has a unique IP address, which allows it to communicate with other pods in the same cluster. This IP address is allocated by the Kubernetes API server when the pod is created.
Creating a Kubernetes Pod
To create a Kubernetes pod, we need to define a pod specification in a YAML file. The specification contains information about the pod, such as the container images to use, the commands to run, and the network settings.
Let's take a look at an example pod specification:
- name: my-container
- containerPort: 80
This YAML file defines a pod with a single container named my-container. The container uses the nginx image and exposes port 80.
Let's break down the YAML file and explain what each field means:
- apiVersion: The version of the Kubernetes API that this object uses.
- kind: The type of object we're creating, in this case, a pod.
- metadata: Metadata about the pod, such as its name.
- spec: The specification of the pod, which includes information about its containers, volumes, and other settings.
- containers: A list of containers to run in the pod.
- name: The name of the container.
- image: The container image to use.
- ports: A list of ports to expose on the container.
- containerPort: The port number to expose on the container.
- containers: A list of containers to run in the pod.
Once you've created the YAML file, you can create the pod by running the
kubectl create command and passing the YAML file as an argument:
$ kubectl create -f my-pod.yaml
This will create the pod and start the container(s) defined in the specification.
Verifying the Pod is Running
To verify that the pod is running, you can use the
kubectl get pods command:
$ kubectl get pods
This will show a list of all the pods running in the cluster. You should see your newly created pod in the list. Example output is detailed below:
NAME READY STATUS RESTARTS AGE
my-pod 1/1 Running 0 2m
my-pod-2 1/1 Running 0 1m
my-pod-3 0/1 Pending 0 5s
This output shows a list of all the pods running in the cluster, along with their current status. Let's break down each column:
- NAME: The name of the pod.
- READY: The number of containers that are ready to serve requests out of the total number of containers defined in the pod.
- STATUS: The current status of the pod, which can be Running, Pending, Succeeded, Failed, or Unknown.
- RESTARTS: The number of times the container has been restarted.
- AGE: The amount of time since the pod was created.
If you want to get more detailed information about the pod, you can use the
kubectl describe command:
$ kubectl describe pod my-pod
This will show detailed information about the pod, including its status, events, and containers. Example output is detailed below:
Start Time: Mon, 22 Feb 2021 13:00:51 -0800
Container ID: docker://8e5051f181...
Image ID: docker-pullable://nginx@sha256:73132a981eb57fca02...
Host Port: 0/TCP
Started: Mon, 22 Feb 2021 13:01:24 -0800
Restart Count: 0
/var/run/secrets/kubernetes.io/serviceaccount from default-token-hwqgc (ro)
Type: Secret (a volume populated by a Secret)
QoS Class: BestEffort
Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Scheduled 2m default-scheduler Successfully assigned default/my-pod to minikube
Normal Pulling 2m kubelet Pulling image "nginx:latest"
Normal Pulled 2m kubelet Successfully pulled image "nginx:latest"
Normal Created 2m kubelet Created container my-container
Normal Started 2m kubelet Started container my-container
This output provides a more detailed view of the my-pod pod, including its status, containers, volumes, and events. Let's break down some of the key sections:
- Name: The name of the pod.
- Namespace: The namespace that the pod belongs to.
- Status: The current status of the pod.
- Containers: A list of containers running in the pod.
- Events: A list of events related to the pod, such as when it was scheduled, when containers were pulled and created, and when the pod was started.
In this example, we can see that the my-pod pod has one container (my-container) running the nginx:latest image. The container is listening on port 80, and the pod is running on the minikube node.
Updating a Pod
If you need to update the pod's configuration, such as adding a new container or changing the container image, you can edit the YAML file and apply the changes using the
kubectl apply command:
$ kubectl apply -f my-pod.yaml
This will update the pod with the new configuration.
Deleting a Pod
If you need to delete a pod, you can use the kubectl delete command:
$ kubectl delete pod my-pod
This will delete the pod and all of its resources.
In this blog post, we went over how to create a Kubernetes pod using a YAML file. We covered the different fields in the specification and how to use the
kubectl command-line tool to create, update, and delete pods.
Creating and managing pods is an essential skill for any Kubernetes user. Pods are the building blocks of Kubernetes, and they form the basis for higher-level objects like services, deployments, and stateful sets. By understanding how to create and manage pods, you'll be well on your way to mastering Kubernetes.