How to Deploy Strapi on the Vultr Kubernetes Engine

Introduction

Strapi is a headless Content Management System (CMS) that assists users to create and manage content for various platforms such as websites, web, and mobile applications. It offers a user-friendly UI admin dashboard that allows users to edit, delete or add content without prior technical knowledge. Users can also define content types and data structures providing more flexibility in content customization. Its seamless integration with third-party tools allows users to connect with different front-end frameworks, databases, and third-party services.

Strapi can handle large amounts of content and serve it to a growing number of users, which makes it suitable to deploy on a Kubernetes cluster for scalability and deployment in multiple environments. It also provides role-based authentication and user permissions to ensure that only authorized individuals can access or modify your content making it a secure application to run in a cluster.

This article explains how to deploy a Strapi application, containerize, deploy, and scale it on a Vultr Kubernetes Engine (VKE) cluster.

Prerequisites

Before you begin, you should:

• Deploy a Vultr Kubernetes Engine cluster.
• Set up a domain record. This article uses strapi.example.com, replace all occurrences with your actual domain.
• Deploy a Vultr Managed Database for PostgreSQL.
• Deploy a OneClick Docker instance from the Vultr Marketplaceto use as the management machine.
  • Use SSH to access the management machine as a non-root sudo user.
  • Install Kubectl on the server.
• Download your VKE cluster configuration file and configure Kubectl to connect to the cluster.

Build a Strapi Application

1. Add the Node.js repository to the server.

    $ curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -  

2. Install Node.js

    $ sudo apt install nodejs

3. Using the npx utility, create a new project.

    $ npx create-strapi-app@latest strapi-project 

   The above command creates a new Strapi application called strapi-project. Then installs the latest version of the create-strapi-app package. The package creates the necessary structure and installs all necessary dependencies.

   When prompted, press enter to Choose Quickstart as your installation type.

   Once installation is complete, press CTRL + C to stop the server and configure other application values.

4. Change to the project directory.

    $ cd strapi-project

Containerize the Strapi Application

In this section, configure your Strapi application to use a Vultr Managed Database for PostgreSQL, then set up an environment variable in the app's server file. Additionally, build the app's docker container image to deploy it on the Kubernetes cluster as described below.

1. Back up the original config/database.js file.

    $ mv config/database.js config/database.ORIG

2. Using a text editor such as nano, re-create the file.

    $ nano config/database.js

3. Add the following configurations to the file.

           module.exports = ({ env }) => ({
               connection: {
                   client: 'postgres',
                   connection: {
                       host: env('DATABASE_HOST', 'postgres.vultrdb.com'),
                       port: env.int('DATABASE_PORT', 5432),
                       database: env('DATABASE_NAME', 'default'),
                       user: env('DATABASE_USERNAME', 'user'),
                       password: env('DATABASE_PASSWORD', 'password'),
                       schema: env('DATABASE_SCHEMA', 'public'), // Not required
                       ssl: {
                           rejectUnauthorized: env.bool('DATABASE_SSL_SELF', false),
                       },
                   },
                   debug: false,
                },
               });

   Save and close the file.

   The above configuration defines the database connection details for the PostgreSQL database. Replace postgres.vultrdb.com, 5432, user, and password with your actual database details.

4. Back up the original config/server.js file.

    $ mv config/server.js config/server.ORIG

5. Re-create the file.

    $ nano config/server.js

6. Add the following configurations to the file.

     module.exports = ({ env }) => ({
           host: env('HOST', '0.0.0.0'),
           port: env.int('PORT', 1337),
           url: env('STRAPI_URL'),
           app: {
             keys: env.array('APP_KEYS'),
           },
           webhooks: {
             populateRelations: env.bool('WEBHOOKS_POPULATE_RELATIONS', false),
           },
         });

   Save and close the file.

   The above code exports a configuration object that sets the host, port, url, and webhooks settings for the Strapi application. It also retrieves values from the environment variable.

7. Define the STRAPI_URL environment variable.

    $ export STRAPI_URL="http://127.0.0.1:1337"

   The above command sets the environment variable STRAPI_URL to the localhost Strapi server and port.

8. Install the PostgreSQL library for Node.js to enable the database connection.

    $ npm install pg --save

9. Rebuild the package.

    $ npm run build

   The above command runs the app's build script to incorporate all changes to the files.

