Menu
×
   ❮     
HTML CSS JAVASCRIPT SQL PYTHON JAVA PHP HOW TO W3.CSS C C++ C# BOOTSTRAP REACT MYSQL JQUERY EXCEL XML DJANGO NUMPY PANDAS NODEJS DSA TYPESCRIPT ANGULAR GIT POSTGRESQL MONGODB ASP AI R GO KOTLIN SASS VUE GEN AI SCIPY CYBERSECURITY DATA SCIENCE INTRO TO PROGRAMMING BASH RUST

Node.js Tutorial

Node HOME Node Intro Node Get Started Node JS Requirements Node.js vs Browser Node Cmd Line Node V8 Engine Node Architecture Node Event Loop

Asynchronous

Node Async Node Promises Node Async/Await Node Errors Handling

Module Basics

Node Modules Node ES Modules Node NPM Node package.json Node NPM Scripts Node Manage Dep Node Publish Packages

Core Modules

HTTP Module HTTPS Module File System (fs) Path Module OS Module URL Module Events Module Stream Module Buffer Module Crypto Module Timers Module DNS Module Assert Module Util Module Readline Module

JS & TS Features

Node ES6+ Node Process Node TypeScript Node Adv. TypeScript Node Lint & Formatting

Building Applications

Node Frameworks Express.js Middleware Concept REST API Design API Authentication Node.js with Frontend

Database Integration

MySQL Get Started MySQL Create Database MySQL Create Table MySQL Insert Into MySQL Select From MySQL Where MySQL Order By MySQL Delete MySQL Drop Table MySQL Update MySQL Limit MySQL Join
MongoDB Get Started MongoDB Create DB MongoDB Collection MongoDB Insert MongoDB Find MongoDB Query MongoDB Sort MongoDB Delete MongoDB Drop Collection MongoDB Update MongoDB Limit MongoDB Join

Advanced Communication

GraphQL Socket.IO WebSockets

Testing & Debugging

Node Adv. Debugging Node Testing Apps Node Test Frameworks Node Test Runner

Node.js Deployment

Node Env Variables Node Dev vs Prod Node CI/CD Node Security Node Deployment

Perfomance & Scaling

Node Logging Node Monitoring Node Performance Child Process Module Cluster Module Worker Threads

Node.js Advanced

Microservices Node WebAssembly HTTP2 Module Perf_hooks Module VM Module TLS/SSL Module Net Module Zlib Module Real-World Examples

Hardware & IoT

RasPi Get Started RasPi GPIO Introduction RasPi Blinking LED RasPi LED & Pushbutton RasPi Flowing LEDs RasPi WebSocket RasPi RGB LED WebSocket RasPi Components

Node.js Reference

Built-in Modules EventEmitter (events) Worker (cluster) Cipher (crypto) Decipher (crypto) DiffieHellman (crypto) ECDH (crypto) Hash (crypto) Hmac (crypto) Sign (crypto) Verify (crypto) Socket (dgram, net, tls) ReadStream (fs, stream) WriteStream (fs, stream) Server (http, https, net, tls) Agent (http, https) Request (http) Response (http) Message (http) Interface (readline)

Resources & Tools

Node.js Compiler Node.js Server Node.js Quiz Node.js Exercises Node.js Syllabus Node.js Study Plan Node.js Certificate

Node.js Deployment

This guide covers different approaches for deploying Node.js applications to various environments, from traditional servers to modern cloud platforms.


Preparing Your Application for Deployment

Before deploying your Node.js application, ensure it's properly prepared:

1. Environment Configuration

Use environment variables to configure your application differently based on the environment:

// config.js
const config = {
  development: {
    port: 8080,
    database: 'mongodb://localhost:27017/myapp_dev',
    logLevel: 'debug'
  },
  test: {
    port: 3001,
    database: 'mongodb://localhost:27017/myapp_test',
    logLevel: 'info'
  },
  production: {
    port: process.env.PORT || 8080,
    database: process.env.DATABASE_URL,
    logLevel: 'error'
  }
};

// Export the configuration for the current environment
const env = process.env.NODE_ENV || 'development';
module.exports = config[env];

2. Build Process

If your application uses TypeScript, Babel, Webpack, or other build tools, set up proper build scripts in package.json:

// package.json
{
  "scripts": {
    "build": "tsc",
    "start": "node dist/server.js",
    "dev": "nodemon src/server.ts"
  }
}

3. Health Checks

Implement a health check endpoint to verify your application is running correctly:

const express = require('express');
const app = express();

