When you node. If JS makes applications, it is easy to run locally. Type you npm startAnd it works.
But when you need to run it on the cloud, things get complicated. You need to think about servers, environment, dependence and deployment pipelines. This place comes with containerization.
Containers make your request portable and predicted. You can run the same code with the same setup anywhere from your laptop to the cloud.
In this guide, we will go through how we will contain a simple node JS API and deploy it in the cloud. Finally, you will know how to set a dock for your app, push it into the registry, and your request on the cloud.
The table of content
Provisions
Before we have your node. Dink the JS application in containing and deploying, make sure that the following setup is on your system. These basic things will help you follow you without being mistaken.
Node. JS and NPM
You should be node.js (V18 or more) and NPM is installed on your local machine. This ensures that you can run it locally before you contain a container.
To check your version, run:
node -v
npm -v
Doer is installed and running
Doctor The basic tool that we will use to contain the app. Install a Dokar desktop or Doker engine in terms of your system. Once installed, confirm that it is running by typing and working:
docker --version
Dokar Hub Account (or any container registry)
You will need a Dokar Hub account to push your container image to the cloud. This allows your deployment platform to photograph and run. You can make one in free Hossor Dokar.com.
Once you have these conditions, you have your first containerized node. The JS app will be ready to create and deploy it in the cloud.
What is the containerization?
Containing is a way to package an application that needs to be run as well. These include codes, libraries, system tools, and settings. The package is called container image.
When you drive this picture, you get a container that treats any system exactly the same as the Doker.
Without containers, deployment can be dirty. Your app may work on your machine but fails to produce as the libraries or versions are similar.
Containers lock it in the environment and solve it. Think of them about lightweight virtual machines that require your app.
A node. To compile JS app
Let’s start with the construction of a simple node Dot JS API. We will keep it minimal so that we can focus on containerization and deployment measures.
Create a new folder and add a file that says server.js:
const express = require('express');
const app = express();
const PORT = process.env.PORT || 3000;
app.get('/', (req, res) => {
res.json({ message: 'Hello from Container!' });
});
app.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});
Next, make a package.json File with the following content:
{
"name": "container-node-app",
"version": "1.0.0",
"main": "server.js",
"scripts": {
"start": "node server.js"
},
"dependencies": {
"express": "^5.1.0"
}
}
Drive npm install Express to install dependence. Now you have a simple node. JS is API that operates locally. You can test it npm start And open In your browser
Write post postponement
Living this app in a container l, we need to write Dockerfile. This file describes how to create a container image. Create a new file that says Dockerfile And add it:
FROM node:24
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 3000
CMD ("npm", "start")
Let’s break it. We are the official node. JS 24 start with image. We set up a working directory inside the container. We copy the package files and install dependence.
Then we copy the rest of the code. We expose Port 3000 to accept the app traffic. Finally, we run away npm start As a default command
Constructing and examining container
Now when we have DockerfileWe can prepare the image. Run the following command:
docker build -t container-node-app .
This creates a syllable container-node-app. To test it locally, run:
docker run -p 3000:3000 container-node-app
Open In your browser, and you should see the JSON message {"message":"Hello from Container!"}. At this point, we know that our app works in a container.
Preparation of deployment
You need to pushing your image into the container registry. The registry is a place where the container images are stored and shared. Your cloud provider can draw from photos Doker Hub Or other registry.
Tag your photo on the way to the registry. For the Dokar Hub, it seems:
docker tag container-node-app your-dockerhub-username/container-node-app:latest
Then log in and press it:
docker login
docker push your-dockerhub-username/container-node-app:latest
Your photo is now available in the Cloud Registry and ready for deployment.
This is mine:
Deployed in the cloud
In this tutorial, I will use Seola because it offers a free level, so there is no cost to deploy this container in the cloud. You may like other providers AWS Or HerocoBut just note that you will cost to make resources.
Civic Service providers as a modern, use -based platform. It offers your plans hosting application hosting, database, object storage, and static site.
Once you set up your account, you can create a new application and tell him which container image is to use. Seola will draw the picture from the registry, make a container, and handle networking, scaling, and updates for you.
To start, Log In the dashboard, select to create a new application. Give this name like this node-api. Provide the way for your image registry.
Choose a location and use the “hobby” plan. Seola comes with $ 50 free credit, so you will not be paid to deploy this photo.
Click “Create and Deploy”. Seola will handle the rest. You can create and deploy the application.
Once deployed. After completion, click “View the app” to get your app directly to the URL. You can see the API answer.
Scaling your app
One of the major benefits of Seola is easy scaling. If you start getting more traffic, you can increase the number of containers running your app with just a few clicks. Seola will load the balance between them. This means that your app can handle more requests without time.
Scaling with containers is effective because every container runs the same code. Additional servers do not need to be manually configured. Seola takes care of the orplanting, so your focus is on writing code rather than infrastructure management.
Updating your app
When you your node. When changes to the JS app, the update is straightforward. You rebuild the Dokar image, push it into the registry, and re -deploy Seola.
Since the containers are incomplete, every new construction creates a fresh environment. This ensures that your updates are clean, permanent and old -fashioned free.
For example, if you change the message server.js And want to deploy it, you’ll run away:
docker build -t your-dockerhub-username/container-node-app:latest .
docker push your-dockerhub-username/container-node-app:latest
Then stimulate a radiper in the Seola dashboard. Within a few minutes, your users will see the latest response.
The benefits of song containers
Container Bring many benefits when deploying node.com JS applications. They make your app portable because the container code and its dependence keeps both, ensuring that it runs everywhere.
They improve consistency, as each construction creates an isolated environment without files or matching versions. Skilling is easier because you can rotate more containers as traffic as traffic is increased, and everyone behaves equally. The latest information is also clear, as you are fresh from the latest code in place of old containers.
This is the developers, it means to fix the problems of the less surprise and the less time environment. Containers provide a reliable foundation, so you can focus on construction features rather than solving problems.
Conclusion
Containing is one of the most important changes in modern software development. Your node. By learning how to put the JS app in the Doker Container, you unlock the ability to run it anywhere.
In this guide, we made a small node JS API, developed a dock file, tested the container locally, pushed it into the registry, and posted it into the cloud. The steps you take here also apply to very large and more complex applications. Once you get the basics, you can scale your workflow in production level projects.
Hope you enjoy this article. Connect to me LinkedIn on them Or Visit my website.