Deploying Web Applications on Kubernetes: A Beginner's Guide
Tags: kubernetes, tutorial, programming, devops
Published: 2024-02-16 07:41:12

Happy new month everyone! Kubernetes has become the leading platform for deploying and managing containerized web applications. In this beginner's guide, we will walk through the key Kubernetes concepts and resources involved in deploying and updating web apps. We will also discuss the different deployment strategies that can be used to deploy web applications on Kubernetes.

## Introduction

When deploying web applications on Kubernetes, two main resources are used:

  - **Deployments** - Used to manage multiple instances of a containerized web app.
  - **Services** - Expose deployments to external traffic.

We will cover how these resources work together to run and expose web apps. We will also discuss common deployment strategies like rolling updates, blue-green, and canary deployments.

By the end of this guide, you will understand:

- The role of deployments and services
- How to create and update deployments
- Strategies like rolling updates to deploy new versions
- How to expose apps externally using services

Let's get started! The diagram below gives a high-level overview of the steps we'll be going through.

![K8s Workflow](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/614cl93d85e27f5yhqdn.png)

## Deployments in Kubernetes

A deployment controllers manages a set of identical pods (containers) that make up your application.

When you create a deployment, you specify the container image and the number of replicas (pods) you want to run. Kubernetes will spin up the pods and make sure the specified number are kept running.

For example, a simple deployment might create 3 replicas of an application container. If one of the pods goes down, Kubernetes will automatically re-create it to match the desired state.

Deployments allow you to easily scale up or down your application by changing the replica count. They also support rolling updates to push new versions of your application code.

Here is an example deployment manifest:

  ```yaml
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: my-webapp
  spec:
    replicas: 3
    selector:
      matchLabels:
        app: my-webapp
    template:
      metadata:
        labels:
          app: my-webapp
      spec:
        containers:
        - name: my-webapp
          image: nginx:1.7.9
          ports:
          - containerPort: 80
  ```

This will create a deployment named `my-webapp` that runs 3 replicas of the `nginx:1.7.9` image exposed on port 80.

## Services in Kubernetes

While deployments run containers inside pods, _services_ expose your deployments so they can be accessed from outside the cluster.

There are different types of Kubernetes services. The main ones are:

 - **ClusterIP** - Exposes pods only within the cluster.
 - **NodePort** - Makes deployments accessible via node ports.
 - **LoadBalancer** - Provisions a cloud load balancer to route traffic.

For example, you may run a ClusterIP service to keep your app internal, and a NodePort service to allow external access.

Here is an example service manifest:

```yaml
  apiVersion: v1
  kind: Service
  metadata:
    name: my-webapp-service
  spec:
    selector:
      app: my-webapp
    type: NodePort  
    ports:
      - port: 80
        targetPort: 80
        nodePort: 30007
```

This exposes our `my-webapp` deployment on port 30007 of every cluster node.

With deployments and services, you have the basic resources to run and expose containerized web applications on Kubernetes.

Next we will look at deployment strategies...

## Deployment Strategies

There are several common strategies used to deploy new versions of your application:

### Rolling Updates

The rolling update is the default strategy used if you apply a change to your Kubernetes deployment manifest.

It works by slowly replacing old pods with new ones a few at a time, rather than stopping everything at once. This allows changes to be applied without downtime.

The rollout pauses if too many pods become unavailable, ensuring availability. Rollbacks can also be performed.

### Blue-Green Deployment

With blue-green deployments, instead of changing the existing deployment directly, you deploy the new version alongside the old version.

Once the new version is up and tested, you switch over by pointing the service to the new deployment. Traffic immediately shifts over to the new version.

This makes rollbacks as easy as switching the service back to the old deployment if issues arise.

### Canary Deployment

With canary deployments, you slowly roll out a new version to a small subset of users to test it out before rolling it out to everybody.

This allows you to catch any issues with a new version early with minimal impact. Traffic is gradually shifted over time until all users have the new version.

## Deploying a Web App on Kubernetes

Now that we have covered the key concepts, let's walk through a simple example of deploying a web application.

