Docker & Kubernetes

NodeSource publishes N|Solid Runtime images based on Debian and Alpine on Docker Hub. This page lists the available tags and shows how to run an application in a container with Docker, Docker Compose, and Kubernetes.

Images are available for the active Node.js LTS lines: krypton (Node.js 24) and jod (Node.js 22). Iron (Node.js 20) images reached end of life in April 2026 and are no longer updated.

Image tags

Tag	Description
latest	Latest release, Debian-based.
alpine-latest	Latest release, Alpine-based.
krypton-latest, jod-latest	Latest release for a Node.js LTS line, Debian-based.
krypton-alpine-latest, jod-alpine-latest	Latest release for a Node.js LTS line, Alpine-based.
<line>-bookworm-slim-latest, <line>-trixie-slim-latest (for example krypton-trixie-slim-latest, jod-bookworm-slim-latest)	Latest release for a Node.js LTS line on a slim Debian base.
<line>-<node-version>-ns<nsolid-version>	A pinned release, for example krypton-24.21.0-ns6.3.7 or jod-22.23.3-ns6.3.7.

Debian-based images are published for amd64 and arm64. Alpine-based images are amd64 only.

tip

In production, pin a specific release (for example nodesource/nsolid:krypton-24.21.0-ns6.3.7) instead of a latest tag, so your builds are reproducible. See Docker Hub for the full list of tags.

Pull an image:

docker pull nodesource/nsolid:krypton-latest

Build an image for your application

Use an N|Solid image as the base image for your application. This example Dockerfile assumes your application starts with node index.js and listens on port 3000:

FROM nodesource/nsolid:krypton-latest
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "index.js"]

Build it:

docker build -t my-app .

Connect to the N|Solid Console

To connect a containerized process to N|Solid SaaS, set the NSOLID_SAAS environment variable to your N|Solid SaaS token. Set NSOLID_APPNAME to name the application in the Console, and optionally NSOLID_TAGS to add tags. For other connection options, see Runtime configuration.

warning

Treat your N|Solid SaaS token as a secret. Store it in a secrets manager or vault, and don't bake it into your image.

Run with Docker

This example reads the token from the NSOLID_SAAS variable in your shell:

docker run -it -p 3000:3000 \
  -e NSOLID_APPNAME="my-app" \
  -e NSOLID_TAGS="production,nsolid-krypton" \
  -e NSOLID_SAAS="$NSOLID_SAAS" \
  my-app

Run with Docker Compose

Docker Compose reads NSOLID_SAAS from your shell or from a .env file next to compose.yaml:

services:
  my-app:
    build: .
    restart: always
    environment:
      - NSOLID_APPNAME=my-app
      - NSOLID_TAGS=production,nsolid-krypton
      - NSOLID_SAAS=${NSOLID_SAAS}
    ports:
      - "3000:3000"

Start it:

docker compose up -d

Deploy on Kubernetes

You can also deploy N|Solid applications to a Kubernetes cluster. For a complete example, including a Next.js application build and basic Kubernetes configuration for the N|Solid Runtime, see the nsolid-kubernetes repository.

A typical configuration includes:

• Deployment: runs your application image with the N|Solid environment variables and secrets.
• Service: exposes the deployment inside the cluster.
• Ingress: provides external access to the service.
• Secret: stores sensitive values such as NSOLID_SAAS.

Create the secret

Before you deploy, store your N|Solid SaaS token in a Kubernetes secret:

kubectl create secret generic nsolid-saas-secret --from-literal=nsolid_saas="$NSOLID_SAAS"

Sample deployment manifest

Replace registry.example.com/my-app:1.0.0 with the image you built and pushed to your registry. The liveness and readiness probes call GET /health on port 3000, so your application must serve that endpoint. Change or remove the probes to match your application.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  labels:
    app: my-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      securityContext:
        runAsNonRoot: true
        runAsUser: 1016
      containers:
        - name: my-app
          image: registry.example.com/my-app:1.0.0
          ports:
            - containerPort: 3000
          env:
            - name: NSOLID_APPNAME
              value: "my-app"
            - name: NSOLID_TAGS
              value: "production,nsolid-krypton"
            - name: NSOLID_SAAS
              valueFrom:
                secretKeyRef:
                  name: nsolid-saas-secret
                  key: nsolid_saas
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          livenessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /health
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 5
      terminationGracePeriodSeconds: 30

note

runAsNonRoot: true rejects containers that would run as root. Setting runAsUser to a non-root user ID satisfies this check. The Debian-based N|Solid images include non-root node (UID 1015) and nsolid (UID 1016) users; this example runs as nsolid. Make sure that user can read your application files.

Deploy

1. Build your image, locally or in CI (for example, with GitHub Actions).

2. Push the image to a container registry your cluster can reach.

3. Apply the manifests from your Kubernetes configuration directory:

   kubectl apply -f k8s/

4. Check the deployment and confirm that the pods are running:

   kubectl get pods --namespace=default

When the pods are running, the processes appear in the N|Solid Console under the name you set in NSOLID_APPNAME.