Understanding Kubernetes Architecture: Deployments, Pods, and Services?

In this blog, I'm going to teach you about how Kubernetes deployments, services and pods work together, we'll take a deep dive into it with a practical example.

26 April, 2023

Contributors

Hasnain Makada

@hasnainmakada-99

Introduction

Hey everyone, I am Hasnain Makada, and I am currently working as a Rotational Super Writer at Showwcase where I produce high-quality content on tech and make it understandable in a simple for my community. Today in this blog, I will explain to you about Kubernetes deployments, pods and services, and how these three work together. We are also going to use a sample hello-world project which we will deploy with the help of Kubernetes.

So without wasting any furthermore time, Let's get started.

In order to run K8s inside your local machine, we are required to install minikube, now let's talk a little bit about minikube.

What is Minikube?

Minikube is a tool that allows you to run a single-node Kubernetes cluster locally on your computer. It is used for development and testing purposes, as well as for learning and experimentation with Kubernetes.

In simple words, Minikube provides a way for developers and users to test and experiment with Kubernetes without having to set up a full-scale Kubernetes cluster. It creates a virtual machine on your local computer that runs a lightweight version of Kubernetes, allowing you to deploy and manage applications as if you were running them on a real Kubernetes cluster.

What is a Kubernetes Deployment?

A deployment in Kubernetes is a resource that provides declarative updates to the application running inside a pod. It enables you to declaratively manage the desired state of your application by defining a template for the pods. This template includes the container image, configuration, and other necessary details for the pod. When you create a deployment, Kubernetes automatically creates the required number of pods, based on the replica count specified in the deployment. Kubernetes then ensures that the specified number of replicas is always running, and if any of the pods fail, it replaces them with new ones. Deployments also provide a mechanism to roll out updates to your application in a controlled manner.

K8s Deployment file demo

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-container
          image: my-image:latest
          ports:
            - containerPort: 80

Let's see what is happening in the above code,

apiVersion and kind: These fields specify that we're creating a Kubernetes deployment.
metadata: This field specifies the name and labels for our deployment.
spec: This field specifies the desired state for our deployment. In this case, we want three replicas of our app.
selector: This field specifies the label selector that will be used to match our pods.
template: This field specifies the pod template that will be used to create our pods.
containers: This field specifies the container(s) that will be run in our pod.
name: This field specifies the name of our container.
image: This field specifies the Docker image that our container will run.
ports: This field specifies the ports that will be exposed by our container.

So in this way, a kubernetes deployment is created and K8s deployment is directly linked with the creation of pods so whenever you're trying to create a deployment, pods will be created automatically.

What is a Kubernetes Service?

A Kubernetes service is a way to provide a stable network connection to a set of pods that are running your application. It acts as a stable endpoint for your application, even if the underlying pods are destroyed or recreated.

A Kubernetes service can also handle load balancing, and routing traffic to the appropriate pods based on the configuration you provide. For example, you might want to distribute traffic evenly across all available pods, or direct traffic to pods with specific labels or annotations.

K8s Service file demo

apiVersion: v1
kind: Service
metadata:
  name: my-service
  labels:
    app: my-app
spec:
  selector:
    app: my-app
  ports:
    - name: http
      port: 80
      targetPort: 8080
  type: ClusterIP

Let's see what is being done with the above code,

apiVersion and kind: These fields specify that we're creating a Kubernetes service.
metadata: This field specifies the name and labels for our service.
spec: This field specifies the desired state for our service.
selector: This field specifies the label selector that will be used to match our pods.
ports: This field specifies the ports that will be exposed by our service and the target port for traffic to be routed to on the pods.
type: This field specifies the type of service we want to create. In this example, we're usingClusterIP which provides a stable internal IP address for the service within the cluster.

So from the above explanation, you can clearly conclude that if you want to configure kubernetes pods automatically, you can do that with the help of services and make any changes to the networking of the pods.

What is a Kubernetes Pod?

In Kubernetes, a pod is the smallest and simplest unit of deployment. A pod is a single instance of a running process in a cluster, and it can contain one or more containers.

Think of a pod as a logical host for your application. The containers inside a pod share the same network namespace and can communicate with each other using localhost. They can also share the same storage volumes, making it easier to manage data persistence.

Kubernetes uses pods as the basic building block for deploying and scaling applications. By organizing your application into pods, you can easily manage and scale the different components of your application independently. For example, you might have one pod for your application's web server, another pod for a background worker process, and a third pod for a database. So in short, you can configure it at your convenience.

K8s Pod demo file

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
  labels:
    app: my-app
