Canary Releases with Express.js

Introduction

In the world of software development, deploying new features without causing disruptions is a common challenge. One effective strategy to achieve this is by using canary releases. A canary release is a deployment strategy where a small percentage of users are exposed to new features before they are rolled out to everyone. This approach allows developers to gather feedback and make necessary adjustments before the feature becomes widely available.

In this tutorial, we will explore how to implement canary releases for Express.js applications using Continuous Integration/Continuous Deployment (CI/CD) pipelines. We'll use popular tools like GitHub Actions and Kubernetes to manage deployments.

Concept

The concept of canary releases involves deploying a new version of your application to a subset of users while the rest continue to use the stable version. This allows you to monitor the performance and stability of the new features without affecting all your users.

To implement this in an Express.js application, we will:

1. Set up a CI/CD pipeline using GitHub Actions.
2. Deploy canary releases to a Kubernetes cluster.
3. Route traffic to the canary version based on user segments or randomly.

Examples

Step 1: Set Up Your Express.js Application

First, ensure you have an Express.js application set up. Here's a simple example:

1const express = require('express');
2const app = express();
3 
4app.get('/', (req, res) => {
5res.send('Hello World!');
6});
7 
8app.listen(3000, () => {
9console.log('Server is running on port 3000');
10});

Step 2: Create a GitHub Repository

Push your Express.js application to a GitHub repository. This will be used by GitHub Actions for CI/CD.

$ git init
$ git add .
$ git commit -m "Initial commit"
$ git branch -M main
$ git remote add origin https://github.com/yourusername/express-app.git
$ git push -u origin main

Step 3: Set Up GitHub Actions for CI

Create a .github/workflows/ci.yml file in your repository to define the CI pipeline:

1name: CI
2 
3on:
4push:
5  branches: [ main ]
6pull_request:
7  branches: [ main ]
8 
9jobs:
10build:
11  runs-on: ubuntu-latest
12 
13  steps:
14  - uses: actions/checkout@v2
15  - name: Use Node.js
16    uses: actions/setup-node@v2
17    with:
18      node-version: '14'
19  - run: npm install
20  - run: npm test

Step 4: Set Up Kubernetes for Deployment

Create a k8s directory in your repository and add the following files:

k8s/deployment.yaml

1apiVersion: apps/v1
2kind: Deployment
3metadata:
4name: express-app
5spec:
6replicas: 3
7selector:
8  matchLabels:
9    app: express-app
10template:
11  metadata:
12    labels:
13      app: express-app
14  spec:
15    containers:
16    - name: express-app
17      image: yourusername/express-app:latest
18      ports:
19      - containerPort: 3000

k8s/service.yaml

1apiVersion: v1
2kind: Service
3metadata:
4name: express-app-service
5spec:
6selector:
7  app: express-app
8ports:
9  - protocol: TCP
10    port: 80
11    targetPort: 3000
12type: LoadBalancer

Step 5: Deploy to Kubernetes

Create a GitHub Actions workflow for deploying canary releases:

1name: Canary Deployment
2 
3on:
4push:
5  branches:
6    - main
7 
8jobs:
9deploy-canary:
10  runs-on: ubuntu-latest
11  steps:
12  - uses: actions/checkout@v2
13  - name: Set up Docker Buildx
14    uses: docker/setup-buildx-action@v1
15  - name: Log in to Docker Hub
16    uses: docker/login-action@v1
17    with:
18      username: ${{ secrets.DOCKER_USERNAME }}
19      password: ${{ secrets.DOCKER_PASSWORD }}
20  - name: Build and push Docker image
21    run: |
22      docker build -t yourusername/express-app:latest .
23      docker push yourusername/express-app:latest
24  - name: Deploy to Kubernetes
25    uses: kubernetes-deploy/action@v2.1.0
26    with:
27      kubeconfig: ${{ secrets.KUBECONFIG }}
28      manifests: 'k8s/deployment.yaml, k8s/service.yaml'
29      strategy: canary
30      replicas: 1

Step 6: Route Traffic to Canary

To route traffic to the canary version, you can use a service mesh like Istio or configure your load balancer to direct a percentage of requests to the new deployment.

For example, with Istio:

1apiVersion: networking.istio.io/v1alpha3
2kind: VirtualService
3metadata:
4name: express-app-vs
5spec:
6hosts:
7- express-app-service
8http:
9- route:
10  - destination:
11      host: express-app-service
12      subset: canary
13    weight: 10
14  - destination:
15      host: express-app-service
16      subset: stable
17    weight: 90

1apiVersion: networking.istio.io/v1alpha3
2kind: DestinationRule
3metadata:
4name: express-app-dr
5spec:
6host: express-app-service
7subsets:
8- name: canary
9  labels:
10    version: canary
11- name: stable
12  labels:
13    version: stable

Step 7: Monitor and Roll Out

Monitor the performance of the canary release using tools like Prometheus and Grafana. If everything looks good, you can gradually increase the traffic to the canary version until it becomes the default.

What's Next?

After mastering canary releases, you might want to explore advanced logging techniques for Express.js applications. This will help you gain deeper insights into your application's behavior and performance.

Stay tuned for more tutorials on building robust and scalable Express.js applications!