reecoverasble.github.io

2024-05-09T21:45:11+08:00

Steps to deploy a Node.js app to DigitalOcean using PM2, NGINX as a reverse proxy and an SSL from LetsEncrypt

If you use the referal link below, you get $10 free (1 or 2 months) https://m.do.co/c/5424d440c63a

2. Create a droplet and log in via ssh

I will be using the root user, but would suggest creating a new user

3. Install Node/NPM

curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -

sudo apt install nodejs

node --version

4. Clone your project from Github

There are a few ways to get your files on to the server, I would suggest using Git

git clone yourproject.git

5. Install dependencies and test app

cd yourproject
npm install
npm start (or whatever your start command)
# stop app
ctrl+C

6. Setup PM2 process manager to keep your app running

sudo npm i pm2 -g
pm2 start app (or whatever your file name)

# Other pm2 commands
pm2 show app
pm2 status
pm2 restart app
pm2 stop app
pm2 logs (Show log stream)
pm2 flush (Clear logs)

# To make sure app starts when reboot
pm2 startup ubuntu

You should now be able to access your app using your IP and port. Now we want to setup a firewall blocking that port and setup NGINX as a reverse proxy so we can access it directly using port 80 (http)

7. Setup ufw firewall

sudo ufw enable
sudo ufw status
sudo ufw allow ssh (Port 22)
sudo ufw allow http (Port 80)
sudo ufw allow https (Port 443)

8. Install NGINX and configure

sudo apt install nginx

sudo nano /etc/nginx/sites-available/default

Add the following to the location part of the server block

    server_name yourdomain.com www.yourdomain.com;

    location / {
        proxy_pass http://localhost:5000; #whatever port your app runs on
        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;
    }

# Check NGINX config
sudo nginx -t

# Restart NGINX
sudo service nginx restart

You should now be able to visit your IP with no port (port 80) and see your app. Now let’s add a domain

9. Add domain in Digital Ocean

In Digital Ocean, go to networking and add a domain

Add an A record for @ and for www to your droplet

Register and/or setup domain from registrar

I prefer Namecheap for domains. Please use this affiliate link if you are going to use them https://namecheap.pxf.io/c/1299552/386170/5618

Choose “Custom nameservers” and add these 3

ns1.digitalocean.com
ns2.digitalocean.com
ns3.digitalocean.com

It may take a bit to propogate

Add SSL with LetsEncrypt ``` sudo add-apt-repository ppa:certbot/certbot sudo apt-get update sudo apt-get install python-certbot-nginx sudo certbot –nginx -d yourdomain.com -d www.yourdomain.com

Only valid for 90 days, test the renewal process with

certbot renew –dry-run ```

Now visit https://yourdomain.com and you should see your Node app

2024-05-09T21:45:11+08:00

Installing Node in 5 minutes: The Final Guide.

~~If you have a shitty internet, it may take a little longer.~~

First, access Node.js website and click the big green “Download” button.

Download finished? Now run the installation. While the installation goes by, grab yourself a coffee or drink some water, then get back at your chair. By now you should have Node.js and NPM (Node’s package manager) installed.

Now, lets install n to manage (and update) Node versions in seconds on your machine. How to install it? Simply run:

npm install -g n

(if you get errors, you probably need administration permissions, try using sudo or equivalent in your OS).

Easy, right? Now, to update your Node.js version, all you have to do is run n latest. And you will have the latest Node.js installed and ready to use in your machine.

To choose which Node.js version you want to use at a given time, run: n and choose between the installed versions.

So, lets recap:

You’ve installed Node.js via their website for the first time. Then you installed the n package, which lets you have multiple Node versions in the same machine, doing version updates with one line command.

Here is what you’ve just installed at the end of this tutorial:

Node.js: The V8 JavaScript Engine which will run your JavaScript code locally. Think of it as a JVM (Java).

NPM: Node (JavaScript) package manager. You can think of it as a Maven (Java), Composer (PHP) or Gems (Ruby), but for Node.js.

Updating Node to future versions: Simply run: n latest.

