Deployment: VPS, PaaS or containers, and zero-downtime releases

// simulated warm-up (DB connections, caches) before the port opens
const STARTUP_DELAY_MS = Number(process.env.STARTUP_DELAY_MS ?? 0);
setTimeout(() => {
  server.listen(PORT, () => console.log(`app ${VERSION} on :${PORT}`));
}, STARTUP_DELAY_MS);

include /etc/nginx/conf.d/upstream.inc;

server {
    listen 80;

    location / {
        proxy_pass http://app_backend;
        proxy_set_header Host            $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

#!/usr/bin/env bash
# Local stand: one Docker network, the app v1 ("blue") and Nginx in front of it
set -euo pipefail
P="${PREFIX:-demo}"
docker network create "$P-net" >/dev/null
echo "upstream app_backend { server $P-app-blue:3000; }" > nginx/conf.d/upstream.inc
docker run -d --rm --name "$P-app-blue" --network "$P-net" \
  -e STARTUP_DELAY_MS=3000 -e APP_VERSION=v1 -v "$PWD/app:/app:ro" node:24-alpine node /app/server.mjs >/dev/null
docker run -d --rm --name "$P-proxy" --network "$P-net" -p 8081:80 \
  -v "$PWD/nginx/conf.d:/etc/nginx/conf.d:ro" nginx:stable-alpine >/dev/null
echo blue > .active
sleep 5 && curl -s http://localhost:8081/api/whoami && echo

#!/usr/bin/env bash
P="${PREFIX:-demo}"
docker stop "$P-proxy" "$P-app-blue" "$P-app-green" >/dev/null 2>&1
docker network rm "$P-net" >/dev/null 2>&1
rm -f .active nginx/upstream.prev
echo "stand removed"

#!/bin/sh
# Simulated users: a request every ~50 ms for N seconds, then a summary
# of status codes and versions ("000" = no response within 2 s).
# Usage: ./watch.sh 20 http://localhost:8081/api/whoami
DURATION="${1:-20}"; URL="${2:-http://localhost:8081/api/whoami}"
END=$(( $(date +%s) + DURATION ))
while [ "$(date +%s)" -lt "$END" ]; do
  out=$(curl -s -m 2 -w ' %{http_code}' "$URL")
  code="${out##* }"
  version=$(printf '%s' "$out" | grep -o '"version":"[^"]*"' | cut -d'"' -f4)
  echo "$code ${version:--}"
  sleep 0.05
done | sort | uniq -c

#!/usr/bin/env bash
# Anti-pattern: stop the running version, then start the new one in its place
set -euo pipefail
P="${PREFIX:-demo}"
docker stop "$P-app-blue" >/dev/null
docker run -d --rm --name "$P-app-blue" --network "$P-net" \
  -e STARTUP_DELAY_MS=3000 -e APP_VERSION="$1" -v "$PWD/app:/app:ro" node:24-alpine node /app/server.mjs >/dev/null
echo "restarted in place with $1"

$ ./setup.sh
{"version":"v1","host":"localhost","forwardedFor":"192.168.16.1","peer":"::ffff:192.168.16.3"}
$ docker run --rm --network demo-net -v "$PWD/watch.sh:/watch.sh:ro" nginx:stable-alpine sh /watch.sh 15 http://demo-proxy/api/whoami > naive.txt &
$ sleep 3; ./naive.sh v2; wait
restarted in place with v2
$ cat naive.txt
     49 200 v1
    119 200 v2
     53 502 -

#!/usr/bin/env bash
# Blue-green release behind Nginx: start the new version next to the old one,
# wait for its health check, switch Nginx with a graceful reload, stop the old one.
# Usage: ./deploy.sh v2
set -euo pipefail

VERSION="$1"
P="${PREFIX:-demo}"                      # container name prefix
ACTIVE=$(cat .active 2>/dev/null || echo blue)
NEXT=$([ "$ACTIVE" = blue ] && echo green || echo blue)

echo "deploy $VERSION: $ACTIVE -> $NEXT"
docker run -d --rm --name "$P-app-$NEXT" --network "$P-net" \
  -e STARTUP_DELAY_MS=3000 -e APP_VERSION="$VERSION" -v "$PWD/app:/app:ro" \
  node:24-alpine node /app/server.mjs >/dev/null

# 1. Health check: the new version must answer before it gets traffic
for i in $(seq 1 20); do
  if docker exec "$P-proxy" curl -fsS "http://$P-app-$NEXT:3000/healthz" >/dev/null 2>&1; then
    echo "health check passed after $i attempt(s)"
    break
  fi
  if [ "$i" -eq 20 ]; then
    echo "health check failed: $NEXT stays out of traffic"
    docker stop "$P-app-$NEXT" >/dev/null
    exit 1
  fi
  sleep 0.5
done

# 2. Switch: rewrite the upstream, validate the config, reload gracefully
cp nginx/conf.d/upstream.inc nginx/upstream.prev
echo "upstream app_backend { server $P-app-$NEXT:3000; }" > nginx/conf.d/upstream.inc
if ! docker exec "$P-proxy" nginx -t >/dev/null 2>&1; then
  cp nginx/upstream.prev nginx/conf.d/upstream.inc
  docker stop "$P-app-$NEXT" >/dev/null
  echo "nginx -t failed: config restored"
  exit 1
fi
docker exec "$P-proxy" nginx -s reload
echo "$NEXT" > .active

# 3. Old version: SIGTERM, it finishes in-flight requests and exits
sleep 2
docker stop "$P-app-$ACTIVE" >/dev/null
echo "done: $VERSION is live on $NEXT, $ACTIVE stopped"

$ ./teardown.sh && ./setup.sh
stand removed
{"version":"v1","host":"localhost","forwardedFor":"192.168.16.1","peer":"::ffff:192.168.16.3"}
$ docker run --rm --network demo-net -v "$PWD/watch.sh:/watch.sh:ro" nginx:stable-alpine sh /watch.sh 20 http://demo-proxy/api/whoami > bg.txt &
$ sleep 3
$ docker run --rm --network demo-net nginx:stable-alpine curl -s -w ' %{http_code}\n' "http://demo-proxy/api/slow?ms=8000" > slow.txt &
$ sleep 0.5; ./deploy.sh v2; wait
deploy v2: blue -> green
health check passed after 4 attempt(s)
2026/10/12 01:36:08 [notice] 77#77: signal process started
done: v2 is live on green, blue stopped
$ cat bg.txt slow.txt
    126 200 v1
    134 200 v2
{"waitedMs":8000} 200

$ docker run --rm --network demo-net -v "$PWD/watch.sh:/watch.sh:ro" nginx:stable-alpine sh /watch.sh 15 http://demo-proxy/api/whoami > rollback.txt &
$ sleep 3; ./deploy.sh v1; wait
deploy v1: green -> blue
health check passed after 5 attempt(s)
2026/10/12 01:36:29 [notice] 149#149: signal process started
done: v1 is live on blue, green stopped
$ cat rollback.txt
    108 200 v1
    126 200 v2