Close Menu
    Blog

    How To Install Node.js on Ubuntu: A Complete Guide

    adminBy Updated:No Comments12 Mins Read
    Install Node.js on Ubuntu

    How To Install Node.js on Ubuntu: A Complete Guide

    Node.JS is a sharp, light and scalable JavaScript Runtime produced on the V8 engine for Chrome. This allows developers to create effective and high-performance applications on the servers side using JavaScript. If you develop backnd logic for API, real-time webapper or even web platforms, Node.JS is a solution. In this wide guide we will run you in many ways to install node.JS on Ubuntu, as well as how to manage versions, manage test installations and handle general problems.

    This guide is sewn for both beginners and advanced users, and we cover in detail how to install using Node.J:

    Ubuntu standard depot

    Nodesource ppa

    NVM (Node Edition Manager)

    Snap package

    Each method has its advantages based on development needs, safety expectations and control over the version.

     

    Why Choose Ubuntu for Node.js Development?

    Ubuntu, being one of the most popular Linux distributions, is widely used for development and deployment. It offers:

    • Stable and secure LTS (Long Term Support) releases

    • Vast community support

    • Compatibility with most open-source tools and runtimes

    • Easy integration with Node.js and npm packages

    Whether you’re using Ubuntu on a server (e.g., Ubuntu 22.04 LTS) or on your local machine, the steps provided here apply seamlessly.

    Method 1: Install Node.js from Ubuntu Default Repository

    The easiest way to install Node.js is by using Ubuntu’s built-in APT package manager. However, this method might not give you the latest version of Node.js.

    Step-by-step Instructions

    1. Update your package index:

    bash
    sudo apt update

    1. Install Node.js and npm (Node Package Manager):

    bash
    sudo apt install nodejs npm -y

    1. Verify Installation:

    Check installed versions:

    bash
    node -v
    npm -v

    This method is simple but often installs an outdated version, which may not support some of the latest JavaScript features or packages. For newer versions, continue to the next method.

    Method 2: Install Node.js via NodeSource PPA (Recommended)

    If you need the latest stable version or even a specific version of Node.js, installing from NodeSource’s Personal Package Archive (PPA) is highly recommended.

    Step-by-step Instructions

    1. Update system and install curl:

    bash
    sudo apt update && sudo apt install curl -y

    1. Download and add the NodeSource PPA (replace ‘setup_18.x’ with your preferred version):

    bash
    curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -

    1. Install Node.js:

    bash
    sudo apt install -y nodejs

    1. Verify the installation:

    bash
    node -v
    npm -v

    This method ensures you have the latest production-ready version and works well for both development and deployment environments.

    Method 3: Install Node.js Using NVM (Node Version Manager)

    NVM (Node Version Manager) is the best way to manage multiple Node.js versions on the same system. It’s ideal for developers working on multiple projects requiring different versions of Node.js.

    Advantages of Using NVM

    • Install multiple Node.js versions side by side

    • Easily switch between versions

    • No need for sudo

    • Cleaner environment management

    Step-by-step Instructions

    1. Download and install NVM:

    bash
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

    1. Activate NVM (for current session):

    bash
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

    To make NVM available in all terminal sessions, you can add the above block to your .bashrc or .zshrc file.

    1. Install latest Node.js version:

    bash
    nvm install node

    1. Install a specific version (optional):

    bash
    nvm install 16

    1. Switch between versions:

    bash
    nvm use 16

    1. Set default version:

    bash
    nvm alias default 16

    1. Check installed version:

    bash
    node -v
    npm -v

    This method is highly flexible and preferred in local development environments.

    Method 4: Install Node.js Using Snap Package

    If you prefer using Snap, the universal Linux package system, Node.js is also available as a snap package.

    Step-by-step Instructions

    1. Ensure Snap is installed:

    bash
    sudo apt install snapd

    1. Install Node.js Snap:

    bash
    sudo snap install node --classic

    1. Verify installation:

    bash
    node -v
    npm -v

    While convenient, the Snap version of Node.js is self-contained, which may not integrate well with system paths or custom configurations.

    How To Uninstall Node.js from Ubuntu

    Depending on how you installed Node.js, use the corresponding uninstall method.

    Uninstall APT version:

    bash
    sudo apt remove nodejs npm

    Uninstall NodeSource version:

    bash
    sudo apt purge nodejs

    Uninstall Snap version:

    bash
    sudo snap remove node

    Uninstall NVM version:

    bash
    nvm uninstall 16

    Or uninstall all versions manually from the ~/.nvm directory.

     

    Install npm Packages Globally Without sudo (NVM Users)

    When using NVM, avoid using sudo to install global packages. Instead, configure npm to use a directory in your home path:

    bash
    mkdir ~/.npm-global
    npm config set prefix '~/.npm-global'

    Add this to your shell config (.bashrc, .zshrc, etc.):

    bash
    export PATH="$HOME/.npm-global/bin:$PATH"

    Apply changes:

    bash
    source ~/.bashrc

    Now, you can safely install global packages:

    bash
    npm install -g typescript

    Best Practices After Installation

    ✅ Keep Node.js and npm updated

    If installed via NVM or NodeSource, you can easily upgrade to the latest version:

    bash
    nvm install node --reinstall-packages-from=node

    or

    bash
    sudo apt update && sudo apt upgrade nodejs

    ✅ Use npx for one-off commands

    npx comes bundled with npm and allows you to run packages without globally installing them:

    bash
    npx create-react-app myapp

    ✅ Avoid using root for development

    Always prefer user-level installs unless absolutely necessary, especially for global packages or scripts.

    Setting Up a Basic Node.js Server on Ubuntu

    After successfully installing Node.js, most developers move on to setting up a basic web server. Node.js makes this incredibly simple thanks to its built-in HTTP module. This section will guide you through creating a simple, functional Node.js server on your Ubuntu system.

    Step-by-Step: Creating a Simple Node.js Server

    1. Create a new project folder:

    bash
    mkdir my-node-server
    cd my-node-server

    1. Initialize the project:

    bash
    npm init -y

    This creates a package.json file with default values.

    1. Create a server file:

    bash
    nano server.js

    1. Add the following code:

    javascript

    const http = require('http');

    const hostname = ‘127.0.0.1’;
    const port = 3000;

    const server = http.createServer((req, res) => {
    res.statusCode = 200;
    res.setHeader(‘Content-Type’, ‘text/plain’);
    res.end(‘Hello, World!\n’);
    });

    server.listen(port, hostname, () => {
    console.log(`Server running at http://${hostname}:${port}/`);
    });

    1. Run the server:

    bash
    node server.js

    1. Test it in a browser or curl:

    Open your browser and navigate to http://localhost:3000 or use:

    bash
    curl http://localhost:3000

    You should see:
    Hello, World!

    Setting Up Node.js with Express Framework

    While the built-in HTTP module is great for learning, most real-world applications use Express.js, a minimalist and powerful framework for building APIs and web applications.

    Install Express:

    bash
    npm install express

    Create app.js:

    bash
    nano app.js

    Add the following code:

    javascript
    const express = require('express');
    const app = express();
    const port = 3000;

    app.get(‘/’, (req, res) => {
    res.send(‘Welcome to your Express server!’);
    });

    app.listen(port, () => {
    console.log(`Server is running at http://localhost:${port}`);
    });

    Run your Express app:

    bash
    node app.js

    You now have a basic Express server running on Ubuntu.

    Running Node.js Server in Background with PM2

    For production environments, you’ll want your Node.js server to run in the background, restart automatically if it crashes, and launch on system boot. That’s where PM2, a Node process manager, becomes useful.

    Install PM2 Globally:

    bash
    npm install -g pm2

    Start your app with PM2:

    bash
    pm2 start app.js

    Save process list and configure startup script:

    bash
    pm2 save
    pm2 startup

    This will generate a startup script you need to run (usually shown in the terminal). Once done, your app will restart automatically after a reboot.

    Firewall Configuration for Node.js on Ubuntu Server

    If you’re using a cloud VPS or server, make sure that the firewall allows incoming traffic on the port you’re using (e.g., 3000 or 80).

    Open a port using UFW (Uncomplicated Firewall):

    bash
    sudo ufw allow 3000
    sudo ufw reload

    To check UFW status:

    bash
    sudo ufw status

    This ensures your app is accessible from external devices.

    Setting Up Node.js with a Reverse Proxy Using Nginx

    For production-grade deployments, it’s best practice to run your Node.js server behind a reverse proxy like Nginx. This offers:

    • SSL termination

    • Load balancing

    • Enhanced security

    • Better performance

    Install Nginx:

    bash
    sudo apt install nginx

    Configure Nginx:

    Create a new configuration file:

    bash
    sudo nano /etc/nginx/sites-available/myapp

    Add the following:

    nginx
    server {
    listen 80;

    server_name your_domain.com;

    location / {
    proxy_pass http://localhost:3000;
    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;
    }
    }

    Enable the configuration:

    bash
    sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
    sudo nginx -t
    sudo systemctl restart nginx

    Now, your Node.js app is being served via Nginx on port 80.

    Final Recommendations for Ubuntu + Node.js Users

    ✅ Keep your system and packages up to date:

    bash
    sudo apt update && sudo apt upgrade
    bash
    npm update -g

    ✅ Use .env files for environment-specific variables

    Install dotenv:

    bash
    npm install dotenv

    Add at the top of your app.js:

    javascript
    require('dotenv').config();

    Then create a .env file:

    ini
    PORT=3000
    API_KEY=yourapikey

    This is essential for managing sensitive config data.

    ✅ Implement Logging and Monitoring

    Use libraries like:

    • Winston for logging

    • Morgan for HTTP request logging

    • New Relic or Datadog for monitoring in production

     

    Node.js Security Best Practices on Ubuntu

    Once your Node.js application is up and running on Ubuntu, securing your server and application is essential. Node.js applications are often exposed to the internet, making them vulnerable to common web attacks such as XSS, CSRF, and code injection. In this section, we outline key best practices for securing your Node.js environment on Ubuntu.

     

    1. Avoid Running as Root

    Never run your Node.js application as the root user. If a malicious actor exploits your application, they could gain full control over your system. Instead, create a new system user specifically for running your app:

    bash
    sudo adduser nodeuser
    sudo chown -R nodeuser:nodeuser /path/to/your/app

    Use this user to run your application or configure PM2 to do so.

    2. Use HTTPS with SSL/TLS

    If your app handles any sensitive data, such as login credentials or personal information, it must run over HTTPS.

    You can use Let’s Encrypt to generate a free SSL certificate:

    bash
    sudo apt install certbot python3-certbot-nginx
    sudo certbot --nginx -d yourdomain.com

    Certbot will automatically generate and renew your certificates.

    3. Sanitize and Validate All Inputs

    To prevent SQL injection, XSS, and NoSQL injection, always validate and sanitize inputs:

    • Use validator.js or Joi to validate user input.

    • Avoid using untrusted user input directly in queries or output.

    Install validator:

    bash
    npm install validator

    Example:

    javascript

    const validator = require('validator');

    if (!validator.isEmail(req.body.email)) {
    return res.status(400).send(‘Invalid email’);
    }

    4. Keep Dependencies Up-to-date

    Many vulnerabilities come from outdated npm packages. Use tools like:

    bash
    npm audit
    npm outdated

    To fix known vulnerabilities:

    bash
    npm audit fix

    Or use:

    bash
    npm install [package]@latest

    For long-term projects, consider using npm-check-updates:

    bash
    npm install -g npm-check-updates
    ncu -u
    npm install

    5. Prevent Directory Traversal and Access to Sensitive Files

    Always serve static files from a dedicated public directory and not from the root of your project.

    Example using Express:

    javascript
    app.use(express.static('public'));

    Ensure .env, config files, and other sensitive files are never exposed to users.

    6. Use Helmet Middleware

    helmet helps secure your app by setting various HTTP headers:

    bash
    npm install helmet

    Then in your app:

    javascript
    const helmet = require('helmet');
    app.use(helmet());

    This middleware protects against:

    • Cross-site scripting

    • Clickjacking

    • MIME-type sniffing

    • Other common vulnerabilities

     

    Performance Optimization Tips for Node.js on Ubuntu

    Ensuring optimal performance is crucial when deploying applications in production. Node.js is already non-blocking and efficient, but with a few tweaks, you can push its performance further.

    1. Use Clustering for Multi-Core Systems

    By default, Node.js runs in a single-threaded process. You can use the built-in cluster module to fork processes on multi-core systems:

    javascript
    const cluster = require('cluster');
    const http = require('http');
    const numCPUs = require('os').cpus().length;

    if (cluster.isMaster) {
    for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
    }
    } else {
    http.createServer((req, res) => {
    res.writeHead(200);
    res.end(‘Handled by worker\n’);
    }).listen(8000);
    }

    This allows your application to handle more simultaneous users.

    2. Use Gzip Compression

    Compress responses to reduce bandwidth usage and improve load times:

    bash
    npm install compression

    Then:

    javascript
    const compression = require('compression');
    app.use(compression());

    3. Enable Caching

    Use tools like Redis or in-memory caching for frequently accessed data. For static files, configure Nginx to cache them for faster delivery.

    4. Monitor Memory and CPU Usage

    Use PM2’s built-in monitoring tools:

    bash
    pm2 monit

    Or integrate tools like:

    • New Relic

    • Datadog

    • AppDynamics

    To visualize performance and detect memory leaks, event loop delays, and CPU spikes.

    5. Minimize Dependency Overhead

    Audit your package.json for unused or heavy packages. Uninstall any unnecessary dependencies and use lightweight alternatives wherever possible.

    Deploying a Full-Stack Node.js Application on Ubuntu

    After completing the setup of Node.js, you may want to deploy a full-stack application that includes:

    • Node.js (backend)

    • React/Vue/Angular (frontend)

    • MongoDB/PostgreSQL (database)

    To do this efficiently:

    1. Backend: Host Node.js with PM2 and Nginx.

    2. Frontend: Build frontend with npm run build, then serve the static files from Nginx.

    3. Database: Install and secure MongoDB or PostgreSQL with restricted access and user roles.

    4. Environment Variables: Store sensitive configs in .env and load via dotenv.

     

    Conclusion

    Installing Node.JS on Ubuntu can be done in many effective ways, whether using APT depot, noderce, snap or very flexible NVM method. When established, it is necessary to establish your development environment correctly, adapt to performance and secure your app for long -term success.

    Ubuntus strong ecosystem makes it ideal for running Node.JS applications in both growth and production settings. By following this guide step by step, you can ensure a stable, safe and high performance environment for your Node.JS apps.

    Read More: Termux: Why Does Pandas Install Hang?

    Share.

    Related Posts

    Leave A Reply