// Health check endpoint
app.get('/health', (req, res) => {
  // Check critical dependencies like database connections
  const isDbConnected = checkDatabaseConnection();
     if (isDbConnected) {
    res.status(200).json({ status: 'healthy' });
  } else {
    res.status(500).json({ status: 'unhealthy', error: 'Database connection failed' });
  }
});

function checkDatabaseConnection() {
  // Implement your database connection check
  return true; // Example response
}

4. Security Measures

  • Remove sensitive information from your codebase
  • Use environment variables for secrets
  • Implement proper security headers using packages like helmet
  • Set up rate limiting for your APIs
const express = require('express');
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

const app = express();

// Set security headers
app.use(helmet());

// Rate limiting
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100 // limit each IP to 100 requests per windowMs
});

// Apply rate limiting to API routes
app.use('/api/', apiLimiter);

Traditional Deployment

Running with Process Managers

In a traditional server environment, use a process manager to keep your Node.js application running:

PM2

# Install PM2 globally
npm install -g pm2

# Start your application
pm2 start app.js --name "my-app"

# Configure auto-restart on server reboot
pm2 startup
pm2 save

# View logs
pm2 logs

# Monitor your application
pm2 monit

PM2 Configuration File (ecosystem.config.js)

module.exports = {
  apps: [{
    name: "my-app",
    script: "./dist/server.js",
    instances: "max",
    exec_mode: "cluster",
    env: {
      NODE_ENV: "development",
    },
    env_production: {
      NODE_ENV: "production",
      PORT: 8080
    }
  }]
}

Forever

# Install Forever globally
npm install -g forever

# Start your application
forever start app.js

# List running processes
forever list

# Stop application
forever stop app.js

Using Reverse Proxy

It's recommended to run Node.js behind a reverse proxy like Nginx:

Nginx Configuration

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://localhost:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Cloud Platform Deployment

Heroku

Heroku is a platform as a service (PaaS) that simplifies Node.js deployment:

# Login to Heroku
heroku login

# Create a new Heroku app
heroku create my-node-app

# Deploy your code
git push heroku main

# Ensure at least one instance is running
heroku ps:scale web=1

# View logs
heroku logs --tail

Heroku requires a Procfile to specify how to start your application:

web: node dist/server.js

AWS Elastic Beanstalk

AWS Elastic Beanstalk is a service for deploying and scaling web applications:

# Install EB CLI
pip install awsebcli

# Initialize EB project
eb init

# Create environment and deploy
eb create my-node-env

# Deploy updates
eb deploy

Digital Ocean App Platform

Digital Ocean's App Platform offers a simple way to deploy Node.js applications:

  1. Connect your GitHub or GitLab repository
  2. Select the branch to deploy
  3. Configure build and run commands
  4. Select your environment variables
  5. Deploy the application

Note: Most cloud platforms can detect Node.js applications automatically and set reasonable defaults for building and running your app.


Container Deployment

Docker

Containerizing your Node.js application provides consistency across environments:

Dockerfile

FROM node:18-alpine

WORKDIR /app

COPY package*.json ./

RUN npm ci --only=production

COPY . .

EXPOSE 8080

CMD ["node", "server.js"]

Building and Running the Docker Container

# Build the Docker image
docker build -t my-node-app .

# Run the container
docker run -p 8080:8080 -d my-node-app

Docker Compose

For applications with multiple services (e.g., Node.js, MongoDB, Redis):

docker-compose.yml

version: '3'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - mongo
    environment:
      - NODE_ENV=production
      - MONGO_URI=mongodb://mongo:27017/myapp
      
  mongo:
    image: mongo:4.4
    volumes:
      - mongo-data:/data/db
    ports:
      - "27017:27017"
      
volumes:
  mongo-data:

Running with Docker Compose

# Start all services
docker-compose up -d

# View logs
docker-compose logs -f app

Kubernetes

For more complex deployments and scaling, Kubernetes provides container orchestration:

Basic Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: node-app
  template:
    metadata:
      labels:
        app: node-app
    spec:
      containers:
      - name: node-app
        image: my-node-app:latest
        ports:
        - containerPort: 8080
        env:
        - name: NODE_ENV
          value: production
        resources:
          limits:
            cpu: "0.5"
            memory: "512Mi"
          requests:
            cpu: "0.2"
            memory: "256Mi"
---
apiVersion: v1
kind: Service
metadata:
  name: node-app-service
spec:
  selector:
    app: node-app
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Serverless Deployment

AWS Lambda

For event-driven applications, serverless platforms like AWS Lambda can be cost-effective:

Lambda Handler

// lambda.js
const serverless = require('serverless-http');
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.json({ message: 'Hello from Lambda!' });
});