Switching between installed Node versions: Run: n, then select (with arrow keys) which version you want to use. You can check your current node version by running: node -v.

And thats it. Now you’ve got a minimal environment ready to kick some a*$!

How to Setup Windows as a Node.js Server Environment

2024-01-12T00:00:00+08:00

Install the following in this order:

cmder Console Emulator for Windows. Use the Download Full link.
- Download and unzip into C:\Users\your-username-here\cmder.
- Open the C:\Users\your-username-here\cmder directory right click on cmdre.exe click Pin to Taskbar.
nvm-windows Node Version Manager for Windows.
- Download nvm-setup.zip.
- Extract the nvm-setup.exe file somewhere and run it.
- TODO: The installer isn’t updating the PATH correctly so the node, npm and nvm commands may not work. Make sure to add the following to Window’s PATH:
  - Open the cmder console you installed above and run:
    setx path "%path%;C:\Users\your-username-here\AppData\Roaming\nvm;C:\Program Files\nodejs;"
- run:
```
  nvm install 8.9.4
  nvm use 8.9.4
  node -v
  # Should return 8.9.4
```

windows-build-tools

C++ Build Tools for Windows using npm

 > Note: This will take 10 - 30 minutes to complete.  * Right click on the `cmder` console icon you installed above and run it as an Administrator. Then run:    * `npm install --global --production windows-build-tools`

You should now have the commands, node, npm, nvm and git available from any command line or cmder console.

Setup a Node.js project with Typescript, ESLint, Prettier, Husky

2024-01-11T00:00:00+08:00

Starting a personal node project could be easy; starting a team node project could be challenging.

I am a developer currently working in SEEK Australia.

In my experience, common mistakes developer make when starting a projects are:

No Linting
Lack of compile-time type checking (not really mistake but less desirable in my preference)
Inconsistent code styling
Linter breaking the build

In this article, I am going to not only to share how to address these above problems, but also some of the best practices we implement in our team at SEEK.

The article assumes the reader knows the basics about nodes and typescripts

Typescript

We can start off by a simple node project consisting only the package.json file

yarn add typescript --dev

After adding the dev dependency, create a ts.config.json file under the root of the node project

{
  "compilerOptions":
    {
      "target": "es2018",
      "module": "commonjs",
      "outDir": "dist",
      "sourceMap": true,
    },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"],
}

The above are the minimal settings of typescript compiler tsc.

It tells the compiler to

use es2018 syntax when generating the distributable
use the commonjs module format.
generate *.js to /dist folder
generate source map
include all *.ts file inside /src folder
exclude all files inside /node_modules folder

Fancy configuration of ts.config.json is beyond the scope of this article

Adding the following line to package.json

{
  "scripts":{
    "build": "tsc"
  }
}

To build, run the following in shell

yarn build

ESLint

We have a handful choices of linting tools for node development, but the de-factor standard these days for typescript is ESLint. Partnering with prettier it really improves consistency and productivity of a development team.

Again we are starting off by adding the dev dependencies

yarn add eslint @typescript-eslint/eslint-plugin @typescript-eslint/parser --dev

ESLint does not support typescript out of the box. Fortunately we are able to add the typescript support by these two packages @typescript-eslint/eslint-plugin @typescript-eslint/parser thanks to the ESLint team’s modular design.

The next thing is to create a .eslintrc file. It does not have a file extension but the default is JSON format:

{
  "parser": "@typescript-eslint/parser",
  "extends": ["plugin:@typescript-eslint/recommended"],
  "parserOptions": { "ecmaVersion": 2018, "sourceType": "module" },
  "rules": {}
}

It tells the ESLint linter to:

use Typescript parser
use Recommended Typescript preset for linting
use ES2018 and module sourceType to match ts.config settings

Add the following lines in package.json:

{
  "scripts": {
    "lint": "eslint src/**/*.ts",
    "format": "eslint src/**/*.ts --fix"
  }
}

To lint, run the following in shell

yarn lint

To format the code to comply with linting rules, run the following in shell

yarn format

Prettier