10. Start the application in the background.

     $ npm run start &

The above command starts the application in the production environment state. To verify that the Strapi Application runs correctly. Load port 1337 using your Server IP in a web browser.

    http://192.0.2.100:1337

The Strapi dashboard should appear with a login screen appears to create the first administrator.

Create the Docker Image

1. Within the project directory, create a new Dockerfile.

    $ nano Dockerfile

2. Add the following contents to the file.

    FROM node:16-alpine
   
    RUN apk update && apk add --no-cache build-base gcc autoconf automake zlib-dev libpng-dev nasm bash vips-dev
    ARG NODE_ENV=development
    ENV NODE_ENV=${NODE_ENV}
   
    WORKDIR /opt/
    COPY package.json package-lock.json ./
    RUN npm install
    ENV PATH /opt/node_modules/.bin:$PATH
   
    WORKDIR /opt/app
    COPY . .
    RUN chown -R node:node /opt/app
    USER node
    RUN ["npm", "run", "build"]
   
    EXPOSE 1337
   
    CMD ["npm", "run", "start"]

   Save and close the file.

   The above instructions inherit the base as node:16-alpine. It installs various dependencies necessary for the application. It uses /opt/app as a working directory and copies the package.json and the package-lock.json and installs the dependencies using npm install.

   The configuration exposes the Strapi port 1337 which is the default port used by Strapi, then starts the server using the npm run start command.

3. Create a file named .dockerignore.

    $ nano .dockerignore

   The .dockerignore file declares a list of files and directories to ignore while building the image.

4. Add the following content to the file

    node_modules/

   The above directive prevents duplication of libraries installed on the host machine and lets Docker install all libraries under the dependencies section.

5. Log in to your DockerHub account.

    $ docker login

   Enter your DockerHub username and password when prompted. To create a new username, visit the DockerHub registry.

6. Build the Docker image.

    $ docker build -t example-user/strapi:latest .

7. Push the image to DockerHub.

    $ docker push example-user/strapi:latest

Prepare the Kubernetes Cluster

You must prepare the Kubernetes cluster for deploying the Strapi application by installing the required plugins and creating a few resources. This section demonstrates the steps to install the ingress-nginx controller, install the cert-manager plugin, and create a ClusterIssuer resource for issuing Let's Encrypt certificates.

Before Installing the Strapi application, prepare the Kubernetes cluster with the necessary plugins and resources as described in this section.

• Install Nginx Ingress Controller.

1. Install CertManager to issue SSL certificates.

    $ kubectl apply -f <https://github.com/cert-manager/cert-manager/releases/download/v1.12.2/cert-manager.yaml>

2. Get the load balancer IP address.

    $ kubectl get services/ingress-nginx-controller -n ingress-nginx

   Output:

    NAME                       TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)                      AGE
    ingress-nginx-controller   LoadBalancer   10.103.190.245   192.0.2.102     80:30420/TCP,443:30061/TCP   7m37s

   The load balancer may take up to 10 minutes to get ready. You can verify the load balancer deployment by opening the cluster page in your customer portal and navigating to the Linked Resources tab. Set up your domain A record for strapi.example.com to point to the load balancer's IP Address.

3. Create a new manifest named clusterissuer.yaml.

    $ nano clusterissuer.yaml

4. Add the following contents to the file.

         apiVersion: cert-manager.io/v1
         kind: ClusterIssuer
         metadata:
             name: letsencrypt-prod
         spec:
             acme:
                 server: <https://acme-v02.api.letsencrypt.org/directory>
                 email: "<hello@example.com>"
                 privateKeySecretRef:
                     name: letsencrypt-prod
                 solvers:
                     - http01:
                          ingress:
                             class: nginx

   Save and close the file.

   The above configuration creates a ClusterIssuer resource for issuing Let's Encrypt certificates. It uses the HTTP01 challenge solver to verify the ownership. Replace hello@example.com with your actual email address.

5. Apply the Issuer to the cluster.

    $ kubectl apply -f clusterissuer.yaml

6. Verify the deployment.

    $ kubectl get clusterissuer letsencrypt-prod

   Output:

    NAME               READY   AGE
    letsencrypt-prod   True   8m27s

Deploy the Strapi Application

1. Create a new deployment file strapi-deployment.yaml.

    $ nano strapi-deployment.yaml