module.exports.handler = serverless(app);

Serverless Framework Configuration

service: my-express-app

provider:
  name: aws
  runtime: nodejs18.x
  stage: dev
  region: us-east-1
  
functions:
  app:
    handler: lambda.handler
    events:
      - http:
          path: /
          method: ANY
      - http:
          path: /{proxy+}
          method: ANY

Deploying with Serverless Framework

# Install Serverless Framework
npm install -g serverless

# Deploy
serverless deploy

Vercel

Vercel provides an easy way to deploy serverless Node.js applications:

vercel.json

{
  "version": 2,
  "builds": [
    {
      "src": "server.js",
      "use": "@vercel/node"
    }
  ],
  "routes": [
    {
      "src": "/(.*)",
      "dest": "server.js"
    }
  ]
}

Deploying to Vercel

# Install Vercel CLI
npm install -g vercel

# Deploy
vercel

Continuous Deployment

Automate your deployment process using continuous integration/continuous deployment (CI/CD) pipelines:

GitHub Actions Example

name: Deploy to Production

on:
  push:
    branches: [ main ]
    
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
          
      - name: Install dependencies
        run: npm ci
        
      - name: Run tests
        run: npm test
        
      - name: Build
        run: npm run build
        
      - name: Deploy to production
        run: |
          # Add your deployment commands here
          # Examples:
          # - ssh into your server and pull the latest changes
          # - deploy to a cloud platform with their CLI
          # - use a deployment service like Vercel, Netlify, etc.

For more details on setting up CI/CD pipelines, see our Node.js CI/CD tutorial.


Deployment Checklist

Before Deployment

  • Remove debugging code and console logs
  • Set appropriate environment variables
  • Run security checks for vulnerabilities (npm audit)
  • Run all tests
  • Optimize bundle size
  • Check for proper error handling

During Deployment

  • Use zero-downtime deployment techniques
  • Verify health checks and monitoring
  • Test the deployed application

After Deployment

  • Monitor application logs
  • Track performance and errors
  • Setup alerts for critical issues
  • Document the deployment process for the team

Performance Optimization for Production

Optimizing your Node.js application for production can significantly improve its performance and reliability. Here are key optimization techniques:

1. Code-Level Optimizations

  • Use the latest LTS version of Node.js for performance improvements
  • Optimize hot code paths and avoid blocking the event loop
  • Use streams for large data processing
  • Implement caching strategies

2. Memory Management

  • Monitor memory usage with process.memoryUsage()
  • Use --max-old-space-size to increase memory limit
  • Fix memory leaks with heap snapshots
  • Use object pooling for frequently created objects

Example: Enabling Cluster Mode

Utilize all CPU cores with Node.js cluster module:

// cluster.js
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;
const app = require('./app');

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork(); // Replace the dead worker
  });
} else {
  // Workers can share any TCP connection
  const PORT = process.env.PORT || 3000;
  app.listen(PORT, () => {
    console.log(`Worker ${process.pid} started on port ${PORT}`);
  });
}

Performance Monitoring

Implement monitoring to identify performance bottlenecks:

# Install monitoring tools
npm install --save express-status-monitor prom-client

# Enable Prometheus metrics endpoint
const express = require('express');
const promBundle = require('express-prom-bundle');
const metricsMiddleware = promBundle({ includeMethod: true });

const app = express();
app.use(metricsMiddleware);

// Your routes here
app.get('/', (req, res) => {
  res.send('Hello, monitored world!');
});

// Metrics endpoint
app.get('/metrics', (req, res) => {
  res.set('Content-Type', register.contentType);
  register.metrics().then(data => res.send(data));
});

Tip: Use tools like PM2's built-in monitoring, New Relic, or Datadog for comprehensive production monitoring and alerting.

Load Testing

Regularly test your application under load to identify bottlenecks:

# Install load testing tool
npm install -g loadtest

# Run a simple load test
loadtest -n 1000 -c 100 http://your-app.com/api/endpoint

# Example output will show requests per second,
# mean latency, and error rates

Summary

  • Prepare your application properly with environment configuration, build processes, health checks, and security measures
  • Choose the deployment approach that best suits your application needs
  • Consider traditional server deployment with process managers for maximum control
  • Use cloud platforms for simplified management and scaling
  • Containerize your application for consistency across environments
  • Consider serverless deployment for event-driven applications
  • Automate your deployment process with CI/CD pipelines



×

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail:
sales@w3schools.com

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail:
help@w3schools.com

W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

Copyright 1999-2025 by Refsnes Data. All Rights Reserved. W3Schools is Powered by W3.CSS.