Prettier drastically improves team consistency by automatically formatting the code. To enable prettier, we first install it by running:

yarn add prettier --dev

Configure prettier by adding a .prettierrc to the root of the project with the following content

{
    "semi": true,
    "trailingComma": "all",
    "singleQuote": true,
    "printWidth": 120,
    "tabWidth": 2
}

The setting let Prettier to

Ensure semi colon at the end of each statement
Ensure trailing comma at the end of each statement
Convert all double quotes to single quotes where applicable
Break into new lines for all lines greater than 120 characters wide
Ensure tab width is 2 characters

In Visual Studio Code, Ctrl (CMD) + P then select Format Code, or enable Format on Save in settings for best result.

Husky

No matter how careful I am, I always endup with situations where I changed and committed the code to Github without linting, and that can lead to failure CI builds.

A good pratcice is to lint before commit. Husky is a very popular plugin to achieve so.

Install Husky by

yarn add husky --save-dev

Husky does not have its own configuration files. Instead we will add its config into package.json:

{
  "husky": {
    "hooks": {
      "pre-commit": "yarn lint"
    }
  }
}

Next time you commit, husky would exit the git commit when the code does not pass linting.

The End

There are so many more things you could do to your project to ensure productivity, consistency and coding styles, but I think this is a good start. This article will be subject to improvements to the latest changes and practices.

If you find this article useful please let me know.

How to deploy a simple Node.js+MongoDB app

2024-01-10T00:00:00+08:00

Clone a Node.js application from GitHub

First, clone from the following URL to Ubuntu VM:

https://github.com/potikanond/docker-node-sample3.git

On Ubuntu VM run the following command:

` $ git clone https://github.com/potikanond/docker-node-sample3.git `

This will clone the application from GitHub to docker-node-sample3 directory.

Review the Node.js application

package.json:

{
  "name": "docker-node-mongo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "body-parser": "^1.18.3",
    "ejs": "^2.6.1",
    "express": "^4.16.3",
    "mongoose": "^5.2.7"
  }
}

Dependencies:

express : a Node.js framework for web application (and api) development.
ejs : Embedded JavaScript template is one of a Node.js template engines for generate HTML using JavaScript.
body-parser : a middleware for Node.js, used to parse incoming web request, help extracting passing parameters.
mongoose : a library for Node.js to work with MongoDB.

Start the Node.js application right way?

The answer is NOT at this step. This application stores and retrieves data on MongoDB, therefore, we need to configure MongoDB first.

But if you really want to start the Node.js application, we need to install Node.js on the Ubuntu VM. After that, go into the docker-node-sample3 directory and enter the following command:

` $ npm start `

If we do not have MongoDB then this would give us an ERROR:

$ npm start

> docker-node-mongo@1.0.0 start /Users/dpotikan/workspace/tutorial-docker/docker-node-sample3
> node index.js

Server running...
{ MongoNetworkError: failed to connect to server [mongo:27017] on first connect 
  [MongoNetworkError: getaddrinfo ENOTFOUND mongo mongo:27017] ... }

With Docker, we will NOT install Node.js on the docker host but we will create a Node.js container and run the application inside.

Create a docker image for the Node.js application

First, create a Dockerfile inside the docker-node-sample3 directory.

Dockerfile:

FROM node:10-alpine

WORKDIR /usr/src/app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

For more detail on dockerizing a Node.js web app, see the following link: https://nodejs.org/en/docs/guides/nodejs-docker-webapp/

Create `.dockerignore` file in the same directory as the `Dockerfile`

.dockerignore:

node_modules
npm-debug.log

This will prevent local_modules and debug logs from being copied onto your Docker image and overwriting modules installed within your image.

Building your Node.js docker image

Use the docker image build ... command to build and tag image.

$ docker image build -t cpe405/example33 .
Sending build context to Docker daemon  148.5kB
Step 1/7 : FROM node:10-alpine
 ---> 4e50ad7c0e0b
Step 2/7 : WORKDIR /usr/src/app
 ---> Running in 5103a44253d3
