The following documentation provides a step-by-step guide on how to scale the benhall/express-demo project for production environments, utilizing Docker and various associated technologies.

Prerequisites

Ensure that you have Docker installed and configured on your production server. The project scales effectively by utilizing containerization, which simplifies deployment, scaling, and management of your application instances.

Step 1: Docker Configuration

The project’s Dockerfile and docker-compose.yml provide a foundational configuration for containerizing the application.

Dockerfile

The Dockerfile defines how to build your application. It ensures that the application and its dependencies are correctly installed and ready for running in a containerized environment.

# Ability to override to ensure it matches .nvmrc
ARG NODE=20.11.0
FROM node:${NODE}

WORKDIR /usr/src/app

# Install Webpack + dependencies for compiling
ENV ADBLOCK=1
COPY package*.json ./
RUN npm ci

COPY . .

# Rebuild Webpack
RUN npm run build 

FROM node:${NODE}

# Create app directory and define defaults
WORKDIR /usr/src/app
EXPOSE 3000
CMD [ "./bin/www" ]
ENV ADBLOCK=1

# Install app dependencies
COPY package*.json ./
RUN npm ci --production

# Bundle app source
COPY --from=0 /usr/src/app/public public
COPY --from=0 /usr/src/app/webpack.version.json .
COPY . .

In this Dockerfile, the application is built in two stages:

1. First Stage: This builds the project, runs Webpack to compile assets, and prepares it for production.
2. Second Stage: This installs only production dependencies to optimize the container’s size.

The critical line that exposes the running application is:

EXPOSE 3000

docker-compose.yml

The docker-compose.yml file is essential for managing multi-container applications and networking between them. Here is a simple service configuration defined for this project:

version: "3.9"
services:
  web:
    build: .
    ports:
      - "3000:3000"

The above file specifies that the service named web will be built using the Dockerfile in the current directory. It maps port 3000 on the container to port 3000 on the host machine, allowing access to the application through the host’s port.

Step 2: Scaling the Application

To scale the application horizontally for production, you can adjust your docker-compose.yml to run multiple instances of the web service. Use the scale command or define replicas explicitly in the configuration.

For instance, to run 3 instances of the web service, modify the docker-compose.yml as follows:

version: "3.9"
services:
  web:
    build: .
    ports:
      - "3000:3000"
    deploy:
      replicas: 3

Step 3: Load Balancing

When scaling the application, a load balancer becomes necessary to distribute incoming traffic evenly across multiple service instances. You can configure a load balancer like Nginx or utilize cloud provider solutions.

An example Nginx configuration for load balancing might look like this:

http {
    upstream backend {
        server web1:3000;
        server web2:3000;
        server web3:3000;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://backend;
        }
    }
}

You need to replace web1, web2, and web3 with the appropriate container names or IPs of your running instances.

Step 4: Monitoring and Logging

To effectively monitor the performance of your application, consider integrating monitoring tools. You could use tools like Prometheus, Grafana, or ELK stack.

Make sure that you log application behavior and errors. Proper logging can be achieved by piping logs from your Node.js application to stdout and configuring Docker to manage these logs:

CMD [ "npm", "start" ]

Logs from the container can be accessed via:

docker logs <container_id>

Conclusion

By utilizing Docker and the configurations in the Dockerfile and docker-compose.yml, the benhall/express-demo project can be efficiently scaled in production. For optimal performance, consider employing load balancing strategies and monitoring solutions to ensure the application runs smoothly under increased load.

This documentation serves as a foundation for scaling practices but can be further enhanced based on specific production requirements.