Installing Node.js NES

How to install Node.js NES

Listing Available Versions

Version	Linux x64	Linux ARM64	Darwin ARM64	Windows x64	RHEL 8 x64
v12	✅	✅	❌	✅	❌
v14	✅	✅	❌	✅	❌
v16	✅	✅	✅	✅	❌
v18	✅	✅	✅	✅	✅
v20	✅	❌	✅	✅	❌
v22	✅	❌	✅	✅	❌

To retrieve the full list of available versions, including trials, run the following command in your terminal:

Note

You must pass in a valid token for the endpoint to return non-trial versions

All Versions

Trial Versions

curl -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/index.tab

Download Node.js

Node.js NES can be downloaded and installed in several ways. This guide highlights the most common and convenient methods.

Using NVM

The fastest way to download Node.js on Linux and MacOS is through NVM.

NVM Windows is not supported, it is recommended to use the wget method instead. Make sure the NVM version is 0.40.0 or higher. You can check your NVM version by running nvm --version.

/bin/sh

export NVM_NODEJS_ORG_MIRROR=https://registry.nes.herodevs.com/nodejs/nes
export NVM_AUTH_HEADER="Bearer <token>"
nvm ls-remote # check all the available versions
nvm install v16.20.5-nes
nvm use v16.20.5-nes

Alternatively, you can download the binary using curl or wget.

Using curl

To download the binary, your curl command should be formatted like the following:

/bin/sh

# Outputs the a tarball or zip to the current working directory
curl -sL -O -H "Authorization: Bearer <token>" ARTIFACT_URL

For example, to download the Node.js 16 NES, choose your platform and then run the associated curl command:

Darwin arm64

Darwin x64

Linux x64

Windows x64

curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v16.20.5-nes/node-v16.20.5-nes-darwin-arm64.tar.gz

Using wget

Alternatively, you can use wget to download the binary. The format is as follows:

/bin/sh

# Outputs the a tarball or zip to the current working directory
wget --header="Authorization: Bearer <token>" ARTIFACT_URL

For example, to download the Node.js 16 NES, choose your platform and then run the associated wget command:

Darwin arm64

Darwin x64

Linux x64

Windows x64

wget --header="Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v16.20.5-nes/node-v16.20.5-nes-darwin-arm64.tar.gz

Dependending on the version you want to download, you may replace the version, platforms, or architecture with the following values:

Versions: v12.22.12-nes, v14.21.3-nes, v16.20.2-nes, v18.20.6-trial-nes, v20.20.2-trial-nes
Platforms: darwin or linux.
Architectures: arm64 or x64.
Extensions: .zip or .tar.gz.

Note: Because Node v18 and v20 are being adopted before their End‑of‑Life, we prepend -trial to the version number before the -nes suffix. Remove -trial if you will be installing other versions.

Example: v18.20.6-trial-nes, v20.20.2-trial-nes.

RHEL 8 installation

To install Node.js NES on RHEL 8, you can download the following rpm package:

/bin/sh

curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v18.20.15-nes/node-v18.20.15-nes-bundled.el8.x86_64.rpm
curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v18.20.15-nes/npm-10.8.2-v18.20.15-nes-bundled.el8.x86_64.rpm

dnf -y install --nogpgcheck \
    ./npm-10.8.2-v18.20.15-nes-bundled.el8.x86_64.rpm \
    ./node-v18.20.15-nes-bundled.el8.x86_64.rpm

AWS Lambda installation

You can run Node.js NES in AWS Lambda by building a custom container image based on the Lambda provided.al2023 base.

Note that older NES version may not work on the Amazon Linux 2023 base image and might require the Amazon Linux 2 base instead.

Prerequisites

An NES registry token with download access
AWS CLI configured for the target account

Dockerfile

index.js

Build and push

FROM public.ecr.aws/amazonlinux/amazonlinux:2023

# Pin the Node.js NES version you want inside Lambda
ARG NODE_VERSION=v20.19.14-nes
# Provide your NES token at build time: --build-arg NES_TOKEN=...
ARG NES_TOKEN
ARG REGISTRY_BASE=https://registry.nes.herodevs.com/nodejs/nes

ENV NODE_DIR=/opt/node

RUN dnf install -y --allowerasing \
    ca-certificates \
    tar \
    gzip \
    shadow-utils \
    curl \
    cmake \
    make \
    gcc \
    gcc-c++ \
    python3 \
    autoconf \
    automake \
    libtool \
    && dnf clean all