Removing intermediate container 5103a44253d3
 ---> 792d79e04737
Step 3/7 : COPY package*.json ./
 ---> b2e4d3253e7f
Step 4/7 : RUN npm install
 ---> Running in 5c75c3eb9927
npm WARN docker-node-mongo@1.0.0 No description
npm WARN docker-node-mongo@1.0.0 No repository field.

added 80 packages from 62 contributors and audited 181 packages in 6.483s
found 0 vulnerabilities

Removing intermediate container 5c75c3eb9927
 ---> 0bd134e0855a
Step 5/7 : COPY . .
 ---> da43997f294f
Step 6/7 : EXPOSE 3000
 ---> Running in 7467dab066a3
Removing intermediate container 7467dab066a3
 ---> 23348db6b2bc
Step 7/7 : CMD [ "npm", "start" ]
 ---> Running in 15a2309daf6f
Removing intermediate container 15a2309daf6f
 ---> 5e97c2c283d5
Successfully built 5e97c2c283d5
Successfully tagged cpe405/example33:latest

If we would create and start a container from this image without MongoDB, there would be ERROR as shown before.

$ docker container run -p 8080:3000 cpe405/example33

> docker-node-mongo@1.0.0 start /usr/src/app
> node index.js

Server running...
{ MongoNetworkError: failed to connect to server [mongo:27017] on first connect [MongoNetworkError: getaddrinfo ENOTFOUND mongo mongo:27017] ... }

Start the application properly

To start the application properly. First, start the MongoDB container:

` $ docker container run -d –name my_mongo -p 27017:27017 mongo:4.0.1-xenial `

We will use the mongo container’s name, my_mongo, for linking with the Node.js container. Next, start the Node.js container (in foreground) and link to the MongoDB container.

$ docker container run -p 8080:3000 --link my_mongo:mongo cpe405/example33

> docker-node-mongo@1.0.0 start /usr/src/app
> node index.js

Server running...
MongoDB Connected

The --link my_mongo:mongo option tells docker to map the MongoDB container’s name, my_mongo, as the name mongo for the Node.js container. If we take a look in the index.js file, we will see that mongoose use the name mongo to refer to MongoDB container.

index.js:

...
mongoose
  .connect(
    'mongodb://mongo:27017/docker-node-mongo',
    { useNewUrlParser: true }
  )
  .then(() => console.log('MongoDB Connected'))
  .catch(err => console.log(err));
...

Now, we can access the Node.js app by http://localhost:8080

Summary

To deploy the Node.js app, we need to manually start a MongoDB container first then the Node.js app container. Next we will learn how to use docker-compose tool to deploy the app.

Portable Node.js and NPM on windows

2024-01-09T00:00:00+08:00

Get node binary (node.exe) from http://nodejs.org/download/
Create the folder where node will reside and move node.exe to it
Download the last zip version of npm from http://nodejs.org/dist/npm
Unpack the zip inside the node folder
Download the last tgz version of npm from http://nodejs.org/dist/npm
Open the tgz file and unpack only the file bin/npm (without extension) directly on the node folder.
Add the the node folder and the packages/bin folder to PATH
On a command prompt execute npm install -g npm to update npm to the latest version

Now you can use npm and node from windows cmd or from bash shell like Git Bash of msysgit.

Node + MongoDB Server Setup Ubuntu 22.04 LTS

2024-01-08T00:00:00+08:00

How to setup a Node.js + MongoDB environment with PM2 and Let’s Encrypt

ssh root@your_server_ip

Update the system before doing anything

sudo apt-get update
sudo apt-get upgrade

Create a non-root user and give it sudo permissions

* adduser braitsch
* usermod -aG sudo braitsch

Copy ssh key over to the non-root user home directory

rsync --archive --chown=braitsch:braitsch ~/.ssh /home/braitsch

ssh braitsch@your_server_ip

Install Node.js via nvm

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash
source ~/.bashrc

Check installation succeeded & install the latest lts version

nvm list-remote
nvm install --lts
node -v

Install MongoDB v6.0

