Docker containerized deployment

Advantages of Docker Containerized Deployment

Docker containerized deployment brings significant convenience to Koa2 applications. Through containerization, developers can quickly build, test, and deploy applications while ensuring environment consistency. Containerized deployment addresses the "it works on my machine" problem caused by environment differences in traditional deployment methods, improving development efficiency and deployment reliability.

Installing the Docker Environment

Before starting, ensure Docker is installed on your system. Here are the installation methods for different operating systems:

Ubuntu/Debian:

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io

MacOS: Install via Homebrew:

brew install --cask docker

After installation, verify that Docker is running correctly:

docker --version
docker run hello-world

Creating a Koa2 Project

First, initialize a basic Koa2 project. Use npm to initialize the project and install Koa2:

mkdir koa2-docker-demo
cd koa2-docker-demo
npm init -y
npm install koa

Create an app.js file as the application entry point:

const Koa = require('koa');
const app = new Koa();

app.use(async ctx => {
  ctx.body = 'Hello Docker with Koa2!';
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Writing the Dockerfile

The Dockerfile is the core file for building Docker images. Create a Dockerfile in the project root directory:

# Use the official Node.js image as the base
FROM node:16-alpine

# Set the working directory
WORKDIR /usr/src/app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy project files
COPY . .

# Expose the application port
EXPOSE 3000

# Define the startup command
CMD ["node", "app.js"]

This Dockerfile does the following:

1. Uses the lightweight Alpine Linux-based Node.js 16 image
2. Sets the working directory to /usr/src/app
3. Copies and installs dependencies
4. Copies all project files
5. Exposes port 3000
6. Defines the startup command

Building the Docker Image

Use the following command to build the Docker image:

docker build -t koa2-demo .

After building, you can view the list of images:

docker images

Running the Docker Container

Run the newly built image:

docker run -p 3000:3000 -d koa2-demo

Parameter explanation:

• -p 3000:3000: Maps container port 3000 to host port 3000
• -d: Runs the container in the background

Verify that the container is running correctly:

docker ps
curl http://localhost:3000

Managing Multiple Containers with Docker Compose

For more complex applications, use Docker Compose to manage multiple services. Create a docker-compose.yml file:

version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
    volumes:
      - .:/usr/src/app
      - /usr/src/app/node_modules

This configuration:

1. Defines a service named app
2. Uses the Dockerfile in the current directory to build the image
3. Maps port 3000
4. Sets environment variables
5. Uses volume mounts for hot-reloading code

Start the service:

docker-compose up -d

Optimizing the Docker Image

To reduce the image size, use multi-stage builds:

# Build stage
FROM node:16-alpine AS builder
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Run stage
FROM node:16-alpine
WORKDIR /usr/src/app
COPY --from=builder /usr/src/app .
EXPOSE 3000
CMD ["node", "app.js"]

Handling Environment Variables

Koa2 applications often require environment variable configuration. Pass environment variables via Docker:

ENV NODE_ENV=production

Or pass them at runtime:

docker run -e NODE_ENV=production -p 3000:3000 -d koa2-demo

Access environment variables in the Koa2 application:

const env = process.env.NODE_ENV || 'development';

Log Management

Container logs can be viewed via Docker commands:

docker logs <container_id>

For production environments, it's recommended to output logs to standard output/error streams and collect them via Docker:

// Replace console.log with process.stdout.write
process.stdout.write(`Server running on http://localhost:3000\n`);

Health Checks

Add health checks to the container:

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/health || exit 1

Add a health check route in Koa2:

router.get('/health', (ctx) => {
  ctx.status = 200;
});

Deploying to Production

Production deployment requires considering the following factors:

1. Use orchestration tools like Kubernetes or Docker Swarm
2. Configure reverse proxies like Nginx
3. Set reasonable resource limits
4. Implement zero-downtime deployment

Example Kubernetes deployment file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: koa2-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: koa2
  template:
    metadata:
      labels:
        app: koa2
    spec:
      containers:
      - name: koa2
        image: koa2-demo:latest
        ports:
        - containerPort: 3000
        resources:
          limits:
            cpu: "1"
            memory: "512Mi"

Troubleshooting Common Issues

Issue 1: Container exits immediately after starting Check if the application is running in the foreground and ensure no background commands like npm start are used.

Issue 2: Port conflicts Ensure the host port is not in use or change the mapped port:

docker run -p 3001:3000 -d koa2-demo

Issue 3: File changes not taking effect Use volume mounts for hot-reloading during development:

docker run -v $(pwd):/usr/src/app -p 3000:3000 -d koa2-demo

Performance Optimization Recommendations

1. Use a .dockerignore file to exclude unnecessary files:

node_modules
.git
*.log

2. Choose an appropriate base image, such as node:16-alpine

3. Leverage caching effectively by placing less frequently changed layers earlier in the Dockerfile

4. Use multi-stage builds to reduce image size in production

Security Best Practices

1. Do not run containers as the root user:

USER node

2. Regularly update base images to get security patches

3. Scan images for vulnerabilities:

docker scan koa2-demo

4. Limit container resource usage:

docker run --memory=512m --cpus=1 -p 3000:3000 -d koa2-demo

Monitoring and Log Collection

Configure log drivers to send container logs to centralized logging systems:

docker run --log-driver=syslog --log-opt syslog-address=udp://logserver:514 -p 3000:3000 -d koa2-demo

Use Prometheus to monitor container metrics:

HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:3000/metrics || exit 1

Continuous Integration/Continuous Deployment

Integrate Docker into CI/CD pipelines:

Example .gitlab-ci.yml:

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t koa2-demo .
    - docker run -d --name test koa2-demo
    - docker stop test

deploy:
  stage: deploy
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker push $CI_REGISTRY_IMAGE:latest