Setting up local development environments can be tiresome. Using infrastructures such as Docker and Kubernetes gives a developer an upper hand to quickly set up and deploy applications. This guide teaches you how to leverage Docker and Kubernetes to deploy Docker Containers to the Kubernetes cluster.
Containers are lightweight operating systems that run as a form of virtualization. They let you package your applications and run them in isolated containerized environments. This gives you the power to quickly run powerful applications from different computing environments. Kubernetes pushes containers a step further by orchestrating them across a broad domain. Let’s dive in and create one the learn how to deploy the container to a Kubernetes Cluster using Docker.
How to Deploy Containers to Kubernetes Cluster using Docker
To get a container up and running on Kubernetes, we will create a basic Node.js application. Using this application, we will run it through Docker and finally land it on Kubernetes Cluster.
Note: Node.js app is a demonstrative example. If you have any applications ready and running, you can use them along with this guide.
Step One: Requirements
To get a Kubernetes Cluster up and running, we will use the following tools:
- Docker Engine: For creating, building, and deploying application images.
- A Docker Hub Account for deploying Docker images to the Docker Hub registry.
- Minikube: Minikube is Kubernetes tool. It allows you to run Kubernetes locally on your computer. It runs as a single-node Kubernetes cluster within your local computer, making it easy to develop the Kubernetes app.
- Kubectl: Kubectl is a Kubernetes command-line (CLI) tool. It allows you to run commands related to deploying, inspecting, and managing cluster resources against Kubernetes.
- Node.js runtime: For creating a Node.js app.
Ensure you have the above tools installed on your computer.
Step Two: Setting up Minikube and Kubectl
It is essential to ensure the above tools are installed tools and correctly configured on your computer before Deploying your container to the Kubernetes cluster using Docker.
You can check if Node.js is correctly installed using the following command:
To check if Docker is installed correctly, run the following:
docker version # client # version # server Docker Desktop
At this point start you installed Docker App:
Also, ensure it is up and running:
Once you have installed Minikube on your computer, run the following command to get it up, and running within your installed Docker Engine:
minikube start
It’s time to get Kubectl. To run Kubectl, we need to execute its installed binaries from PATH environment variables. First, navigate to the directory where Kubectl got installed. Then copy the bin directory path. Finally, add the path to your computer’s PATH environment variables.
If you have any problems adding the installed Kubectl PATH binaries, check this guide to help you add the Kubectl binaries correctly.
Once you have the PATH ready, run the following command to check if your set Kubectl is ready to execute Kubernetes commands:
kubectl cluster-info
Step Three: Setting up a Basic app
Kubernetes allows you to manage large applications. Likewise, Docker can deploy this application to a Kubernetes cluster seamlessly. For this guide, we will just create a simple Node.js app to demonstrate how you can get your application running on a Kubernetes cluster.
If you have an application reader, you can skip this step and use the application alongside this guide.
First, navigate to your project directory and initialize Node.js using the following command:
npm init-y
Just like any application, you go ahead and add dependencies/libraries to run your application. In this case, we create a minimal Node.js app. Therefore, we will use the Express library to create a simple Node.js server. Install Express as follows:
npm install express
Then create an index.js file and create the server as follows:
const express = require('express');
const app = express();
const port = 3000;
app.get('/', (req, res) => {
res.send('Hello Kubernetes!!!');
});
app.listen(port, () => {
console.log(`Server started on port ${port}`);
});
Then test the application by running the following:
node index.js
Finally, open http://localhost:3000 on the browser to test the application:
We will use this example. At the end of this tutorial, you should have the above example running on a Kubernetes cluster. Let’s dive in and start deploying the application.
Step Four: Writing Dockerfile
To get the application ready, we will first write a few commands that will instruct Docker to build an image for this specific application.
Note: Each application Dockerfile differs. Therefore, always ensure you have the right Dockerfile for running your application. In this example, we will write the Dockerfile as follows:
Inside the project directory, create a Dockerfile file and add the following Docker commands.
# pull the Node.js from the Docker registry FROM node:18-alpine3.15 # set default dir so that subsequent commands execute in /src/app dir WORKDIR /src/app # copy dependencies files COPY package.json ./ COPY package-lock.json . # will execute npm install in /src/app because of WORKDIR RUN npm install # copy application files (index.js) COPY ./ ./ # Port t expose the application on Docker EXPOSE 3000 # The command for running the application CMD ["node", "index.js"]
In case you have any files and folders that you don’t your Docker to build, create a .dockerignore file and add such items. In our case, we installed Node.js packages to create a directory node_modules. We don’t need to copy such items as:
- They are large.
- Executing
RUN npm installwill automatically create this folder. There is no need to copy it over to Docker.
Therefore, go ahead and add this directory to your dockerignore file.
node_modules
Step Five: Building the Docker Image
Once you have the Dockerfile ready, let’s dive in and run the application using Docker. Here we will:
- Build the application image
- Allows us to test if the application is correctly running on Docker.
- Build a global registry image for Docker Hub
Let’s now dive in and learn how to build the container image using the Dockerfile we have created.
First, let’s build the image and test it locally. Inside your Dockerfile root directory, run the following command:
docker build -t node-app.
Now run a container from this image and see that it works as expected:
docker run -it -p 3000:3000 node-app
If you open http://localhost:3000, you should be served the same application we run locally. However, this time the application will be loaded from a Docker container.
To deploy this application to Kubernetes, we first need to push the image to a Docker Hub registry. To do so, login to your Docker Hub account using a terminal by running:
docker login
Provide your correct Docker Hub username and password. If the credentials are correct, a Login Succeeded message will be logged on your terminal.
Proceed and build an image using your username as follows:
docker build -t <Enter your Docker Hub username>/node-app
Here, ensure you have the correct username added to the above command. This will form the image name of your application. For example:
docker build -t kimafro/node-app
Once the image is built successfully, go ahead and push it to your Docker Hub registry as follows:
docker push <Enter your Docker Hub username>/node-app
Replace your username as such:
docker push kimafro/node-app
Step Six: How to Deploy the Application to a Kubernetes Cluster
We have Docker ready. Let’s now get it up and running on the cluster. First, we need to create the deployment command for Kubernetes using a .yaml file. o ahead and create a k8s.yaml at the root of your project directory.
Create the deployment configuration for Kubernetes as follows:
apiVersion: apps/v1
kind: Deployment
metadata:
name: nodeapp-deployment
labels:
app: nodeapp
spec:
replicas: 1
selector:
matchLabels:
app: nodeapp
template:
metadata:
labels:
app: nodeapp
spec:
containers:
- name: nodeserver
image: kimafro/node-app
imagePullPolicy: Always
ports:
- containerPort: 3000
---
This will create the pods where the cluster will run. Then pull the image from the Docker registry and expose it on port 3000. Replace image: kimafro/node-app with the image name used alongside the Docker Hub username. I.e., <Enter your Docker Hub username>/node-app.
Inside the same file, create a service to expose the application as follows:
apiVersion: v1
kind: Service
metadata:
name: nodeapp-service
spec:
selector:
app: nodeapp
type: LoadBalancer
ports:
- protocol: TCP
port: 5000
targetPort: 3000
nodePort: 31110
This example will use a load balance. However, you can go ahead and choose a different approach to expose the application. Other options include NodePorts, LoadBalancers, Ingresses, and Cluster IP. Check this guide and learn more about them.
The application is ready. Let’s use Kubectl to deploy it. Go ahead and run the following command inside the application directory:
kubectl create -f k8s.yaml
This will create the application deployment and the service:
deployment.apps/nodeapp-deployment created service/nodeapp-service created
To check if the application cluster is running, use the following command:
kubectl get pods NAME READY STATUS RESTARTS AGE nodeapp-deployment-b8876f487-cgrv8 1/1 Running 0 8s
At this point, the application status should be Running. To test the deployed cluster service run:
minikube service nodeapp-service
Where nodeapp-service is the service name added in the k8s.yaml file.
Running the above command will loach the application as follows:
And there you have the application running the Kubernetes cluster. The application will be launched on your browser. However, you can go ahead and use the http://127.0.0.1:10920 and access the application. (Your URL might be different from this one. Copy the URL displayed in the above dashboard of your terminal)
If you are done using the cluster, you can delete it using:
kubectl delete -f k8s.yaml
Output:
deployment.apps "nodeapp-deployment" deleted service "nodeapp-service" deleted
Conclusion
Kubernetes is an open-source technology for automating the deployment, scaling, and management of container orchestration. Docker lets you run applications in containers, and Kubernetes helps you manage those containers. I hope you found this guide helpful and have successfully learned how to deploy containers to Kubernetes cluster using Docker.