curl -fsSL https://pgp.mongodb.com/server-6.0.asc | sudo gpg -o /usr/share/keyrings/mongodb-server-6.0.gpg --dearmor
echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-6.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-6.0.list
sudo apt-get update
sudo apt-get install -y mongodb-org

Start MongoDB as a service & confirm that it’s running

sudo systemctl start mongod
sudo systemctl status mongod
sudo systemctl enable mongod

Install & Configure NGINX

sudo apt update
sudo apt install nginx

Setup NGINX Server Block

sudo nano /etc/nginx/sites-available/my_domain

server {

	server_name my_domain.org www.my_domain.org;
	root /home/braitsch/site/server; # required to serve static images

	location / {
		proxy_pass http://localhost:8081; #nuxt app
		proxy_http_version 1.1;
		proxy_set_header Host $host;
	}

	location /api {
		proxy_pass http://localhost:8080; #express app
		proxy_http_version 1.1;
		proxy_set_header Host $host;
		client_body_buffer_size 1M; #required for image uploads
		client_max_body_size 100M; #required for image uploads
	}

	location /static {
		proxy_pass http://localhost:8080;
		try_files $uri $uri/ =404; # static asset directory
	}
}

Activate NGINX Server Block

sudo ln -s /etc/nginx/sites-available/my_domain /etc/nginx/sites-enabled/
sudo nano /etc/nginx/nginx.conf
http {
    server_names_hash_bucket_size 64; # <- uncomment this line
}
sudo nginx -t
sudo systemctl restart nginx

Enable & Setup firewall

sudo ufw enable
sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw status

Install & Setup Let’s Encrypt

sudo snap install core; sudo snap refresh core
sudo apt remove certbot
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot
sudo certbot --nginx -d my_domain.com -d www.my_domain.com

Confirm automatic SSL cert renewal

sudo systemctl status snap.certbot.renew.service
sudo certbot renew --dry-run

Update iptables to redirect 80/443 traffic to the ports our node app will be running on

sudo iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables -I INPUT -p tcp --dport 8080 -j ACCEPT
sudo iptables -A PREROUTING -t nat -i eth0 -p tcp --dport 443 -j REDIRECT --to-port 8443
sudo sh -c "iptables-save > /etc/iptables.rules"

Install PM2 globally to run & monitor our Node apps

npm install pm2@latest -g

Set the Server’s Timezone

sudo timedatectl set-timezone America/Los_Angeles

Install NodeJS 16.17

2024-01-05T00:00:00+08:00

sudo yum install -y gcc-c++ make curl
curl -sL https://rpm.nodesource.com/setup_16.x | sudo -E bash -

sudo yum list available nodejs
sudo yum install -y nodejs
node -v
npm -v

Node.js LTS

sudo yum install -y gcc-c++ make curl
curl -sL https://rpm.nodesource.com/setup_lts.x | bash -
# Remove old version
yum remove -y nodejs npm
# Clear cache
yum clean all
# Install new Node.js
yum install -y nodejs

Remove NodeJS

sudo yum remove -y nodejs
sudo rm -rf /var/cache/yum
sudo rm /etc/yum.repos.d/nodesource*
sudo yum clean all

Remove residual files

whereis node
sudo rm -rfv /usr/bin/node /usr/local/bin/node /usr/share/man/man1/node.1.gz
sudo rm -rfv /usr/bin/npm /usr/local/bin/npm /usr/share/man/man1/npm.1.gz
sudo rm -rfv /usr/local/bin/npx
sudo rm -rfv /usr/local/lib/node*
sudo rm -rfv /usr/local/include/node*
sudo rm -rfv /usr/lib/node_modules/

how to run apache and node.js together the right way

2024-01-03T00:00:00+08:00

Step 1

Get a VPS that offers 2 or more IP addresses.

Step 2

From the WHM cPanel, find the menu item Service Configuration, select Apache Configuration and then click on Reserved IPs Editor.

Step 3

Tick the IP address you DON’T WANT Apache to listen to, and write it down so you can use it in the next step. Click Save.

Step 4

