
## 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

Discover how to deploy a GraphQL API using MongoDB Atlas and Apollo Server. Apollo Server is s an open-source GraphQL server that provides an easy way to build a GraphQL API that can use data from multiple sources, including several databases and even REST APIs.

Deploy a GraphQL API with MongoDB Atlas and Apollo Server 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.

Running PostHog Product Analytics on Koyeb


PlanetScale is a serverless database platform built on top of MySQL and Vitess. The platform provides developers great primitives simplifying the management and scaling of databases.

Following is a non-exhaustive list of the built-in features PlanetScale offers:

- **Native autoscaling**: to automatically scale underlying resources depending of the load
- **Database branching**: to create database copies with a click and apply schema changes to a branch
- **Non-blocking schema changes**: to update your database tables without locking and downtime

In this guide, we will explain how to use and connect your apps to your PlanetScale databases on the Koyeb serverless platform.

We will deploy the official PlanetScale `planetscale/pscale-proxy` Docker image inside a Koyeb App which avoids dealing with IP whitelisting or SSL certificates by proxifying connection to your PlanetScale databases.
We will also take advantage of the Koyeb [service mesh and discovery](/docs/reference/service-mesh-and-discovery), built-in features which provide an isolated, secure private network allowing your apps to communicate with your PlanetScale database securely.

## Requirements

To successfully follow and complete this tutorial, you need:

- A PlanetScale account and the [PlaneScale CLI](https://docs.planetscale.com/reference/planetscale-environment-setup/) installed on your machine
- A [Koyeb account](https://app.koyeb.com) to deploy and run

## Steps

To successfully follow this guide, you need to follow these steps:

1. [Create a PlanetScale database and service token](#create-a-planet-scale-database)
2. [Deploy the PlanetScale proxy on Koyeb](#deploy-the-planet-scale-proxy-on-koyeb)
3. [Connect your database via the Koyeb mesh](#connect-your-database-via-the-koyeb-mesh)

## Create a PlanetScale database

To get started, let's start by creating a database using the PlanetScale CLI. In the terminal, execute the following command replacing the `<dbname>` with the database name you want to use.

```bash
pscale database create <dbname>
```

To connect the PlanetScale database, we will use a service token to authenticate. To create a new service token, in the terminal run:

```bash
$pscale service-token create
NAME           TOKEN
-------------- ------------------------------------------
asd9eeectsti   f0d0d1426bf30957f8526d52208a07c08f000000
```

Save the token in a safe place, you will need it in the next section when deploying the PlaneScale Proxy on Koyeb.

To be able to properly authenticate to our database, we need to grant permissions on the service token we previously created. In the terminal execute the following replacing the `<dbname>` with your database name and `<tokenname>` with your service token name.

```bash
pscale service-token add-access <tokenname> connect_production_branch connect_branch --database <dbname>
```

By running this command, we grant the service token access to connect the production branch and all other branches. To learn more about service token permissions, please refer to the PlanetScale [documentation](https://docs.planetscale.com/reference/planetscale-cli/#service-tokens-in-organizations).

## Deploy the PlanetScale Proxy on Koyeb

PlanetScale provides a proxy to securely connect to your database without having to deal with IP whitelisting or SSL certificates manually. We will deploy the PlanetScale proxy in a Koyeb Service to easily connect to the associated databases.

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

1. Choose **Docker** as the deployment method.
2. In the **Docker image** field, enter `docker.io/planetscale/pscale-proxy`.
3. In the **Deployment** section, click the **Override** toggle associated with **Command args** and enter `["--host","0.0.0.0"]` in the field.
4. In the **Environment variables** section, click **Bulk edit** and add the following variables:
   - `PLANETSCALE_SERVICE_TOKEN`: with the PlanetScale service token you created in the previous section. We strongly recommend using a Secret environment variable to store it.
   - `PLANETSCALE_SERVICE_TOKEN_NAME`: with the PlanetScale service token name you created in the previous section. We strongly recommend using an environment variable of type Secret to store it.
   - `PLANETSCALE_DATABASE`: with the name of your PlanetScale database.
   - `PLANETSCALE_BRANCH`: with the name of the PlanetScale database branch to use, here I set the value to the default production branch `main`.
   - `PLANETSCALE_ORG`: with the name of your PlanetScale organization.
5. In the **Exposed ports** section, change the export port to `3306`.
6. Choose a name for your App and Service, for example `planetscale-demo`, and click **Deploy**.

This will create the Koyeb App with the PlanetScale proxy Service running it.

Now all Services you deployed inside this application will be able to securely connect the database using the Koyeb [service mesh](/blog/what-is-a-service-mesh) and [discovery](/blog/service-discovery-solving-the-communication-challenge-in-microservice-architectures).

## Connect your database via the Koyeb mesh

To connect the PlaneScale database using the Koyeb mesh, provide your application the following mysql configuration:

- `host`: The name of the Koyeb service running the PlanetScale, i.e. `pscale-proxy`
- `port`: 3306
- `user`: root
- `database`: your PlanetScale database name

We recommend to use environment variables to store and pass the connection parameters to your application.

## Conclusion

In this guide, we have seen how to configure, deploy and connect a PlaneScale database using the PlaneScale Proxy and how to connect your application to the database using the Koyeb mesh network. The Service Mesh & Discovery features offer a simple and secure way to communicate between your services and your database.

Questions or suggestions to improve this guide? Join us on the **[community platform](https://community.koyeb.com/)** to chat!


This tutorial explains how to use and securely connect your apps to a PlanetScale database on the Koyeb serverless platform.

Database

Deploy Redis as an In-Memory Database for Koyeb Applications

Deploy a GraphQL API with MongoDB Atlas and Apollo Server on Koyeb

Running PostHog Product Analytics on Koyeb

How to connect your apps to a PlanetScale database on Koyeb