Kubernetes for Nodejs developers
Tags: node, devops, webdev, showdev
Published: 2020-07-07 15:21:23

---
title: Kubernetes for Nodejs developers
published: true
date: 2020-07-06 00:00:00 UTC
tags: nodejs,devops,webdev,showdev
canonical_url: https://cloudnweb.dev//2020/07/kubernetes-nodejs-developers
---

Do you keep hearing the word Kubernetes in the tech community and you couldn't understand what, why, and how of Kubernetes?. Well, you are in the right place, my friend. I was like that, when people around me talks about Kubernetes and couldn't understand what they talk about. So, In this article, let's understand Kubernetes with nodejs application development.

**Note**: there are a lot of articles out there explains about Kubernetes and it's a workflow in detail. but the main purpose of writing this blog is to explain Kubernetes to a guy like me who wants to learn Kubernetes in an easy and understandable way.

Before, getting into the concept of Kubernetes. let's understand what is Kubernetes and why it's so popular nowadays.

I assume that you have a basic understanding of what is [docker](https://cloudnweb.dev/2019/10/crafting-multi-stage-builds-with-docker-in-node-js), containers, and how to build docker images for nodejs application.

**Prerequisites**

Docker Desktop installed and Kubernetes enabled on your machine.

## Related Articles

[How to Find Project Ideas for Web development](https://cloudnweb.dev/2020/06/how-to-find-project-ideas-web-development)

[Building a Production-grade Nodejs,GraphQL and TypeScript Server with CI/CD Pipeline](https://cloudnweb.dev/2020/04/nodejs-graphql-typescript-starter-part-1)

## What is Kubernetes?

Let's try to understand Kubernetes with simple terms and scenarios. At the beginning of application development, we tend to deploy our application manually just by creating a server in the cloud and deploy our application with either through git or file transfer protocol such as FileZilla.

![Traditional Server](https://dev-to-uploads.s3.amazonaws.com/i/qeo68lwgzknkjj315utz.png)

After the evolution of containers and Docker, application deployment will be like wrapping our application code insider docker containers and deploy them in the server. it solved a lot of problems for us such as installing the dependencies manually and resolve the conflicts that come in that way.

Still, there are some problems that need to solved manually. they are, if we have replicas of the containers, we need to manage them. like if one goes down. we need to restart the replica set and keep checking the health of the cluster.

Then comes Kubernetes, which helps us to manage the containers within a system. Kubernetes helps us to manage the container in a systematic way. Once configured, it will take care of the containers without you need to worry about the containers.

![Architecture](https://dev-to-uploads.s3.amazonaws.com/i/ekqcgtz3pn6q3dprw1n3.png)

Some of the benefits of using Kubernetes are,

- **Service Discovery** - Let's say you have a Container for User REST API and Container for Another domain REST API Container. to make it communicate, you need to make the service available to another one. Kubernetes helps us in that process easier. we will see about this in the later part of this article.
- **Container Orchestration** - If you want to replicas of your container to be running all the time irrespective of failure. Kubernetes solves that problem out of the box. you don't need to worry about that at all. it will make sure that specified replica's available all the time.

## Basics of Kubernetes

Alright!! we reached one of the important topics in the article. Let's see what we need to know in Kubernetes before application development with Kubernetes.

![Core Concepts](https://dev-to-uploads.s3.amazonaws.com/i/5l2g9a125unc6iuho8yo.png)

Firstly, we have master and node,

**Master & Node**

Node is a simply a virtual machine the server. just like how we create a virtual machine. Kubernetes manage the VM as a node.

Master is a controller that controls all the operations in the node and it also manages all the configurations of nodes.

Inside the Node, we have Pod and Container.

**Pod & Container**

Pod in Kubernetes is a collection of containers. most of the time pod will contain only one container. only on some special scenarios, you might need to create multiple containers in the pod.

so far, we have the container inside the pod. but, how do they communicate between the containers? for example, the Nodejs application needs to connect with MongoDB for data access. how does it happen in Kubernetes?

There comes the need of Service in Kubernetes.

**Service**

Service helps us with the communication between the containers. Let me tell you one thing. when i read about services in Kubernetes. I had this question of "Why?", Why do we need other resources to manage the communication? Can't a container talk directly with another container?.

Then I found out the real purpose of Services in Kubernetes. Let's say you have the Container A with IPAddress **`192.16.3.2`** and Container B communicates with Container A using this IPAddress. After some time, your Container A dies and Kubernetes recreates a new container for you on the Node. Now, the IPAddress will be different for the Container. Now, how can ContainerB communicates with A with the IPAddress is different

This is the main purpose of having the Kubernetes Service.

**Deployment**

Deployment is a way to create pods and containers in Kubernetes. it read the configuration file and pull the docker images from the hub and create the container out of it.

Most of the time, you will be writing the YAML configuration for **Service** and **Deployment** Resources**.** Sometimes, you might need to create some other resources.

## Running Nodejs with Kubernetes

Here we have a simple nodejs application to deploy using Kubernetes. create app.js and add the following code,

```jsx
const express = require("express")

const app = express()

app.get("/", (req, res) => {
  res.send({
    data: "Kubernetes is Awesome",
  })
})

const PORT = process.env.PORT || 8080

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`)
})
```

After that, create a folder to write the kubernetes configuration. `infra/app-deploy.yaml`

```yaml
---
apiVersion: v1
kind: Service
metadata:
  name: my-node-app-service
  labels:
    app: my-node-app-service
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 8080
  type: LoadBalancer
  selector:
    app: mynodeapp
---

```

Let's break it down one by one. For any resources that you create for kubernetes. it always start with `apiVersion` and `kind`

```yaml
apiVersion: v1
kind: Service
```

Here, we mention the kind as `Service` which create the service for us. there are four type of `Service` in the kubernetes.

1. **ClusterIP** - it exposes the service to be accessed within the cluster. you can access this service using the IPAddress of the cluster.
2. **NodePort** - NodePort helps us to connect Pods to external IP's. it maps the Node Port with Pod Port which helps to access the Pod externally. Note: Port of Node ranges from 30000 - 32767
3. LoadBalancer - it is similar to NodePort except that it balances the load with multiple ports.
4. ExternalName - it maps the service and pods to the **CNAME** record

Here, we will be using LoadBalancer Service to map the NodePort with Containers.

Coming back to the configuration. then we have, `metadata` which helps to identify the service.

```yaml
metadata:
  name: my-node-app-service
  labels:
    app: my-node-app-service
```

After that, we have the main part of the configuration which is `spec`. Here, we specify the type of service along with the port and target port

```yaml
spec:
  ports:
    - port: 80
      protocol: TCP
      targetPort: 8080
  type: LoadBalancer
  selector:
    app: mynodeapp
```

**Service WorkFlow**

![Service NodePort](https://dev-to-uploads.s3.amazonaws.com/i/eazbj1ke7ievfyaqujhr.png)

On the above diagram, we need to access the pod from external IP. to do that, we configure `Service` which maps the port between Pod and NodePort.

Service maps the Port with the targetPort and it maps with NodePort to route the traffic into the Pod.

So far, we have seen how to configure the `Service` .let's see how to create the Pods and Containers inside of it. To do that, we need to create `Deployment` Resources.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
  labels:
    app: mynodeapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: mynodeapp
  template:
    metadata:
      labels:
        app: mynodeapp
    spec:
      containers:
        - name: mynodeapp
          image: ganeshmani009/nodesample
          ports:
            - containerPort: 8080
          imagePullPolicy: Always
          env:
            - name: PORT
              value: "8080"
            - name: MONGODB_URL
              value: mongodb://mongo:27017/sampledb
```

This seems to be a bit long. right?. let's try to break it down and understand better. just like before, we have the basic information about the resource,

```yaml
# configuration
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-deployment
  labels:
    app: mynodeapp
```

After that, we have `spec` with configuration for the `template` and `replicaSet`

```yaml
# Configuration for the replica set
replicas: 2
  selector:
    matchLabels:
      app: mynodeapp
```

Then, we have the configuration for the pod, which pulls the image from the docker hub and creates the container inside the pod.

```yaml
template:
  metadata:
    labels:
      app: mynodeapp
  spec:
    containers:
      - name: mynodeapp
        image: ganeshmani009/nodesample
        ports:
          - containerPort: 8080
        imagePullPolicy: Always
        env:
          - name: PORT
            value: "8080"
          - name: MONGODB_URL
            value: mongodb://mongo:27017/sampledb
```

Once you complete the configuration, run the command in the terminal.

```bash
kubectl apply -f app-deploy.yaml
```

![Pod Deploy Command](https://dev-to-uploads.s3.amazonaws.com/i/9dkajgw8mgbfvjer4g0i.png)

you can check the pods using the command

```bash
kubectl get pods
```

![Get Pods](https://dev-to-uploads.s3.amazonaws.com/i/6uouazsz8l7gjhr024b7.png)

Since, we configured `replicaSet` as 2. it creates two pods for us. to check the service.

```bash
kubectl get service
```

![Get Service](https://dev-to-uploads.s3.amazonaws.com/i/be11gqb4eiofrn6of6v5.png)

### Conclusion

we just scratched the surface in the Kubernetes world. In the upcoming article, we will see how to connect the MongoDB with nodejs application in Kubernetes. we will also see some use-cases on how nodejs and Kubernetes used in production. Until then, Happy Coding :-)