![K8S Web Deployment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/74h3juzprec6jj9cqccq.png)

We will deploy the free open-source [Cowsay](https://hub.docker.com/r/docker/getting-started) app which displays a cow saying messages.

**Step 1 - Create the deployment**

First we create a deployment manifest `cowsay.yaml`:
```yaml
  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: cowsay
  spec:
    replicas: 3
    selector:
      matchLabels:
        app: cowsay
    template:
      metadata:
        labels:
          app: cowsay
      spec:
        containers:
        - name: cowsay
          image: docker/getting-started
          ports:
          - containerPort: 80
```

This will deploy 3 replicas of the cowsay image exposed on port 80.

 **Step 2 - Create the service**

Now we create a service manifest `cowsay-service.yaml` to expose the deployment:

```yaml
  apiVersion: v1
  kind: Service
  metadata:
    name: cowsay-service
  spec:
    selector:
      app: cowsay
    ports:
      - port: 80
        targetPort: 80
```

This is a simple ClusterIP service to expose the cowsay internally.

**Step 3 - Deploy the app**

We can now deploy the app using `kubectl`:

```shell
  kubectl apply -f cowsay.yaml
  kubectl apply -f cowsay-service.yaml
```

That's it! The cowsay app is deployed and exposed on your Kubernetes cluster. Run the following commands to see deployment, services and pods that were created.

```shell
  kubectl get deployments
  kubectl get services
  kubectl get pods
```

From here you could update the deployment or expose it via a NodePort to make it externally accessible.

## Summary

In this guide we covered:

- **Deployments** - For running a number of identical pod replicas
- **Services** - For exposing deployments internally and externally
- Common **deployment strategies** like rolling updates and blue-green
- Walkthrough of **deploying a sample app** on Kubernetes

We discussed how deployments can be used to manage multiple instances of a pod, how services can be used to expose web applications to the outside world, and the different deployment strategies that can be used to deploy web applications on Kubernetes. By understanding these concepts, you can begin to deploy your own web applications on Kubernetes.

This should give you a solid foundational understanding of running web applications on Kubernetes.

For more hands-on practice, I recommend checking out the [Kubernetes documentation](https://kubernetes.io/docs/tutorials/kubernetes-basics/) and trying out examples locally using [minikube](https://minikube.sigs.k8s.io/docs/start/).

In the next article, we will explore how to scale and monitor web applications on Kubernetes. We will cover the different ways to scale your applications, and the tools and techniques required to monitor your applications. We will also discuss the different metrics that can be used to monitor your applications, and the different tools that can be used to visualize these metrics.

I hope you have enjoyed this article. If you have any questions, please feel free to reach out to me on [Twitter](https://twitter.com/KenMwaura1). or [LinkedIn](https://www.linkedin.com/in/kennedy-mwaura/). You can also check out my other articles on [Dev.to](https://dev.to/ken_mwaura1). Thanks for reading!

Buy me a coffee [here](https://www.buymeacoffee.com/kenmwaura1).

![image](https://media.dev.to/cdn-cgi/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fmthxo12c3pejx4nz6dkq.gif)

## References

- [Kubernetes Deployments Documentation](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/)
- [Kubernetes Services Documentation](https://kubernetes.io/docs/concepts/services-networking/service/)
- [Kubernetes Rolling Update Documentation](https://kubernetes.io/docs/tasks/run-application/rolling-update-replication-controller/)
- [Kubernetes Blue-Green Deployment Tutorial](https://kubernetes.io/blog/2018/04/30/zero-downtime-deployment-kubernetes-jenkins/)
- [Canary Deployments on Kubernetes](https://www.replex.io/blog/canary-deployment-strategies-kubernetes-istio)
- [Getting Started with Kubernetes](https://kubernetes.io/docs/tutorials/kubernetes-basics/)
- [Deploy a sample app on Kubernetes](https://kubernetes.io/docs/tutorials/hello-minikube/)
- [Minikube documentation](https://minikube.sigs.k8s.io/docs/)