spec:
  containers:
    - name: my-container
      image: nginx:latest
      ports:
        - containerPort: 80

So what is happening in the above code,

apiVersion and kind: These fields specify that we're creating a Kubernetes pod.
metadata: This field specifies the name and labels for our pod.
spec: This field specifies the desired state for our pod.
containers: This field specifies the containers that will be run inside our pod. In this example, we have one container named my-container running the nginx image.
name and image: These fields specify the name and Docker image for our container.
ports: This field specifies the ports that will be exposed by our container.

From the above breakdown, we can conclude that we can configure our kubernetes pod as we want and in the end, everything breaks down to a pod in k8s.

Let's understand it practically!

To run Kubernetes in your system, make sure you have docker desktop as well as minikube installed in your system.

Now start minikube in your system by runningminikube start

And see if any deployments, services or pods are there running,

kubectl get deployment

kubectl get services

kubectl get pods

Now create a new directory and inside that create a new deployment.yaml file and paste this deployment code inside it.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-app
spec:
  replicas: 5
  selector:
    matchLabels:
      app: hello-world-app
  template:
    metadata:
      labels:
        app: hello-world-app
    spec:
      containers:
        - name: hello-world-app
          image: hasnainmakada/hello-world
          resources:
            limits:
              memory: "128Mi"
              cpu: "500m"
          ports:
            - containerPort: 3000

For the above code, I've used a custom docker image made by me, you can find it here 👇

https://hub.docker.com/repository/docker/hasnainmakada/hello-world/general

Now create a services.yaml for the same,

apiVersion: v1
kind: Service
metadata:
  name: hello-world-service
spec:
  selector:
    app: hello-world-app
  ports:
    - port: 3000
      targetPort: 3000

The above YAML file creates a Kubernetes service that acts as a load balancer for pods running an application with the label app: hello-world-app. By creating a service, we can decouple the pods running our application from the network details of our Kubernetes cluster, and expose our application to other pods and services using a simple and consistent interface.

Now apply the YAML file using the following command:

Kubectl apply -f <path-to-yaml-file>

Apply the above command for both the deployments as well as for the services too.

Now run the below commands to check whether the pods are running successfully or not

kubectl get deployments

kubectl get pods

We've defined 5 replicas inside the deployment service, so 5 were created and you can scale them as per your need.

Let's port-forward any particular pod

kubectl port-forward hello-world-app-5b4c88475c-2z5n7 3000:3000

Redirect to localhost:3000

You can also see the services for your deployment,

And now you can scale your application as per your need with the help of Kubernetes.

Make sure to delete the resources created so that it does keep lying inside your cluster.

kubectl delete deployment hello-world-app

kubectl delete service hello-world-app

FAQ's

What is a Deployment in Kubernetes?
A Deployment in Kubernetes is a higher-level object that manages a set of replica Pods. Deployments are responsible for rolling out updates to the application running in a Kubernetes cluster while ensuring the availability of the application during the upgrade process.
What is a Pod in Kubernetes, and how is it related to a Deployment?
A Pod in Kubernetes is the smallest and simplest unit of the Kubernetes object model. It is a single instance of a running process in a container within the Kubernetes cluster. Pods are created and managed by Deployments, which ensure that the desired number of replicas of the Pod is running at any given time.
What is a Service in Kubernetes, and how does it relate to Deployments and Pods?
A Service in Kubernetes is a way to expose a set of Pods as a network service. Services provide a stable IP address and DNS name that can be used by other parts of the application or by external users to access the Pods. Services are typically associated with Deployments and Pods using labels to ensure that they route traffic to the correct Pods.
Can multiple Services point to the same Pods?
Yes, multiple Services can point to the same Pods. This can be useful when you want to expose different endpoints or ports of the same application to different users or parts of the system.
Can Deployments, Pods, or Services be scaled up or down based on demand?
Yes, Deployments, Pods, and Services can all be scaled up or down based on demand. Scaling is achieved by changing the number of replicas specified in the Deployment or by updating the resource limits of the Pods. Services can also be scaled horizontally by increasing the number of Pods they route traffic to.

Conclusion

In conclusion, Kubernetes deployments, services, and pods work together to provide a powerful and flexible system for managing containerized applications. By defining a desired state for our application with a deployment, exposing it with a service, and managing the actual running instances with pods, we can easily scale, update, and manage our applications on Kubernetes.

If you have any more doubts related to DevOps and Flutter, feel free to reach out on Showwcase and Twitter.

devops

kubernetes

k8s

services

deployments