# Install Node.js NES
RUN curl -fSL -H "Authorization: Bearer ${NES_TOKEN}" "${REGISTRY_BASE}/${NODE_VERSION}/node-${NODE_VERSION}-linux-x64.tar.gz" -o /tmp/node.tgz \
    && mkdir -p ${NODE_DIR} \
    && tar -xzf /tmp/node.tgz -C ${NODE_DIR} --strip-components=1 \
    && rm /tmp/node.tgz

ENV PATH="${NODE_DIR}/bin:${PATH}" \
    npm_config_nodedir=${NODE_DIR} \
    npm_config_prefix=${NODE_DIR}

RUN node --version

RUN npm install -g aws-lambda-ric@3

COPY index.js ./

# Change the version to match the Node.js runtime you are using (eg nodejs18.x)
ENV AWS_EXECUTION_ENV=AWS_Lambda_nodejs20.x

ENTRYPOINT ["/opt/node/bin/node", "/opt/node/lib/node_modules/aws-lambda-ric/bin/index.mjs"]

CMD ["index.handler"]

For more background on Lambda container images and pushing to ECR, see the AWS guides for container images and ECR authentication.

You can run Node.js NES on Google Cloud Run by building a custom container image that downloads the Node.js NES binary during the image build. Cloud Run runs the container image you provide, so the Node.js runtime comes from the binary installed in the Dockerfile instead of from a Google-managed Node.js runtime image.

Prerequisites

An NES registry token with download access
Google Cloud CLI configured for the target project
Docker installed locally, or an equivalent container build system
Artifact Registry enabled in the target project

Dockerfile

server.js

Build and deploy

Verify locally

Verify deployed service

FROM debian:bookworm-slim

# Pin the Node.js NES version you want inside Cloud Run
ARG NODE_VERSION=v20.19.14-nes
# Provide your NES token at build time: --build-arg NES_TOKEN=...
ARG NES_TOKEN
ARG REGISTRY_BASE=https://registry.nes.herodevs.com/nodejs/nes

