Headless CMS

Definitions & benefits

Tools & Concepts

Open source

Features

Authentication

Custom plugins & Marketplace

Webhooks

Multilingual CMS

APIs

Dynamic Zones

User roles & permissions

Content Modeling

Security & Privacy

Use Cases

Ecommerce

Blog

Forum

About Strapi

Life at Strapi

Releases & Roadmap

Events

Community

News

The Tutorials section covers an introduction to Strapi, some advanced technical content, product updates and releases. From basic workaround to in-depth development guides. 

Tutorials

How tos

Get all the latest updates, news and events.

Subscribe to the newsletter 📣

This tutorial provides a step-by-step guide for deploying a Strapi application using Dokku and DigitalOcean. 

This tutorial covers everything from installing Dokku and creating a new app to configuring SSL with Let's Encrypt and setting up auto-deployment on GitHub. Following these instructions, you can deploy and manage web applications, databases, and other services on your servers or cloud providers like DigitalOcean.

[![Strapi Cloud Trial](/uploads/Strapi_Cloud_CTA_2b6a7deb9a.png)](https://strp.cc/43tg9Si)

## What is Dokku?

Dokku is a Docker-powered PaaS that helps you build and manage the lifecycle of applications. It is designed to be a lightweight and simple alternative to Heroku. 

You can think of it as a self-hosted Heroku that you can deploy on your own infrastructure. With Dokku, you can easily deploy and manage web applications, databases, and other services on your own servers or cloud providers like DigitalOcean.

> **Note**: To give some heads-up, if you are looking for cheap hosting, we know it works. Simen would recommend Contabo. The server comes with the following: 
> - 200GB SSD Space or 50 GB NVMe
> - 8GB RAM
> - Four vCPU Cores
> 
> Affiliate Link [here](https://contabo.com/en/vps/vps-s-ssd/?image=ubuntu.267&qty=1&contract=1&storage-type=vps-s-200-gb-ssd). This is not recommended by Strapi but personally by Simen Daehlin.     

## 👷‍♀️ Prerequisites

- **Strapi Project**
- min **2GB** Ram (4GB+ Recommended)

## 🥷 Server Setup

Sure thing! Here's a step-by-step guide for setting up a droplet on **DigitalOcean**:

1. Log in to your DigitalOcean account and click on the ***Create*** button in the top right corner of the dashboard.
2. Select **Droplets** from the dropdown menu.
3. Choose a hostname for your droplet.
4. Select the size of your droplet. Strapi does recommend a ***min** of 2GB of RAM. Dokku itself requires min of 1GB of RAM*
5. Choose a data center region closest to your target audience.
6. Select ***Ubuntu 22.04 LTS*** as your droplet's operating system. (Important here is not to use xx.10 as it won’t work)
7. Choose any additional options you need, such as backups or monitoring.
8. Click ***Create Droplet*** to finalize your settings and create your droplet.

Once your droplet is created, you can access it via SSH and set up your server. Let me know if you have any other questions!

### 🔐 Important About SSH

> **Note**: Please note that to use Dokku, we need an SSH Key. If you don’t have one, please make sure you create one. You can find out how to do it here.
> [Windows](https://www.howtogeek.com/762863/how-to-generate-ssh-keys-in-windows-10-and-windows-11/)
> [MAC / Linux](https://www.digitalocean.com/community/tutorials/how-to-set-up-ssh-keys-on-ubuntu-20-04) (Unix)
    
**<a name="back-1"> ⚠️ Please note that the commands here assume you are SSH’ed into the box itself. </a>**


## 🐳 Install Dokku

To install Dokku, you can use a one-line command provided in the official Dokku documentation. SSH into your server and run the following command:

```bash
wget -NP . https://dokku.com/bootstrap.sh
sudo DOKKU_TAG=v0.30.9 bash bootstrap.sh
```

This command will download and run the **Dokku** installation script, which will install **Dokku** on your server. Make sure you have [about SSH](#back-1) to your server before proceeding with the installation.

Once the installation is complete, you can access the **Dokku** web interface by navigating to `http://your-server-ip` in your browser. From there, you can configure your server and deploy your applications.

Now, please ensure you have your SSH at hand, as we need this.

```bash
PUBLIC_KEY="your-public-key-contents-here"
echo "$PUBLIC_KEY" | dokku ssh-keys:add admin
```

### 🍏 Creating an Application

To create a new app named `mystrapi`, run the following command in your **Dokku** server:

```bash
dokku apps:create mystrapi
```

### 💾 Creating Postgres database

```bash
sudo dokku plugin:install https://github.com/dokku/dokku-postgres.git
```

Once the plugin is installed, create a new PostgreSQL instance named "strapi" by running:

```bash
dokku postgres:create strapi
```

To link the PostgreSQL instance to your app, run the following command:

```bash
dokku postgres:link strapi mystrapi
```


> ⚠️ Please take note of the username and password that get printed out, and save them if we need them for later. 
The line you are looking for is DSN, and it’s written like so
”postgres://DATABASE_USERNAME:DATABASE_PASSWORD@DBHOST:DATABASE_PORT/DATABASE_NAME”


## ⚙️ Configure Dokku and Strapi Environmental Variables

This is a `oneline` code for you to set **HOST, PORT, APP_KEYS, API_TOKEN_SALT, ADMIN_JWT_SECRET, JWT_SECRET**

```bash
dokku config:set mystrapi HOST=0.0.0.0 PORT=1337 APP_KEYS="$(for i in {1..3}; do openssl rand -base64 16; done | tr '\n' ',')" API_TOKEN_SALT=$(openssl rand -base64 32) ADMIN_JWT_SECRET=$(openssl rand -base64 32) JWT_SECRET=$(openssl rand -base64 32)
dokku config:set mystrapi DATABASE_USERNAME=INSERT FROM OUTPUT ABOVE DATABASE_PASSWORD=INSERT FROM OUTPUT ABOVE DATABASE_PORT=INSERT FROM OUTPUT ABOVE DATABASE_HOST=INSERT FROM OUTPUT ABOVE DATABASE_NAME= INSERT FROM OUTPUT ABOVE
```

### 🌎 Optional: Setup Domain

Next, you need to set up a domain for your app. Run the following command to add a domain:

```bash
dokku domains:set-global example.com
dokku domains:add mystrapi backend.example.com
```

Replace "[example.com](http://example.com/)" with your desired domain name.

### 🔐 Setting up SSL and Let’s Encrypt

To configure Let's Encrypt for your app, you need to install the Let's Encrypt plugin by running:

```bash
sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git
```

Once the plugin is installed, you can enable Let's Encrypt for your domain by running the following command:

```bash
dokku letsencrypt:set --global email <your-email>
dokku letsencrypt:enable mystrapi
dokku letsencrypt:cron-job --add
```

**Replace `<your-email>` with your email address.**

That's it! You have now created a **new app**, installed **PostgreSQL**, linked it to your app, added a **domain**, and configured **Let's Encrypt**. You can now deploy your app by pushing your code to your Dokku server.

### 🚒 Configure the Proxy

When you deploy Strapi using Dokku, it is important to note that Dokku uses a proxy to route requests to the correct port on the container (remember, each **app** is a container in Dokku). Strapi uses port ***1337***, so to use Strapi with Dokku, we need to configure the proxy to route ports ***80*** and ***443*** to port ***1337***.

To do this, we can use the `dokku proxy:set` command with the appropriate arguments. Specifically, we need to specify the name of our app on Dokku and the ports that we want to proxy to port ***1337***. The command to configure the proxy for Strapi would look like this:

```
dokku proxy:set mystrapi http:80:1337 https:443:1337
```

Here, `mystrapi` should be replaced with the name of your app on Dokku. Once this command is executed successfully, Dokku will route requests from ports 80 and 443 to port 1337

## 🚀 Auto Deployment with git

1. Create a new file in your repository called `.github/workflows/deployment.yml` with the following contents:
    
```bash
    name: Deployment
    on:
      push:
        branches: [main]
    jobs:
      build:
        name: Deploy to Dokku
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v2
            with:
              fetch-depth: 0
          - name: Dokku Deployment
            uses: dokku/github-action@master
            with:
              git_remote_url: "ssh://dokku@${{ secrets.HOST }}:22/APPNAME"
              ssh_private_key: ${{ secrets.SECRET }}
              git_push_flags: "--force"
            env:
              BUILDER_ENV: production
```
    
Replace `APPNAME` with the name of your app on Dokku.
    
2. To add the `SECRET` and `HOST` secrets, go to your repository on GitHub and click on **Settings** > **Secrets** > **New repository secret**. For ***Name***, enter `SECRET`. For ***Value***, paste in your SSH private key. Repeat the process for the `HOST` secret, with the value being the ***IP address*** or ***domain name*** of your Dokku server.o add the SSH private key to Dokku, SSH into your server and run the following command

### 👔 Manually Push to Dokku

You can do the following if you don’t want to automate the deployment and just push.

1. In your Strapi project, add the Dokku server as a repo.

```bash
git remote add dokku ssh://dokku@IP-ADDRESS-OR-DOMAIN-TO-DOKKU:22/APPNAME
git push dokku
```

Or you can use git sync if you already have a public repo. This will have Dokku PULL directly from GitHub or other repositories.

> ⚠️ Please note: The repo has to be public

```bash
dokku git:sync --build mystrapi https://github.com/GITHUBUSERNAME/REPONAME.git
```

Now the last bit we need to do is that GitHub changed branches a few years ago from **master** to **main,** so we must tell Dokku that we want to adhere to this.

```bash
dokku git:set --global deploy-branch main
```

You can also remove `--global` and set it per app if you use a different branch.

## 🐳 Using Our Own Dockerfile *(Optional)*

As you noticed, people might have issues. We also cover setting up Docker to use your Dockerfile instead of using `herokuish`. Using a Docker file means we know the environment that gets created always will be the same and won’t change.

Creating a Dockerfile to use with Strapi is quite easy with [Strapi Community Dockerize Tool](https://github.com/strapi-community/strapi-tool-dockerize).

1. In your project, run `npx @strapi-community/dockerize@latest`
2. Select your Package Manager `yarn / npm`
3. Select **NO** to use `docker-compose`
4. Select **Production**
5. Done 🎉

Now that we created the Dockerfile, we can tell Dokku that we want it to build for this project.

In your **Dokku server again**

```bash
dokku builder-dockerfile:set mystrapi Dockerfile.prod
```

This tells Dokku to look for a prod file. If you only have a Dockerfile, you don’t need to specify it. Dokku is smart enough to auto-detect it.

### 👷‍♂️Dockerfile Build Arguments

As our `Dockerfile` we want to specify the build argument like `NODE_ENV`. We can tell it to always build for production or override it to whatever we want.
We run the following command on the server

```bash
dokku docker-options:add mystrapi build '--build-arg NODE_ENV=production'
```

If you previously used the guide and tried to deploy with `herokuish` we need to RESET it to use Docker. 

First, let’s get the build pack URL that was set.

```bash
dokku buildpacks:report mystrapi
```

Then let's remove it, you are looking for Buildpacks list and copy the URL: 

```bash
dokku buildpacks:remove mystrapi INSERT URL FROM BUILDPACKS ABOVE
// Example
dokku buildpacks:remove mystrapi https://github.com/heroku/heroku-buildpack-nodejs.git
```

When you now deploy, it should use a Dockerfile instead of `herokuish`. Please check their documentation on this [here](https://dokku.com/docs/deployment/builders/dockerfiles/). 

## 🎁 Wrap up

This tutorial taught you how to deploy a Strapi application using Dokku and DigitalOcean. Dokku is a Docker-powered PaaS that helps you build and manage the lifecycle of applications. 

We covered how to install Dokku, create a new app, install PostgreSQL, link it to your app, add a domain, configure SSL with Let's Encrypt, configure the proxy, and set up auto-deployment on GitHub. 

We also provided instructions for manually pushing to Dokku. With this knowledge, you can easily deploy and manage web applications, databases, and other services on your own servers or cloud providers like DigitalOcean.

Overall, deploying a Strapi application using Dokku and DigitalOcean is a straightforward process that can be completed in just a few steps. By following the steps outlined in this tutorial, you can set up a scalable, reliable, and secure server for your Strapi application.

This tutorial covers everything from installing Dokku and creating a new app to configuring SSL with Let's Encrypt and setting up auto-deployment on GitHub. Following these instructions, you can deploy and manage web applications, databases, and other services on your servers or cloud providers like DigitalOcean.

How to Deploy Strapi on Dokku and DigitalOcean

medium_How to Deploy Strapi on Dokku and DigitalOcean.png

small_How to Deploy Strapi on Dokku and DigitalOcean.png

thumbnail_How to Deploy Strapi on Dokku and DigitalOcean.png

How to Deploy Strapi on Dokku and DigitalOcean.png

London

Simen came from our Community and now working as a Solutions Engineer. Vivid PlayStation Trophy Hunter by night and loves anything with Pokemon.

User Success

As an open-source Headless CMS, Strapi provides many deployment options from traditional hosting servers or your preferred hosting provider. 

It was recently announced the [Strapi Cloud beta program](https://strapi.io/blog/announcing-strapi-cloud-beta), a hosted Content Management platform. Strapi announced when will be available and more about what is coming. So if you don't want to deploy Strapi by yourself, join the [waitlist](https://strapi.io/cloud) to soon access the easiest way to host your Strapi application and get additional benefits! 

In the meantime, the Strapi developer documentation includes several step-by-step how-to guides for deploying Strapi on the most popular hosting providers: 

- [Deploying on AWS EC2](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/amazon-aws.html)
- [Deploying on Azure](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/azure.html)
- [Deploying on DigitalOcean App Platform](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/digitalocean-app-platform.html)
- [Deploying on DigitalOcean Droplets](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/digitalocean.html)
- [Deploying on GCP's App Engine](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/google-app-engine.html)
- [Deploying on Heroku](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/deployment/hosting-guides/heroku.html)

Another option is to use Docker to facilitate the deployment to various cloud providers, or Kubernetes managed services such as [Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html), [Microsoft AKS](https://learn.microsoft.com/en-us/azure/aks/), or others. 

In this post, we'll take a closer look at what Docker is. Learn how to build custom Docker containers with an existing Strapi project and introduce an open-source community tool called Dockerize, which can assist you in deploying Strapi to various cloud providers using Docker. 

## What are Docker and Docker Compose? 

If you need to become more familiar with Docker and Docker Compose, check out [this article](https://strapi.io/blog/what-is-docker-compose-all-you-need-to-know) to learn more about it and how it can help ship your applications to your favorite Cloud providers. 

## Run Strapi in a Docker Container

Strapi does not build any official container images because you can build many different types of applications for various use cases using Strapi. However, we provide [Docker documentation for Strapi](https://docs.strapi.io/developer-docs/latest/setup-deployment-guides/installation/docker.html) as a courtesy to the community. 

## What is Dockerize?

Dockerize is a CLI tool built by [Simen Daehlin](https://twitter.com/eventyret), Strapi Community Organization Member. 

This tool aims to simplify the life of developers who want to deploy Strapi with Docker. After the user answers some questions, it will generate files for their Strapi project.

It's a simple one-time run tool that will generate a `Dockerfile, Dockerfile.prod` (if you choose production or both), and `docker-compose`. All ready to go and configured to the user's needs.

This tool makes development and deploying with docker super simple, run the tool, answer questions, and off you go to the races! Under the hood, the tool will consider what database is wanted and currently supporting: MariaDB, MySQL, and PostgreSQL.

It will auto-detect `YARN` or `NPM` and use the tool according to what is being used by the project. It generates and backs up `database.js/ts` for you if this is detected and generates config environment folders with files for you.

Last but not least, it also generates values that have been asked for your `.env` file, which docker-compose can use. It also has CLI integration by passing CLI Flags so other CLI tools can work with it.

## Strapi Dockerize Roadmap

Currently, I am working on changes to `server.js/ts` where we can inject and set up CORS as this seems to be a known issue for users. And detect if the project is a Strapi project; if not, we will start the Strapi CLI to simplify things for a user.

## Why did I build this tool?

I started work on this as there needed to be more info about Strapi and Docker. In Strapi v3, an [official Docker image of Strapi](https://hub.docker.com/r/strapi/strapi/) was downloaded more than 10M times. It was "a nice to have" for many people in the Strapi Community, yet not a good fit for many people who needed to customize their images. 

Dockerize gives developers the power to customize their images to their applications' needs and requirements. This also enhances security and saves Strapi as a company from maintaining a docker image, as each user can create their own image.

I wrote a blog post on how to [dockerize Strapi v4 for development](https://blog.dehlin.dev/docker-with-strapi-v4), and after 40k visits, I realized that there was definitely a need for a tool to automate some of the work. 

As a result, [Deployify](https://github.com/strapi-community/strapi-tool-deployify) was born with the help of other developers. Making a simple tool to deploy Strapi to the cloud. I'm thrilled that this has become people's standard when using templates in Docker for images! 🧑‍🚀 

## Host on Strapi Cloud

The Strapi experience has always been about flexibility, customization, and open-source innovation. But we understand that managing infrastructure and scaling your application can sometimes be a daunting task, diverting your focus from what you do best: developing web experiences.

That's why we're excited to introduce **[Strapi Cloud](https://strapi.io/cloud)**, so you can leverage the same robust Strapi capabilities you love, but without the hassle of managing servers, worrying about uptime, or scaling infrastructure as your project grows. It will allow you to future-proof your apps with a CMS that meets the content management needs of all your stakeholders, no matter your use case, services or devices. 

Strapi remains committed to open-source values, and self-hosting will always be a viable option. We believe in offering choices that align with your project's unique needs. Strapi Cloud is an additional resource for those who want to focus solely on development, leaving the infrastructure to us.

Aw are here to support you every step of the way, no matter which hosting option you choose. You can reach out to us and the community on our [Discord](https://discord.strapi.io/) if you have any questions!

Take a closer look at what Docker is, discover how to build custom Docker containers with an existing Strapi project, and learn about an open-source community tool called Dockerize. 

The Ecosystem section covers everything related to the world of Headless CMS and Strapi's place in it. 