Maximum performance at minimal cost. Start your server in seconds now!

    Dockerization and Kubernetes Deployment of a Node.js Application

    Containerization and Deployment with Ease: This tutorial guides you step-by-step through the Dockerization and Kubernetes deployment of a Node.js application.

    From the basics to implementation, this post provides clear step-by-step instructions and valuable insights. Learn how to efficiently modernize and scale your application using these powerful tools.

    Step 1 – Clone the Node.js Project Code

    First, clone the Node.js project code from GitHub:

    Copy Code 
    git clone https://github.com/your-username/your-nodejs-app.git

    Then navigate to the directory of the cloned project code:

    Copy Code 
    cd your-nodejs-app

    Step 2 – Dockerize the Application

    The Node.js application needs to be prepared to run in a Docker container. Create a Dockerfile in the root directory of the application and a .dockerignore file to manage files and directories you want to exclude when building the image.

    Create a Dockerfile:

    Copy Code 
    touch Dockerfile

    Open the Dockerfile in your preferred text editor and insert the following content:

    Copy Code 
    # Use the official Node.js 14 image as the base image
    
FROM node:14
    

    # Set the working directory in the container
    
WORKDIR /usr/src/app
    

    # Copy dependency files to the working directory
    
COPY package*.json ./
    

    # Install dependencies
    
RUN npm install
    

    # Copy the application code to the working directory
    
COPY . .
    

    # Change the default port number
    
ENV PORT=8080
    

    # The container listens on the port defined above
    
EXPOSE $PORT
    

    # Start the application
    
CMD [ “node”, “index.js” ]

    Save and close the file.

    Step 3 – Translate Compose Services to Kubernetes Objects with Kompose

    Now that you have cloned the Node.js project code and packaged the application, you can translate your Docker Compose service definitions to Kubernetes objects. You can use KOMPOSE to facilitate this translation. Start by creating a new YAML file named docker-compose.yaml in the application’s root directory:

    Copy Code 
    touch docker-compose.yaml

    Open the file in your preferred text editor and insert the following content:

    Copy Code 
    version: ‘3’
    

    services:
    
web:
    
build: .
    
image: nodejs-mongo-web
    
ports:
    
– “8080:8080”
    
environment:
    
– MONGODB_URI=mongodb://mongodb:27017/hai
    
depends_on:
    
– mongodb
    

    mongodb:
    
image: mongo
    
ports:
    
– “27017:27017”
    
environment:
    
– MONGO_INITDB_DATABASE=hai

    Save and close the file. This file defines two services: one for the Node.js application and one for the MongoDB database. The web service definition specifies that the application code is built using the Dockerfile in the current directory and specifies that the application listens on port 8080 in the container and port 8080 on the host. The mongodb service definition specifies that the official MongoDB container is used and that MongoDB listens on port 27017 in the container and port 27017 on the host.

    Now compile the Docker Compose service definitions into Kubernetes objects with the following kompose command:

    Copy Code 
    kompose convert -f docker-compose.yaml

    This command reads the service definitions in docker-compose.yaml and outputs the corresponding Kubernetes objects in YAML format. By default, it will be split into four files: one for the Node.js application, one for the MongoDB database, one for the service exposing the Node.js application, and one for the secret containing the MongoDB credentials.

    For more information on kompose commands and options, consult the KOMPOSE documentation.

    Once the service definitions have been translated into Kubernetes objects, they will be created in a new directory named KOMPOSE. Navigate to this directory to review the files:

    Copy Code 
    cd kompose

    You should see four YAML files: nodejs-mongo-web-deployment.yaml, mongodb-deployment.yaml, nodejs-mongo-web-service.yaml, and mongodb-secret.yaml. These files correspond to the Kubernetes objects created by KOMPOSE: deployments for the Node.js application and MongoDB database, a service exposing the Node.js application, and a secret containing the MongoDB credentials.

    Open each file in your preferred text editor and review the generated Kubernetes objects:

    • nodejs-mongo-web-deployment.yaml: Contains the deployment definition for the Node.js application, including container specs, environment variables, and pod labels.
    • mongodb-deployment.yaml: Contains the deployment definition for the MongoDB database, including container specs, pod labels, and persistent volume claims.
    • nodejs-mongo-web-service.yaml: Contains the service definition for the Node.js application, including service type and target port.
    • mongodb-secret.yaml: Contains the secret object with MongoDB credentials, encrypted as base64.

    You can now use these YAML files to create the Kubernetes objects in your cluster. However, you may need to make some adjustments to ensure they meet your specific requirements. For example, you should adjust the environment variables and access permissions to suit your specific use case.

    Step 4 – Creating Kubernetes Secrets

    Before creating your Kubernetes objects, you must create the secret object with the MongoDB credentials. First, create a Kubernetes secret object from the mongodb-secret.yaml file:

    Copy Code 
    kubectl apply -f mongodb-secret.yaml

    This command creates the secret object in the current Kubernetes namespace. To create the secret object in a different namespace, use the -n flag.

    Verify that the secret object was created successfully:

    Copy Code 
    kubectl get secret mongodb

    You should see output similar to the following:

    Copy Code 
    NAME TYPE
    

    DATA AGE
    
