
## Introduction

[Redis](https://redis.io/) is a powerful in-memory storage technology often used a key-value store, caching layer, and message broker. It is a key component in many application architectures due to its speed, flexibility, and ease-of-use.

In this guide, we will go over how to deploy and configure Redis to act as a data store for applications on Koyeb. We will deploy Redis to Koyeb as a private web service, meaning the instance will only be accessible to other applications using the [service mesh](/docs/reference/service-mesh-and-discovery). Afterwards, we will demonstrate how to connect to it from a companion service.

You can deploy the Redis instance by clicking the [Deploy to Koyeb button](/docs/build-and-deploy/deploy-to-koyeb-button) below:

[![Deploy to Koyeb](https://www.koyeb.com/static/images/deploy/button.svg)](https://app.koyeb.com/deploy?type=docker&image=redis&ports=6379;tcp&name=redis-on-koyeb)

## Requirements

To successfully follow and complete this guide, you need:

- A [Koyeb account](https://app.koyeb.com) to deploy and configure Redis.

## Steps

To complete this guide and deploy a Redis instance for your applications, you'll need to follow these steps:

1. [Deploy the Redis server on Koyeb](#deploy-the-redis-server-on-koyeb)
2. [Deploy a Redis client](#deploy-a-redis-client)
3. [Test the Redis server](#test-the-redis-server)

## Deploy the Redis server on Koyeb

The simplest way of to deploy Redis on Koyeb is to use the [Redis Docker image](https://hub.docker.com/_/redis).

To begin, navigate to the **Overview** tab of the [Koyeb control panel](https://app.koyeb.com/), click **Create Service** to begin:

1. Select **Private service** as the service type and then click **Create private service**. This service type allows other Koyeb applications to access the Redis using the [service mesh](/docs/reference/service-mesh-and-discovery) rather than exposing the service publicly.
2. Select **Docker** as the deployment source and click **Next**.
3. In the image field, type `docker.io/redis` to pull the latest Redis tag. To deploy a specific [Redis tag](https://hub.docker.com/_/redis/tags), append a colon (`:`) and the tag name to the end of the field. Click **Next** to continue.
4. Select your preferred [Instance type](/docs/reference/instances#instance-types) and [region](/docs/reference/regions#core-regions) and click **Next**.
5. In the **Exposed ports** section, change the **Port** value to **6379**.
6. Click **Deploy**.

Koyeb will pull the specified Redis Docker image and launch it using the provided configuration.

Once the deployment is complete and the Instance is healthy, click **Inspect and manage your service** to access the Service's **Overview** page. Find the **Private domain** value and click the associated **copy icon** to copy the Redis server's private domain name. It should use the following format:

```none /<YOUR_SERVICE_NAME>/ /<YOUR_APP_NAME>/ copy
<YOUR_SERVICE_NAME>.<YOUR_APP_NAME>.internal
```

<Admonition>
  Your private domain may also end in `.koyeb`. This domain format is currently being phased out in favor of
  the `.internal` domain format.
</Admonition>

Now that the Redis service is deployed, you can launch a second service to test it.

## Deploy a Redis client

To connect to the Redis service, we will launch another service to act as the client. You can use any [Redis library](https://redis.io/docs/latest/integrate/) to interact with your service.

For simplicity's sake, we will demonstrate by deploying the same Redis Docker image we used for the server in a different configuration. This time, instead of starting the Redis server process in the container, we will override the image's default command during deployment. We will configure this service as a worker so that we can use the bundled CLI client as needed.

To begin, return to the **Overview** tab of the [Koyeb control panel](https://app.koyeb.com/). Find your existing Redis service and click the **ellipsis** next to the App name. In the menu that appears, select **Add service**:

1. Select **Worker** as the service type and then click **Create worker service**. This service type is suitable for deployments that do not provide a network service.
2. Select **Docker** as the deployment source and click **Next**.
3. In the image field, type `docker.io/redis` to pull the latest Redis tag. To deploy a specific [Redis tag](https://hub.docker.com/_/redis/tags), append a colon (`:`) and the tag name to the end of the field. Click **Next** to continue.
4. Select your preferred [Instance type](/docs/reference/instances#instance-types). Deploy the new service to the same [region](/docs/reference/regions#core-regions) as your Redis server and click **Next**.
5. In the **Deployment** section, click the **Override** toggle associated with the **Command** field and enter `sleep`.
6. Click the **Override** toggle associated with the **Command args** field and enter `3600`. Together, these two settings override the default Redis server command and instead sleep for an hour. This ensures that a process will be running that won't exit during deployment.
7. Edit the **Service name** to ensure that the new service has a unique name.
8. Click **Deploy**.

Koyeb will pull the specified Redis Docker image and launch it using the provided configuration.

Once the deployment is complete and the Instance is healthy, click **Inspect and manage your service** to access the Service's **Overview** page.

## Test the Redis server

Once the worker service is up and running, visit the Service's **Overview** page. From there, click **Console** to connect to your Instance's shell.

In the web terminal window, press **Enter** to spawn a Bourne shell session or replace the shell with `/bin/bash` and press **Enter** to spawn a Bash session.

In the web terminal window, connect to your Redis server using the `redis-cli` command and the `-h` flag. Use the private domain of your Redis server that you copied earlier.

```bash copy
redis-cli -h <REDIS_SERVER_PRIVATE_DOMAIN>
```

The client will attempt to connect to the server at the given address and will start an interactive Redis session.

In the new session, verify that the connection was successful with the [Redis `PING` command](https://redis.io/docs/latest/commands/ping/):

```none copy
PING
```

The server should respond with `PONG` if everything is working as intended.

Next, check what keys are defined on the server:

```none copy
KEYS *
```

Because we have not yet added any keys, the server should respond with `(empty array)`. Define a new key-value pair by typing:

```none copy
SET test "Hello world"
```

If we check the keys again, a single key should be returned:

```none copy
KEYS *
```

This time the server responds with `1) "test"`. Retrieve the key's value by typing:

```none copy
GET test
```

The value should be returned as expected.

When you are finished testing your Redis server, exit the session by typing:

```none copy
QUIT
```

## Conclusion

In this guide, we demonstrated how to launch a Redis server on Koyeb using the Redis Docker image. We began by deploying Redis to Koyeb as a private web service exposed through the private network. Afterwards, we deployed a separate worker service in the same region to act as the Redis client. Using the client service, we connected to the Redis server and verified that it responded as expected.

To learn more about how to configure and use Redis, check out the [Redis documentation](https://redis.io/docs/latest/develop/) and explore the various [libraries and tools](https://redis.io/docs/latest/integrate/) available.


Learn how to set up Redis, the most popular in-memory key-value data store, to use with your Koyeb applications.

Deploy Redis as an In-Memory Database for Koyeb Applications

Deploy your full-stack web apps across continents and run on an edge network of 250 locations.

Global serverless deployments

In this guide, we demonstrate how to deploy and configure Infisical to help you manage secrets and other configuration for applications across your environments.

How to Deploy Infisical to Manage Application Secrets on Koyeb


## Introduction

[Directus](https://directus.io/) is an open data platform built to serve as a headless CMS, API, or Backend-as-a-Service (BaaS) for other applications. It is designed to make data accessible to people of all technical levels and to make it easy to build data-centric applications. Directus is extensible and can be integrated with many different frontend technologies to create stable, well-structured development and user experiences.

In this tutorial, we will show how to deploy Directus to Koyeb to enable you to build your own data backend. To ensure that our deployment is both scalable and resilient, we will configure Directus to use a number of accompanying components and services. We will deploy an external PostgreSQL database for long-term data persistence, an S3-compatible object storage bucket for storing uploads and images, and a Redis database for caching and to help our application stay in sync even when scaled to multiple instances.

You can deploy the application from this guide with [our Directus One-Click app](https://www.koyeb.com/deploy/directus) or by clicking the [Deploy to Koyeb button](/docs/build-and-deploy/deploy-to-koyeb-button) below:

[![Deploy to Koyeb](https://www.koyeb.com/static/images/deploy/button.svg)](https://app.koyeb.com/deploy?name=directus&type=docker&image=directus%2Fdirectus&instance_type=small&env%5BADMIN_EMAIL%5D=CHANGE_ME&env%5BADMIN_PASSWORD%5D=CHANGE_ME&env%5BCACHE_AUTO_PURGE%5D=true&env%5BCACHE_ENABLED%5D=true&env%5BCACHE_STORE%5D=redis&env%5BDB_CLIENT%5D=pg&env%5BDB_CONNECTION_STRING%5D=CHANGE_ME&env%5BKEY%5D=CHANGE_ME&env%5BPUBLIC_URL%5D=https://{{KOYEB_PUBLIC_DOMAIN}}&env%5BREDIS%5D=CHANGE_ME&env%5BSECRET%5D=CHANGE_ME&env%5BSTORAGE_S3_BUCKET%5D=CHANGE_ME&env%5BSTORAGE_S3_DRIVER%5D=s3&env%5BSTORAGE_S3_ENDPOINT%5D=CHANGE_ME&env%5BSTORAGE_S3_KEY%5D=CHANGE_ME&env%5BSTORAGE_S3_REGION%5D=CHANGE_ME&env%5BSTORAGE_S3_SECRET%5D=CHANGE_ME&env%5BSTORAGE_LOCATIONS%5D=s3&env%5BSYNCHRONIZATION_STORE%5D=redis&ports=8055%3Bhttp%3B%2F)

Be sure to modify all of the environment variables values set to `CHANGE_ME` to reflect your own data. You can consult the information in this guide if you need additional information.

## Requirements

To successfully follow and complete this guide, you need:

- A [Koyeb account](https://app.koyeb.com) to provision the PostgreSQL database and the Directus application.
- A [Backblaze B2](https://www.backblaze.com/cloud-storage) account to create an S3-compatible object storage bucket.
- An [Aiven Redis instance](https://aiven.io/redis) to cache data and synchronize between Directus instances. This is optional if you only plan on running a single Directus instance, but helps with performance and reliability.

## Steps

To complete this guide and deploy Directus, you'll need to follow these steps:

1. [Provision a PostgreSQL database on Koyeb](#provision-a-postgre-sql-database-on-koyeb)
2. [Provision a Backblaze B2 object storage bucket](#provision-a-backblaze-b2-object-storage-bucket)
3. [Provision a Redis instance on Aiven (Optional)](<#provision-a-redis-instance-on-aiven-(optional)>)
4. [Deploy Directus to Koyeb](#deploy-directus-to-koyeb)

## Provision a PostgreSQL database on Koyeb

Before we can deploy Directus, we need to provision a PostgreSQL database that we can use to persist application data including data collections, user data, and API configuration. We will use [Koyeb's PostgreSQL service](https://www.koyeb.com/docs/databases) which includes a free tier that we can use to get started.

To deploy a new PostgreSQL database, on the **Overview** tab of the [Koyeb control panel](https://app.koyeb.com/), click **Create Database Service**. Choose a name for the service and choose the region closest to you or your users.

Once the database is provisioned, click on the `.env` option of the **Connection Details** tab. Click the **copy icon** to save the connection details for later.

## Provision a Backblaze B2 object storage bucket

By default, Directus will store uploads and other file objects on the local filesystem where the application is running. In a serverless environment, this storage is ephemeral and would be lost when redeploying or reconfiguring the application. To avoid this, we will configure Directus to store these objects in an external object storage bucket. We will use Backblaze B2 for this.

To create an object storage bucket for Directus, log into your [Backblaze account](https://secure.backblaze.com/user_signin.htm) and follow these steps:

1. In the **B2 Cloud Storage** section on the left side of the dashboard, click **Buckets**.
2. Click **Create a Bucket** to begin configuring a new bucket.
3. Choose a name for the bucket. This must be globally unique, so choose a name not likely to be used by another user.
4. Set the bucket privacy to **Private**.
5. Use the provided defaults for the rest of the settings.
6. Click **Create a Bucket** to create the new bucket.

Copy and save the following information about your new bucket. You'll need it later to configure Directus:

| Backblaze B2 item | Example value                       |
| ----------------- | ----------------------------------- |
| Bucket name       | `some-bucket-name`                  |
| Endpoint          | `s3.eu-central-003.backblazeb2.com` |

Now that you have a bucket, you need to create API credentials so that Directus can authenticate to Backblaze as well as upload and manage objects:

1. In the **Account** section on the left side of the dashboard, click **Application Keys**.
2. Under **Your Application Keys**, click **Add a New Application Key** to begin configuring a new key.
3. Select a name for your key to help you identify it more easily.
4. Select the bucket you just created in the **Allow access to Bucket(s)** drop-down menu.
5. Select **Read and Write** as the access type.
6. Leave the remaining fields blank to accept the default policies.
7. Click **Create New Key** to generate the new key to manage your bucket.

Copy and save the following information related to your new API key. You'll need it to properly authenticate to your Backblaze account and perform object operations:

| Backblaze B2 item | Example value                     |
| ----------------- | --------------------------------- |
| `keyID`           | `008c587cb98cb3d0000000003`       |
| `applicationKey`  | `K002cbYLV/CkW/x+28zsqmpbIAtdzMM` |

## Provision a Redis instance on Aiven (Optional)

If you plan on scaling to multiple Directus instances, or if performance is an important factor, you can optionally configure a Redis database for caching and state synchronization. For this, we will use [Aiven Redis](https://aiven.io/redis).

To begin, [log in to your Aiven account](https://console.aiven.io/login) and follow these steps:

1. In the upper-right corner, click **Create service**.
2. On the service selection page, click **Redis**.
3. Select **Free plan** to use a free Aiven service.
4. Select the region closest to where you plan to run Directus.
5. Choose a name for the service or confirm the default choice.
6. Click **Create free service** to initialize the new Redis store.

Once the service is available, click the **copy icon** associated with the **Service URI** to save the connection details for later.

## Deploy Directus to Koyeb

Now that we have the connection details for the PostgreSQL database, object storage bucket, and Redis instance, we can deploy Directus to Koyeb.

On the **Overview** tab of the [Koyeb control panel](https://app.koyeb.com/), click **Create Web Service** to begin:

1. Select **Docker** as the deployment method.
2. Set the **Docker image** to `docker.io/directus/directus`. Optionally, append an [image tag](https://hub.docker.com/r/directus/directus/tags) if you'd like to deploy a specific version.
3. In the **Environment variables** section, click **Bulk edit** to enter multiple environment variables at once. In the text box that appears, paste the following:

   ```
   KEY=
   SECRET=
   DB_CLIENT="pg"
   DB_CONNECTION_STRING=
   STORAGE_LOCATIONS="s3"
   STORAGE_S3_DRIVER="s3"
   STORAGE_S3_KEY=
   STORAGE_S3_SECRET=
   STORAGE_S3_BUCKET=
   STORAGE_S3_ENDPOINT=
   STORAGE_S3_REGION=
   REDIS=
   CACHE_ENABLED="true"
   CACHE_AUTO_PURGE="true"
   CACHE_STORE="redis"
   SYNCHRONIZATION_STORE="redis"
   PUBLIC_URL=https://{{ KOYEB_PUBLIC_DOMAIN }}
   ADMIN_EMAIL=
   ADMIN_PASSWORD=
   ```

   Set the variable values to reference your own information as follows:

   - `KEY`: A unique string that serves as an identifier for the current project. Set to a random number (for example, generated by `openssl rand -base64 24`).
   - `SECRET`: A unique string used to sign JSON web tokens for authentication. Set to a random number (for example, generated by `openssl rand -base64 24`).
   - `DB_CLIENT`: Set to `pg` to indicate a PostgreSQL database.
   - `DB_CONNECTION_STRING`: Set to your PostgreSQL connection string, with `?sslmode=require` appended to the end.
   - `STORAGE_LOCATIONS`: A name for the storage location to be configured. This will be used as part of the other variables used to configure it. Use `s3` here.
   - `STORAGE_S3_DRIVER`: The driver to use for the storage location. Set this to `s3`.
   - `STORAGE_S3_KEY`: The API key ID for authenticating to Backblaze.
   - `STORAGE_S3_SECRET`: The API key secret for authenticating to Backblaze.
   - `STORAGE_S3_BUCKET`: The name of your Backblaze B2 bucket.
   - `STORAGE_S3_ENDPOINT`: The Backblaze B2 endpoint URL. This should look something like `s3.eu-central-003.backblazeb2.com`.
   - `STORAGE_S3_REGION`: The name of the region where your Backblaze B2 bucket can be accessed. This is part of the endpoint URL. For the above endpoint, the region would be `eu-central-003`.
   - `REDIS`: The connection string for the Redis store. If you do not plan on running multiple Directus containers, you can optionally remove this requirement.
   - `CACHE_ENABLED`: Set to `true` to enable caching.
   - `CACHE_AUTO_PURGE`: Set to `true` to automatically purge cache when data is manipulated.
   - `CACHE_STORE`: Set to `redis` if using a Redis store. Set to `memory` if you are not using Redis.
   - `SYNCRHONIZATION_STORE`: Set to `redis` if using a Redis store. Set to `memory` if you are not using Redis.
   - `PUBLIC_URL`: Set to the public URL where the Directus service will run. Set to `https://{{ KOYEB_PUBLIC_DOMAIN }}`, which will substitute the correct domain on deployment.
   - `ADMIN_EMAIL`: Set to the email you wish to use to authenticate to the Directus admin account.
   - `ADMIN_PASSWORD`: Set to the password you wish to use to authenticate to the Directus admin account.

4. In the **Instance** section, select size **eco-micro** or larger. According to the [Directus documentation](https://docs.directus.io/self-hosted/docker-guide.html#requirements), the `eco-micro` Instance provides the minimum amount of resources required to run Directus. The `small` Instance includes the recommended resources.
5. If you wish to scale to more than one instance, adjust the scale values in the **Scaling** section.
6. In the **Exposed ports** section, change the **Port** value that the Service will run on to **8055**, the default port for Directus.
7. Click **Deploy**.

Koyeb will pull the Directus Docker image from Docker Hub and deploy it using the configuration you provided. During the deployment process, Directus will connect to the PostgreSQL database and initialize it to create the necessary data structures. It will perform similar preparatory steps to configure the object storage and Redis components.

Once the deployment is healthy, visit your Koyeb Service's subdomain (you can find this on your Service's detail page). It will have the following format:

```
https://<YOUR_APP_NAME>-<KOYEB_ORG_NAME>.koyeb.app
```

You will be redirected to the Directus login page. Enter the admin email address and password you provided as environment variables to authenticate.

## Conclusion

In this guide, we showed how to deploy and configure Directus on Koyeb to create a data backend for applications. We provisioned a PostgreSQL database to store persistent data, an object storage bucket to manage user uploads and other file-type objects, and a Redis instance to synchronize state between Directus instances and cache content. We deployed Directus using a configuration that'll allow us to scale out as needed in the future, providing our applications, sites, and clients with a reliable, easy-to-manage data backend.

We've left off on this tutorial with a functional Directus instance that you can integrate with your projects. To get started, consider walking through the [Directus Quickstart Guide](https://docs.directus.io/getting-started/quickstart.html) which shows how to create collections, configure data fields and items, and manage roles and permissions to make your data public. If you'd like to further customize your Directus service, take a look at the [Directus configuration options](https://docs.directus.io/self-hosted/config-options.html) in the documentation.


Learn how to deploy and configure Directus, an open-data platform that can be used as a Backend-as-a-Service, headless CMS, or API.

How to Deploy Directus as a Backend-as-a-Service (BaaS) on Koyeb


## Introduction

PostHog is a developer-friendly open-source product analytics tool. With [PostHog](//posthog.com/), you can automate the collection of events on your websites and apps and analyze them without sending data to third parties.

By deploying your PostHog application on Koyeb you benefit from native autoscaling, Automatic HTTPS (SSL) on all apps you deployed, high availability, and global load-balancing & CDN to make your applications global.

## Requirements

To successfully deploy PostHog on Koyeb, you need:

- A [Koyeb account](//app.koyeb.com/auth/signup) to deploy and run PostHog
- The [Koyeb CLI](/docs/quickstart/koyeb-cli) installed to interact with Koyeb from the command line
- A running [PostgreSQL](//www.postgresql.org/) database Koyeb can access

## Steps

In order to deploy your PostHog app to Koyeb, you have to follow these steps:

1. [Create a new Koyeb App to deploy PostHog](#create-a-new-koyeb-app-to-deploy-post-hog)
2. [Deploy Redis](#deploy-redis)
3. [Create Secrets for PostHog App and PostgreSQL Connection](#create-secrets-for-post-hog-app-and-postgre-sql-database)
4. [Deploy PostHog on Koyeb](#deploy-post-hog-on-koyeb)

## Create a new Koyeb App to deploy PostHog

Start by creating a new Koyeb App we will deploy and run PostHog. In a terminal execute the following commands to create a new App:

```bash
koyeb app create posthog
```

## Deploy Redis

With the PostHog Koyeb App created, we now can deploy the Redis service required by PostHog. In a terminal, execute the following command to deploy the Redis instance:

```bash
koyeb service create redis -a posthog --docker redis:6-alpine --ports 6379:tcp --routes ""
```

## Create Secrets for PostHog App and PostgreSQL Database

Koyeb Secrets allow you to securely store and retrieve sensitive information like passwords. All Secret values are automatically encrypted server-side to ensure secure storage. To find out more about Koyeb Secrets, read our documentation about it [here](/docs/secrets).

### Koyeb Secret for PostHog Instance

For PostHog to work, you must create a `SECRET_KEY` that is unique to your PostHog instance. This `SECRET_KEY` is very important because it is used to encrypt cookies and password reset emails.

To create your `SECRET_KEY` and store it as a Koyeb Secret, in your terminal execute:

```bash
openssl rand -hex 32 | koyeb secret create posthog-secret-key --value-from-stdin
```

The command below generates a new key and creates a new Koyeb Secret `posthog-secret` to securely store the key on Koyeb.

### Koyeb Secret for PostgreSQL Database Connection

Create a Koyeb secret to securely store your PostgreSQL connection URL.

In the terminal execute the following command and replace the following values with your own:

- `<DB_USERNAME>`: PostgreSQL username
- `<DB_PASSWORD>`: PostgreSQL password
- `<DB_HOST>`: PostgreSQL host
- `<DB_PORT>`: PostgreSQL port
- `<DB_NAME>`: PostgreSQL database name

```bash
$koyeb secret create posthog-db-url
✔ Enter your secret: postgres://<DB_USERNAME>:<DB_PASSWORD>@<DB_HOST>:<DB_PORT>/<DB_NAME>
```

## Deploy PostHog on Koyeb

With al the previous steps completed, you are ready to deploy PostHog on Koyeb. In the terminal execute the following command:

```bash
koyeb service create posthog -a posthog --docker posthog/posthog:latest --ports 8000:http --routes /:8000 --env REDIS_URL=redis://redis --env SECRET_KEY=@posthog-secret-key --env DATABASE_URL=@posthog-db-url --env IS_BEHIND_PROXY=1
```

Within a few minutes you will be able to access your PostHog instance at `https://posthog-<YOUR_KOYEB_ORG_NAME>.koyeb.app/`

You can track the deployment logs in your terminal with this command:

```
koyeb service logs posthog
```

Your PostHog application is now running on Koyeb and benefits from native autoscaling, automatic HTTPS (SSL), auto-healing, and global load-balancing across our [edge network](/docs/reference/edge-network).

## Conclusion

In this guide, we saw how easy it is to deploy PostHog on Koyeb and how to interact with the Koyeb platform using the CLI.

If you would like to read more Koyeb tutorials, checkout out our [tutorials collection](/tutorials). Have an idea for a tutorial you'd like us to cover? Let us know by joining the conversation over on the **[Koyeb community platform](https://community.koyeb.com/)**!

Want to deploy your workloads on Koyeb? We let you run web apps, APIs, background workers, and more using git-based deployment or Docker containers! Enjoy native autoscaling, free SSL, a global edge network, and built-in service mesh and discovery with near zero configuration. [Sign up and get started](//app.koyeb.com/auth/signup) now


This guide covers how to deploy the open-source PostHog product analytics app on the Koyeb serverless platform. With PostHogs, you can integrate product analytics into your app without needing to send data to third parties.

Redis

Deploy Redis as an In-Memory Database for Koyeb Applications

How to Deploy Infisical to Manage Application Secrets on Koyeb

How to Deploy Directus as a Backend-as-a-Service (BaaS) on Koyeb

Running PostHog Product Analytics on Koyeb