2. Add the following configurations to the file.

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: strapi-deployment
     spec:
       replicas: 2
       selector:
         matchLabels:
           name: strapi-app
       template:
         metadata:
           labels:
             name: strapi-app
         spec:
           imagePullSecrets:
             - name: regcred
           containers:
             - name: strapi
               image: example-user/strapi:latest
               imagePullPolicy: Always
               command: ["npm", "run", "build", "&&", "npm", "run", "develop"]
               ports:
                 - containerPort: 1337
               env:
                 - name: STRAPI_URL
                   value: "strapi.example.com"

   Save and close the file.

   The above configuration creates a Deployment resource:

   • It creates 2 initial pods with the container image you built, and the pods have the label strapi-app.
   • It uses the regcred secret resource to fetch the credentials. Replace the image example-user/strapi:latest with your actual repository.
   • Replace strapi.example.com with your actual domain pointing to the cluster load balancer.

3. Create the deployment.

    $ kubectl apply -f strapi-deployment.yaml

4. Verify the deployment

    $ kubectl get deployment strapi-deployment

   Output:

      NAME                READY   UP-TO-DATE   AVAILABLE   AGE
      strapi-deployment   1/2     2            1           20m

5. Create a new service manifest.

    $ nano strapi-service.yaml

6. Add the following configurations to the file.

         apiVersion: v1
         kind: Service
         metadata:
             name: strapi-service
         spec:
             ports:
               - name: http
                 port: 80
                 protocol: TCP
                 targetPort: 1337
             selector:
               name: strapi-app

7. Apply the Service.

    $ kubectl apply -f strapi-service.yaml

8. Create a new Ingree Manifest.

    $ nano strapi-ingress.yaml

9. Add the following configurations to the file.

     apiVersion: networking.k8s.io/v1
     kind: Ingress
     metadata:
       name: strapi-ingress
       annotations:
         kubernetes.io/ingress.class: nginx
         cert-manager.io/cluster-issuer: letsencrypt-prod
     spec:
       tls:
         - secretName: strapi-tls
           hosts:
             - strapi.example.com
       rules:
         - host: strapi.example.com
           http:
             paths:
               - path: /
                 pathType: Prefix
                 backend:
                   service:
                     name: strapi-service
                     port:
                       number: 80

   Save and close the file.

   The Ingress resource allows external access to the strapi-service resource. It uses the cluster issuer resource letsencrypt-prod to issue a new SSL certificate for strapi.example.com and store it as a secret resource strapi-tls.

10. Apply the Ingress resource.

     $ kubectl apply -f strapi-ingress.yaml

11. Verify the Ingress resource.

     $ kubectl get ingress

    Output:

    NAME             CLASS    HOSTS                  ADDRESS          PORTS     AGE
    strapi-ingress   <none>   strapi.onlustech.com   192.0.2.100   80, 443   10m

12. In a web browser, visit the Strapi application and verify that you can access the Strapi Application over HTTPS.

     https://strapi.example.com

Scale the Strapi Deployment

Scaling the Strapi application makes it efficient to handle large loads of traffic without any interruption or downtime. In this section, scale the Strapi deployments by increasing the number of replicas.

1. Increase the number of running replicas.

    $ kubectl scale deployment/strapi-deployment --replicas=4

   The above command increases the number of running replicas to 4.

2. Check the deployment status.

    $ kubectl get deployment strapi-deployment

   Output:

      NAME                READY   UP-TO-DATE   AVAILABLE   AGE
      strapi-deployment   0/4     4            0           29m

3. View available Pods.

    $ kubectl get pods

4. Decrease the number of pods.

    $ kubectl scale deployment/strapi-deployment --replicas=2

You can also run the kubectl delete pod command to do a fault tolerance check. Kubernetes detects changes that occur by the command and automatically creates a new pod instantly. New pods are then detected by the ingress resource which starts serving requests instantly.

Conclusion

In this article, you created an example Strapi application using the Strapi API with PostgreSQL configuration along with its containerization, deployment, and scaling. You also configured CertManager to issue Let's Encrypt certificates and the Nginx Ingress controller to allow external access to cluster services.

Strapi focuses on efficient content management via a web interface without the need for technical knowledge which makes it to build low-code or no-code backends. For more information, visit the following resources.

• Strapi API reference.
• Strapi Docker documentation.