Installing Node.js NES on cloud providers

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"]

export const handler = async (event) => {
  return {
    statusCode: 200,
    body: JSON.stringify({ nodeVersion: process.version, event })
  };
};

# Build and push
export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export REGION=us-east-1
export REPO=node-nes-custom
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>

aws ecr create-repository --repository-name ${REPO} --region ${REGION} --query repository.repositoryUri --output text

aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com

docker build \
  --platform linux/amd64 \
  --provenance=false \ # Disable buildkit provenance for compatibility if needed
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${NODE_VERSION} .

docker push ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${NODE_VERSION}

# Deploy the image to a Lambda function
aws lambda create-function \
  --function-name node-nes-custom \
  --package-type Image \
  --code ImageUri=${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${NODE_VERSION} \
  --role arn:aws:iam::${ACCOUNT_ID}:role/your-lambda-execution-role

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

# Pin the Node.js NES version you want inside Fargate
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 dnf install -y \
    ca-certificates \
    curl \
    gzip \
    tar \
    && dnf clean all

# 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 ./

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

import http from 'node:http';

const port = Number.parseInt(process.env.PORT || '3000', 10);

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    nodeVersion: process.version,
    path: req.url
  }));
});

server.listen(port, '0.0.0.0');

{
  "family": "node-nes-fargate",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::<account-id>:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "node-nes-app",
      "image": "<account-id>.dkr.ecr.<region>.amazonaws.com/node-nes-fargate:v20.19.14-nes",
      "essential": true,
      "portMappings": [
        {
          "containerPort": 3000,
          "protocol": "tcp"
        }
      ],
      "environment": [
        {
          "name": "PORT",
          "value": "3000"
        }
      ],
      "logConfiguration": {
        "logDriver": "awslogs",
        "options": {
          "awslogs-group": "/ecs/node-nes-fargate",
          "awslogs-region": "<region>",
          "awslogs-stream-prefix": "ecs"
        }
      }
    }
  ]
}

export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export REGION=us-east-1
export REPO=node-nes-fargate
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>
export IMAGE_URL=${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${NODE_VERSION}

aws ecr create-repository \
  --repository-name ${REPO} \
  --region ${REGION} \
  --query repository.repositoryUri \
  --output text

aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com

docker build \
  --platform linux/amd64 \
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${IMAGE_URL} .

docker push ${IMAGE_URL}

export CLUSTER=node-nes-cluster
export SERVICE=node-nes-fargate
export SUBNET_ID=<your-subnet-id>
export SECURITY_GROUP_ID=<your-security-group-id>

aws logs create-log-group \
  --log-group-name /ecs/node-nes-fargate \
  --region ${REGION}

aws ecs create-cluster \
  --cluster-name ${CLUSTER}

aws ecs register-task-definition \
  --cli-input-json file://task-definition.json

aws ecs create-service \
  --cluster ${CLUSTER} \
  --service-name ${SERVICE} \
  --task-definition node-nes-fargate \
  --desired-count 1 \
  --launch-type FARGATE \
  --network-configuration "awsvpcConfiguration={subnets=[${SUBNET_ID}],securityGroups=[${SECURITY_GROUP_ID}],assignPublicIp=ENABLED}"

docker run --rm -d --name node-nes-fargate -p 3000:3000 ${IMAGE_URL}

curl http://localhost:3000

docker rm -f node-nes-fargate

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

# Pin the Node.js NES version you want inside App Runner
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 dnf install -y \
    ca-certificates \
    curl \
    gzip \
    tar \
    && dnf clean all

# 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 ./

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

import http from 'node:http';

const port = Number.parseInt(process.env.PORT || '3000', 10);

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    nodeVersion: process.version,
    path: req.url
  }));
});

server.listen(port, '0.0.0.0');

{
  "ServiceName": "node-nes-app-runner",
  "SourceConfiguration": {
    "AuthenticationConfiguration": {
      "AccessRoleArn": "arn:aws:iam::<account-id>:role/<app-runner-ecr-access-role>"
    },
    "AutoDeploymentsEnabled": true,
    "ImageRepository": {
      "ImageIdentifier": "<account-id>.dkr.ecr.<region>.amazonaws.com/node-nes-app-runner:v20.19.14-nes",
      "ImageConfiguration": {
        "Port": "3000",
        "RuntimeEnvironmentVariables": {
          "PORT": "3000"
        }
      },
      "ImageRepositoryType": "ECR"
    }
  },
  "InstanceConfiguration": {
    "Cpu": "0.25 vCPU",
    "Memory": "0.5 GB"
  }
}

export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export REGION=us-east-1
export REPO=node-nes-app-runner
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>
export IMAGE_URL=${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com/${REPO}:${NODE_VERSION}

aws ecr create-repository \
  --repository-name ${REPO} \
  --region ${REGION} \
  --query repository.repositoryUri \
  --output text

aws ecr get-login-password --region ${REGION} | docker login --username AWS --password-stdin ${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com

docker build \
  --platform linux/amd64 \
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${IMAGE_URL} .

docker push ${IMAGE_URL}

aws apprunner create-service \
  --cli-input-json file://apprunner-service.json

docker run --rm -d --name node-nes-app-runner -p 3000:3000 ${IMAGE_URL}

curl http://localhost:3000

docker rm -f node-nes-app-runner

#!/bin/bash
set -euo pipefail

NODE_VERSION=v20.19.14-nes
NES_TOKEN=<your-nes-token>
REGISTRY_BASE=https://registry.nes.herodevs.com/nodejs/nes
NODE_DIR=/opt/node
APP_DIR=/opt/node-nes-app

dnf install -y \
  ca-certificates \
  curl \
  gzip \
  tar

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}" "${APP_DIR}"
tar -xzf /tmp/node.tgz -C "${NODE_DIR}" --strip-components=1
rm /tmp/node.tgz

cat > "${APP_DIR}/server.js" <<'EOF'
import http from 'node:http';

const port = Number.parseInt(process.env.PORT || '3000', 10);

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    nodeVersion: process.version,
    path: req.url
  }));
});