Install Node.js, and create a server like this:

var http = require('http');

var server = http.createServer(function(req, res) {
  res.writeHead(200);
  res.end('Hello, world!');
});

server.listen(80, '111.111.111.111');

Replacing 111.111.111.111 with the IP address you previously reserved from the WHM cPanel.

Step 5

Stop wasting your time and never listen to those telling you to use mod_rewrite to proxy Node.js again.

How to deploy NodeJS App to EC2

2024-01-02T00:00:00+08:00

Instructions

Connect to ec2 via ssh
Install nvm: https://github.com/nvm-sh/nvm via curl e.g. curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
Source nvm: . ~/.nvm/nvm.sh
Install node: nvm install <your_version>
Install git: sudo yum install -y git
Git clone your project and cd in
Install yarn: npm i -g yarn
Install your node app
touch ~/.env and paste your env config there with the export prefix
Source .env in bash_profile to run everytime: vim ~/.bash_profile and then add source ~/.env to the bottom of the bashprofile. Source your bash_profile: source ~/.bash_profile to load the new changes.
Run the server by doing yarn dev. You should be running on port 3000 at this point
From the EC2, go to the related security group and open port 3000 to 0.0.0.0/0
Test the url by going to the EC2 instance and getting the public IPv4 address. Append :3000 to the end of the url. Ensure that the url is http not https
Install pm2: npm install -g pm2
Set up pm2 to start the server auto: pm2 start npm -- start; pm2 save; pm2 startup. Copy and paste the generated script into the console to save the startup script.
Also setup logging with timestamp by doing: pm2 restart 0 --log-date-format "DD-MM-YYYY HH:MM Z" and pm2 save. In future, to view logs in EC2, do pm2 logs npm.
In EC2 security group, add inbound rule for your node port
Add classic load balancer to route port 80/443 to your port with :80:3000 and :443->:3000
Create a new security group for this load balancer, exposing ports 80 and 443 only.
Create a new ACM certificate with the desired domain and validate via DNS. Open the accordion to find a button that automatically helps create a record in Route53 to validate it immediately.
For healthcheck, set protocol to http, port to 3000, and path to /
Once the load balancer is created, wait for instance status to be InService, then open the load balancer’s DNS name in the browser to test that it works.
In route 53, add A record (use the wizard) with alias to your load balancer.
Test the route, it should work.
To redirect http traffic to https, upgrade the classic load balancer to application load balancer via the migration tab.
In the new application load balancer, go to listeners and edit rules for port 80. In the rules page, click the edit pencil icon at the top and later at the bottom-left. Delete the existing ‘Then’ rule to add another action to “Redirect to” to 443 with a 301 redirect. Hit save and update for permanent http to https redirect to take effect.
Go to Route53 and point to the new application load balancer. Once done, delete the classic load balancer.
Done!

References:

EC2 Tutorial: https://hackernoon.com/deploying-a-node-app-on-amazon-ec2-d2fb9a6757eb
ELB Tutorial: https://medium.com/tfogo/how-to-serve-your-website-on-port-80-or-443-using-aws-load-balancers-a3b84781d730
Add Env: https://mrngoitall.net/blog/2013/10/13/best-practices-on-deploying-node-dot-js-to-aws-ec2/
Route 53 to Load Balancer: https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/using-domain-names-with-elb.html?icmpid=docs_elb_console

Installing Node.js with `nvm` to Linux & macOS & WSL

2023-01-04T00:00:00+08:00

A quick guide on how to setup Node.js development environment.

Install `nvm` for managing Node.js versions

nvm allows installing several versions of Node.js to the same system. Sometimes applications require a certain versions of Node.js to work. Having the flexibility of using specific versions can help.

Open new Terminal window.
Run nvm installer. (If you already had it, remember to update to more recent versions.)
- … with either curl or wget, depending on what your computer has available.
  - curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
  - wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