ENV NODE_DIR=/opt/node
WORKDIR /workspace

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
      ca-certificates \
      curl \
      gzip \
      tar \
    && rm -rf /var/lib/apt/lists/*

# Install the custom Node.js NES build
RUN curl -fSL -H "Authorization: Bearer ${NES_TOKEN}" "${REGISTRY_BASE}/${NODE_VERSION}/node-${NODE_VERSION}-linux-x64.tar.gz" -o /tmp/node.tgz \
    && mkdir -p ${NODE_DIR} \
    && tar -xzf /tmp/node.tgz -C ${NODE_DIR} --strip-components=1 \
    && rm /tmp/node.tgz

ENV PATH="${NODE_DIR}/bin:${PATH}"

RUN node --version

COPY server.js ./

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

The local and deployed verification commands should return JSON that includes the Node.js NES version from process.version. Cloud Run requires the container to listen on the port provided by the PORT environment variable and bind to 0.0.0.0.

For more background on Cloud Run container images and runtime requirements, see the Google Cloud guides for deploying container images to Cloud Run and the Cloud Run container runtime contract.

Google App Engine installation

You can run Node.js NES on Google App Engine by using the App Engine flexible environment with a custom runtime. Build the container image yourself, push it to Artifact Registry, and deploy that prebuilt image with gcloud app deploy --image-url.

Do not deploy this with runtime: nodejs, because that uses Google's managed Node.js runtime instead of the Node.js NES binary.

Prerequisites

An NES registry token with download access
Google Cloud CLI configured for the target project
Docker installed locally, or an equivalent container build system
Artifact Registry enabled in the target project
An App Engine application created in the target project

app.yaml

Dockerfile

server.js

Build and deploy

Verify locally

Verify deployed service

runtime: custom
env: flex

manual_scaling:
  instances: 1
resources:
  cpu: 1
  memory_gb: 0.5
  disk_size_gb: 10

The local and deployed verification commands should return JSON that includes the Node.js NES version from process.version. App Engine flexible custom runtimes must listen for HTTP requests on port 8080.

For more background on App Engine flexible custom runtimes, prebuilt image deployment, and app.yaml, see the Google Cloud guides for building custom runtimes, configuring custom runtimes with app.yaml, and gcloud app deploy.

Google Cloud Functions installation

You can run Node.js NES for Google Cloud Functions by packaging your function as a custom container image and deploying it to Cloud Run. This uses the Google Functions Framework to receive function invocations, but the Node.js runtime itself comes from the Node.js NES binary that you download into the container.

Do not deploy this with gcloud functions deploy --runtime nodejs... or gcloud run deploy --source . --function ... --base-image nodejs..., because those paths use Google's managed Node.js runtime image instead of the Node.js NES binary.

Prerequisites

An NES registry token with download access
Google Cloud CLI configured for the target project
Docker installed locally, or an equivalent container build system
Artifact Registry enabled in the target project

Dockerfile

package.json

index.js

Build and deploy

FROM debian:bookworm-slim

# Pin the Node.js NES version you want inside Google Cloud Functions
ARG NODE_VERSION=v20.19.14-nes
# Provide your NES token at build time: --build-arg NES_TOKEN=...
ARG NES_TOKEN
ARG REGISTRY_BASE=https://registry.nes.herodevs.com/nodejs/nes

ENV NODE_DIR=/opt/node
WORKDIR /workspace

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
      ca-certificates \
      curl \
      gzip \
      tar \
    && rm -rf /var/lib/apt/lists/*

# Install the custom Node.js NES build
RUN curl -fSL -H "Authorization: Bearer ${NES_TOKEN}" "${REGISTRY_BASE}/${NODE_VERSION}/node-${NODE_VERSION}-linux-x64.tar.gz" -o /tmp/node.tgz \
    && mkdir -p ${NODE_DIR} \
    && tar -xzf /tmp/node.tgz -C ${NODE_DIR} --strip-components=1 \
    && rm /tmp/node.tgz

ENV PATH="${NODE_DIR}/bin:${PATH}" \
    npm_config_nodedir=${NODE_DIR} \
    npm_config_prefix=${NODE_DIR}

RUN node --version

COPY package*.json ./
RUN npm install --omit=dev

COPY index.js ./

CMD ["./node_modules/.bin/functions-framework", "--target=helloNodeNes"]

The deployed service runs as a Cloud Run function-compatible container. If you need event-driven behavior, attach the appropriate Eventarc trigger to the Cloud Run service after deployment.

For more background on Cloud Run functions, Functions Framework, and container image deployment, see the Google Cloud guides for writing Cloud Run functions, the Functions Framework, and deploying container images to Cloud Run.

Verification

It is possible to verify the integrity of the downloaded files using the provided SHA256 checksums and GPG signatures.

Download the checksum and signature files:

/bin/sh

curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v18.20.13-nes/SHASUMS256.txt
curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v18.20.13-nes/SHASUMS256.txt.asc
curl -sL -O -H "Authorization: Bearer <token>" https://registry.nes.herodevs.com/nodejs/nes/v18.20.13-nes/SHASUMS256.txt.sig

Import the GPG key used for signing:

GPG Key Fingerprint: CA44E935A3995EB733AF292B18DD1E9212F3C6A2.

You can find the key on the following key servers:

/bin/sh

gpg --keyserver keys.openpgp.org --recv-keys CA44E935A3995EB733AF292B18DD1E9212F3C6A2

Verify the signature of the checksum file:

/bin/sh

gpg --verify SHASUMS256.txt.asc SHASUMS256.txt

Verify the checksum of the downloaded binary:

/bin/sh

sha256sum -c --ignore-missing SHASUMS256.txt

GitHub Actions installation

You can use the setup-node action to install Node.js NES in GitHub Actions workflows by configuring the mirror and mirror-token parameters.

Prerequisites

An NES registry token stored as a GitHub Actions secret (e.g., NES_TOKEN)
setup-node action version 6.3.0 or higher

Add the following to your workflow file:

.github/workflows/ci.yml

- uses: actions/setup-node@v6.3.0
  with:
    node-version: '18.20.13-nes'
    mirror: 'https://registry.nes.herodevs.com/nodejs'
    mirror-token: 'Bearer ${{ secrets.NES_TOKEN }}'

The mirror parameter points to the HeroDevs NES registry, and mirror-token provides the authentication token for downloading the Node.js NES binary.

Version aliases or ranges are not supported.

Version	Linux x64	Linux ARM64	Darwin ARM64	Windows x64	RHEL 8 x64
v12	✅	✅	❌	✅	❌
v14	✅	✅	❌	✅	❌
v16	✅	✅	✅	✅	❌
v18	✅	✅	✅	✅	✅
v20	✅	❌	✅	✅	❌
v22	✅	❌	✅	✅	❌

Version	Linux x64	Linux ARM64	Darwin ARM64	Windows x64	RHEL 8 x64
v12	✅	✅	❌	✅	❌
v14	✅	✅	❌	✅	❌
v16	✅	✅	✅	✅	❌
v18	✅	✅	✅	✅	✅
v20	✅	❌	✅	✅	❌
v22	✅	❌	✅	✅	❌

Version	Linux x64	Linux ARM64	Darwin ARM64	Windows x64	RHEL 8 x64
v12	✅	✅	❌	✅	❌
v14	✅	✅	❌	✅	❌
v16	✅	✅	✅	✅	❌
v18	✅	✅	✅	✅	✅
v20	✅	❌	✅	✅	❌
v22	✅	❌	✅	✅	❌