server.listen(port, '0.0.0.0');
EOF

cat > /etc/systemd/system/node-nes-app.service <<EOF
[Unit]
Description=Node.js NES application
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=${APP_DIR}
Environment=PATH=${NODE_DIR}/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
Environment=PORT=3000
ExecStart=${NODE_DIR}/bin/node ${APP_DIR}/server.js
Restart=always
RestartSec=5
User=ec2-user

[Install]
WantedBy=multi-user.target
EOF

chown -R ec2-user:ec2-user "${APP_DIR}"
systemctl daemon-reload
systemctl enable --now node-nes-app

export AMI_ID=<amazon-linux-2023-ami-id>
export INSTANCE_TYPE=t3.micro
export KEY_NAME=<your-key-pair>
export SUBNET_ID=<your-subnet-id>
export SECURITY_GROUP_ID=<your-security-group-id>

aws ec2 run-instances \
  --image-id ${AMI_ID} \
  --instance-type ${INSTANCE_TYPE} \
  --key-name ${KEY_NAME} \
  --subnet-id ${SUBNET_ID} \
  --security-group-ids ${SECURITY_GROUP_ID} \
  --user-data file://user-data.sh

/opt/node/bin/node --version
systemctl status node-nes-app
curl http://localhost:3000

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"]

import http from 'node:http';

const port = Number.parseInt(process.env.PORT || '8080', 10);

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    nodeVersion: process.version,
    path: req.url
  }));
});

server.listen(port, '0.0.0.0');

export PROJECT_ID=<your-google-cloud-project>
export REGION=us-central1
export REPO=node-nes-custom
export SERVICE=node-nes-cloud-run
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>
export IMAGE_URL=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${SERVICE}:${NODE_VERSION}

gcloud config set project ${PROJECT_ID}

gcloud services enable \
  artifactregistry.googleapis.com \
  run.googleapis.com

# Skip this command if the repository already exists.
gcloud artifacts repositories create ${REPO} \
  --repository-format=docker \
  --location=${REGION}

gcloud auth configure-docker ${REGION}-docker.pkg.dev

docker build \
  --platform linux/amd64 \
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${IMAGE_URL} .

docker push ${IMAGE_URL}

gcloud run deploy ${SERVICE} \
  --image ${IMAGE_URL} \
  --region ${REGION} \
  --allow-unauthenticated

docker run --rm -d --name node-nes-cloud-run -p 8080:8080 ${IMAGE_URL}

curl http://localhost:8080

docker rm -f node-nes-cloud-run

export SERVICE_URL=$(gcloud run services describe ${SERVICE} \
  --region ${REGION} \
  --format='value(status.url)')

curl ${SERVICE_URL}

runtime: custom
env: flex

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

FROM debian:bookworm-slim

# Pin the Node.js NES version you want inside App Engine
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"]

import http from 'node:http';

const port = 8080;

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'content-type': 'application/json' });
  res.end(JSON.stringify({
    nodeVersion: process.version,
    path: req.url
  }));
});

server.listen(port, '0.0.0.0');

export PROJECT_ID=<your-google-cloud-project>
export REGION=us-central1
export APP_ENGINE_REGION=us-central
export REPO=node-nes-custom
export SERVICE=node-nes-app-engine
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>
export IMAGE_URL=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${SERVICE}:${NODE_VERSION}

gcloud config set project ${PROJECT_ID}

gcloud services enable \
  appengineflex.googleapis.com \
  artifactregistry.googleapis.com

# Run this once if the project does not already have an App Engine application.
gcloud app create --region=${APP_ENGINE_REGION}

# Skip this command if the repository already exists.
gcloud artifacts repositories create ${REPO} \
  --repository-format=docker \
  --location=${REGION}

gcloud auth configure-docker ${REGION}-docker.pkg.dev

docker build \
  --platform linux/amd64 \
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${IMAGE_URL} .

docker push ${IMAGE_URL}

gcloud app deploy app.yaml \
  --image-url=${IMAGE_URL}

docker run --rm -d --name node-nes-app-engine -p 8080:8080 ${IMAGE_URL}

curl http://localhost:8080

docker rm -f node-nes-app-engine

export APP_URL=https://$(gcloud app describe --format='value(defaultHostname)')

curl ${APP_URL}

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"]

{
  "name": "node-nes-google-cloud-functions",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "dependencies": {
    "@google-cloud/functions-framework": "^3.0.0"
  }
}

export const helloNodeNes = (req, res) => {
  res.status(200).json({
    nodeVersion: process.version
  });
};

export PROJECT_ID=<your-google-cloud-project>
export REGION=us-central1
export REPO=node-nes-custom
export SERVICE=node-nes-custom
export NODE_VERSION=v20.19.14-nes
export NES_TOKEN=<your-nes-token>
export IMAGE_URL=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO}/${SERVICE}:${NODE_VERSION}

gcloud services enable \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  run.googleapis.com

gcloud artifacts repositories create ${REPO} \
  --repository-format=docker \
  --location=${REGION}

gcloud auth configure-docker ${REGION}-docker.pkg.dev

docker build \
  --platform linux/amd64 \
  --build-arg NES_TOKEN=${NES_TOKEN} \
  --build-arg NODE_VERSION=${NODE_VERSION} \
  -t ${IMAGE_URL} .

docker push ${IMAGE_URL}

gcloud run deploy ${SERVICE} \
  --image ${IMAGE_URL} \
  --region ${REGION} \
  --allow-unauthenticated