mongodb Opaque 2 10s

    The secret object named mongodb has been successfully created. It contains two data fields: username and password, which hold the MongoDB credentials.

    Step 5 – Customizing Kubernetes Objects

    Before creating the Kubernetes objects, you should make some adjustments to ensure they meet your specific requirements. This includes setting environment variables, adjusting access permissions, and configuring resource limits.

    First, open the nodejs-mongo-web-deployment.yaml file in your preferred text editor and make the following adjustments:

    • Set the environment variable MONGODB_URI to reference the secret object containing MongoDB credentials.
    • Add an init container that waits for the MongoDB database to be ready before starting the Node.js application.

    First, add the init container to the deployment definition of the Node.js application. Open the nodejs-mongo-web-deployment.yaml file and add the following init container spec under spec.template.spec.containers:

    Copy Code 
    initContainers:
    
– name: init-db
    
image: mongo
    
command: [‘sh’, ‘-c’, ‘until mongo –eval “db.adminCommand(‘ping’)”; do sleep 2; done’]

    Save and close the file.

    Then, create the service for the MongoDB database. Open the mongodb-service.yaml file and add the following service definition under spec:

    Copy Code 
    apiVersion: v1
    
kind: Service
    
metadata:
    
name: mongodb
    
labels:
    
io.kompose.service: mongodb
    
spec:
    
ports:
    
– name: “27017”
    
port: 27017
    
targetPort: 27017
    
selector:
    
io.kompose.service: mongodb

    Save and close the file.

    Step 6 – Creating the Kubernetes Objects

    Once you’ve made the adjustments, you can create your Kubernetes objects in the cluster. Use the kubectl apply command to deploy the definitions to your cluster:

    Copy Code 
    kubectl apply -f nodejs-mongo-web-deployment.yaml
    
kubectl apply -f mongodb-deployment.yaml
    
kubectl apply -f nodejs-mongo-web-service.yaml
    
kubectl apply -f mongodb-service.yaml

    After creating the Kubernetes objects, you can check the status of the pods to ensure they started successfully:

    Copy Code 
    kubectl get pods

    You should see output similar to the following:

    Copy Code 
    NAME READY STATUS RESTARTS AGE
    
mongodb-6b789f4577-gj22z 1/1 Running 0 5m
    
nodejs-mongo-web-695b58d4d4-d8lqz 1/1 Running 0 5m

    If the STATUS for both pods is “Running,” they have started successfully. If the STATUS is different, use the kubectl describe command to get more information and troubleshoot potential issues.

    Step 7 – Accessing the Application

    Once the pods have started, you can access the application using the service endpoint. Use the kubectl get service command to retrieve the service endpoint:

    Copy Code 
    kubectl get service nodejs-mongo-web

    You should see output similar to the following:

    Copy Code 
    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    
nodejs-mongo-web ClusterIP 10.245.159.26 8080/TCP 5m

    The service endpoint is the CLUSTER-IP, followed by the PORT(S) number. You can access the application by sending an HTTP request to the service endpoint.

    Open a web browser or use curl to access the application:

    Copy Code 
    curl http://:

    Replace “ and “ with the corresponding values for your service endpoint. When you open the application in the browser, you should see the home page of the application displaying a list of shark information.

    Conclusion

    In this tutorial, you learned how to translate Docker Compose service definitions into Kubernetes objects using KOMPOSE. You cloned and packaged a Node.js application code, translated Docker Compose service definitions into Kubernetes objects, created Kubernetes secrets, customized Kubernetes objects, and deployed the Kubernetes objects in your cluster. Finally, you accessed the application to verify it started successfully.

    Create a Free Account

    Register now and get access to our Cloud Services.

    Try now

    Posts you might be interested in:

    No results found.