- The script clones the nvm repository to ~/.nvm and adds the source line to your profile (~/.bash_profile, ~/.zshrc, ~/.profile, or ~/.bashrc). (You can add the source loading line manually, if the automated install tool does not add it for you.)
```
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
```
- Another option: when you have consistent directory location between systems, following example Bash/Zsh configuration allows to load nvm when the directory exists. This allows more consistent sharing of your shell configuration between systems, improving reliability of rest of your configuration even when nvm does not exist on a specific system.
```
if [ -d "$HOME/.nvm" ]; then
  # export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
  export NVM_DIR="$HOME/.nvm"

  # This loads nvm
  [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

  # This loads nvm bash_completion
  [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
fi
```
If everything went well, you should now either open a new Terminal window/tab, or reload the shell configuration by running:
- source ~/.bashrc
Verify installation
- To check if nvm command got installed, run:
  - command -v nvm

Install Node.js with `nvm`

List installed Node.js versions with:
- nvm ls
Install latest LTS Version of Node.js (for production quality applications)
- nvm install v20.11.1
Install latest Node.js Current release (for testing new feature improvements)
- nvm install v21.6.2
If you want to change the default Node version later, you can run a command to adjust it.
- nvm alias default v20.11.1 changelog (for production quality applications)
- nvm alias default v21.6.2 changelog (if you use Node.js features from the Current release)

You can select Node.js version by running nvm use v20.11.1 (or another version number). Another alternative: create a small Bash shell script to enable the right environment variables for your project.

Read the Node.js [Long Term Support (LTS) schedule](https://nodejs.org/en/about/releases/ “Releases

Node.js”) to have more understanding of their release roadmap. List of all [previous releases](https://nodejs.org/en/download/releases/ “Previous Releases

Node.js”) is also useful for finding details about Node.js release history.

npm package repository has a lot of packages to discover. Have a good time with the freshly installed tools.

Migrating packages from a previous Node.js version

If you already have existing Node.js version via nvm, you can migrate older packages from the installed Node.js versions.

Open new Terminal window (to make sure you have latest Node.js version active in your command line environment).
Before running next commands, remember to switch to the right version of Node with nvm use command. For example:
- nvm use v20.11.1
- nvm use v21.6.2
Linking global packages from previous version:
- nvm reinstall-packages v20.3.1
- nvm reinstall-packages v18.16.1

Deleting old Node.js versions

Check installed Node.js versions with:
- nvm ls
Delete an older version (if you don’t use it in some of your projects):
- nvm uninstall v20.3.1
- nvm uninstall v18.16.1

Updating outdated packages

Warning: Make sure you have latest nvm version installed, just in case. Update instructions of it in the beginning of this article. nvm v0.39.2 version of fixes potential problems that might cause older node environments to break if accidentally installing npm v9 to those.

List of globally installed top level packages

npm ls -g --depth=0.

List outdated global packages

npm outdated -g --depth=0.

Updating all globally installed npm packages

Warning: This might be too risky approach. Instead, it is better to update packages individually, as that avoids the risk of accidentally updating npm package to incompatible versions. npm v9 installation to older incompatible Node.js environments is known to cause problems (potentially breaking down the development environment), so it’s better be safe than sorry.

npm update -g

CLI aliases for Bash & Zsh environments

Example configuration for your Bash & Zsh command line environments.

# -----------------------------------------------------------
# npm helpers
# -----------------------------------------------------------

# List what (top level) packages are installed globally
alias list-installed-npm-packages="npm ls -g --depth=0."

# List what globally installed packages are outdated
alias list-outdated-npm-packages="npm outdated -g --depth=0."

# Update outdated globally installed npm packages
alias update-npm-packages="npm update -g"

Fixing old package versions

If you have older npm packages with compiled native extensions, recompiling native extensions can improve compatibility with the new Node.js version. Go to your project’s root directory, and run npm rebuild command.

cd PROJECT_NAME
npm rebuild

Notes about this documentation

@d2s tested older versions of these install instructions with:

Contributions

If you have improvement suggestions to make these instructions simpler & better, post a comment under the original Gist by @d2s with your documentation improvement suggestions. If you are reading a forked version of the document, check the original Gist for a more recent instructions.