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

This guide explains how to build and deploy a REST API using Koa, Prisma, and Aiven on the Koyeb serverless platform.

Deploy a Rest API using Koa, Prisma, and Aiven on Koyeb


## Introduction

Flask is a popular and lightweight web framework written in Python offering developers all the tools and features to create web applications with flexibility and ease.

In this guide, you will create a simple "Hello World" application written in Flask, create a Dockerfile using multi-stage builds to minimize the Docker image size, run
the Dockerized application locally and deploy it to the Koyeb platform.

By deploying your Python Flask 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 follow and complete this guide, you need:

- A [Koyeb account](https://www.koyeb.com) to deploy and run your Python Flask application

## Steps

To successfully dockerize your Flask application and deploy it to Koyeb, you have to follow the following steps:

1. Create a "Hello World" Flask application
2. Create the Docker image to run the Flask application
3. Push the Docker image on the Docker Hub
4. Deploy the Flask application on Koyeb

## Create a "Hello World" Flask application

To get started, we need to create a new folder to store the Flask application. In your terminal create a new folder by executing the command below:

```bash
mkdir -p ~/demo/flask
```

In my case, I create a `demo/flask` folder in my home directory.

In the folder you created, create a new virtual environment folder using `python -m venv venv`.
Virtual environments provide isolation from the system environment allowing each virtual environment you create to have its own installation directories, dependencies, etc.

Then to activate and load your virtual environment, type:

```bash
. venv/bin/activate
```

### Install dependencies

Now that our environment is created and activated, let's install Flask by running:

```bash
pip install Flask # Install Flask
pip freeze > requirements.txt # Create the requirements.txt to store the dependencies and version of each package required to run our application.
```

### Create the Hello World Flask application

In the `demo/flask/app` folder, create a new file `app.py`. We will use this file to store our minimalist Flask application code.
In the snipper below, we define a route to handle `/` request and return "Hello, World!" as a response.

```python
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'


if __name__ == "__main__":
    app.run()
```

### Run the application locally.

Back to your terminal and run the command below to launch the Flask application.

```bash
python app.py
```

In your browser, navigate to `http://localhost:5000` you will see `Hello, World!`.

## Create the Docker image to run the Flask application

To create our Docker image, we will Docker multi-stage to keep the Docker image size down by building an image that only contained what our application needs to run.

The Docker image is composed of two stages:

1. Create the virtual environment and install dependencies
2. Copy the virtual environment and launch the app

In the project root, create a Dockerfile containing the following:

```dockerfile
# Stage 1
FROM python:3-slim-buster AS builder

WORKDIR /flask-app

RUN python3 -m venv venv
ENV VIRTUAL_ENV=/flask-app/venv
ENV PATH="$VIRTUAL_ENV/bin:$PATH"

COPY requirements.txt .
RUN pip install -r requirements.txt

# Stage 2
FROM python:3-slim-buster AS runner

WORKDIR /flask-app

COPY --from=builder /flask-app/venv venv
COPY app.py app.py

ENV VIRTUAL_ENV=/flask-app/venv
ENV PATH="$VIRTUAL_ENV/bin:$PATH"
ENV FLASK_APP=app/app.py

EXPOSE 5000

CMD ["python", "-m" , "flask", "run", "--host=0.0.0.0"]
```

### Build and run the Docker image locally

To build the Docker image execute the following command in the `~/demo/flask` folder:

```bash
docker build . -t <YOUR_DOCKER_HUB_USERNAME>/koyeb-flask-demo
```

_In this guide, we will push the Docker image on the Docker Hub registry. Replace `<YOUR_DOCKER_HUB_USERNAME>` with your Docker Hub username._

Once the Docker build achieved, let's run the Docker image locally to ensure everything is running as expected:

```bash
docker run -d -p 5000:5000 <YOUR_DOCKER_HUB_USERNAME>/koyeb-flask-demo
```

If you open your browser and navigate to `http://localhost:5000` you will see `Hello, World!` served by the Docker container.

## Push the Docker image on the Docker Hub

With our Docker image built and working as expected, we can now push it to the [Docker Hub](https://hub.docker.com/).
In your terminal run the command below to push the image.

```bash
docker push <YOUR_DOCKER_HUB_USERNAME>/koyeb-flask-demo
```

Within a few minutes, you will see your Docker image available on your Docker Hub account repository.

## Deploy the Flask application on Koyeb

The most exciting part is happening now as we will deploy our Flask application on Koyeb!

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. Enter name of the image you created in the **Docker image** field. For example, `<YOUR_DOCKER_HUB_USERNAME>/koyeb-flask-demo`.
3. Click the **Private image** toggle and, in the select field, click **Create secret**. In the form that appears, choose a name for the Secret, for example `docker-hub-secret`, the registry provider, in our case **Docker Hub**, and the registry **username** and **password**. We recommend you to [generate an access token](https://hub.docker.com/settings/security) from the Docker Hub to use instead of your password. Once you've filled all the fields, click the **Create** button.
4. In the **Exposed ports** section, set the existing port to **5000**.
5. Choose a name for your App and Service, for example `koyeb-flask-demo`, and click **Deploy**.

You will automatically be redirected to the Koyeb App page where you can follow the progress of your Flask application deployment. In a few seconds, once your app is deployed, click on the _Public URL_ ending with `koyeb.app`.

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


This guide shows how to build a Docker image for your Flask application and how to deploy it on Koyeb serverless platform.

Python Flask Application Deployment on Koyeb


## Introduction

The Hasura GraphQL engine allows you to create and expose GraphQL APIs from your databases. Using the Hasura GraphQL engine you can focus on building your data schema structure
allowing you to build modern applications faster.

The Hasura GraphQL engine comes with native, useful primitives such as JWT authentication, authorization to restrict user access to a specific subset of data, event triggers to capture events happening on specific tables
and invoke a webhook to handle and perform a processing operation, and much more.

## Requirements

To successfully follow and complete this tutorial, you need:

- A Postgres database to use as the Hasura GraphQL engine backend.
- A [Koyeb account](//app.koyeb.com) to deploy and run the Hasura GraphQL engine.

## Steps

In this guide, we will focus on how to deploy the Hasura GraphQL engine on the Koyeb serverless platform and build a simple GraphQL API using PostgreSQL as a backend.

1. [**Deploy the Hasura GraphQL engine on Koyeb**](#deploy-the-hasura-graph-ql-engine-on-koyeb)
2. [**Try out Hasura**](#try-out-hasura)
3. [**Conclusion**](#conclusion)

## Deploy the Hasura GraphQL Engine on Koyeb

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

1. Choose **Docker** as the deployment method.
2. Enter `hasura/graphql-engine` as the **Docker image**.
3. In the **Environment variables** section, click **Add variable** to add the following variables:
   - `HASURA_GRAPHQL_DATABASE_URL`: The environment variable containing the PostgreSQL URL, i.e. `postgres://<user>:<password>@<host>:<port>/<database>`. To store this value which contains sensitive information, we strongly recommend configuring the environment variable using Koyeb secrets instead of storing it as a plaintext value. Secrets are encrypted at rest. They are ideal to store add sensitive data like authentication tokens, OAuth tokens, etc.
   - `HASURA_GRAPHQL_ENABLE_CONSOLE`: Set to `true`. This will expose the Hasura console and allow us to perform the configuration.
   - `HASURA_GRAPHQL_ADMIN_SECRET`: The secret to access the Hasura Graphql admin. As for the `HASURA_GRAPHQL_DATABASE_URL`, we strongly recommend using a secret to store this value.
4. In the **Exposed ports** section, change the existing entry to **8080**.
5. Choose a name for your App and Service, for example `hasura-demo`, and click **Deploy**.

## Try out Hasura

### Create a table

Open the Hasura console by clicking your App URL on the Koyeb control panel, in my case: `hasura-ed.koyeb.com`.
You land on the Hasura console where you need to log in using your admin secret.

Once logged in, click the **Data** tab on the top navigation bar of the Hasura console and click the **Create Table** button.
In this guide, we will create a todo table to showcase how to interact with data.

- Table name: todo
- Columns:

| Name       | Type | Default value     | Nullable | Unique |
| ---------- | ---- | ----------------- | -------- | ------ |
| id         | UUID | gen_random_uuid() | False    | True   |
| task       | Text |                   | False    | False  |
| status     | Text |                   | False    | False  |
| created_at | Date | now()             | False    | False  |
| updated_at | Date | now()             | False    | False  |

- Primary key: id

Once the form is properly completed, click the **Add Table** button.

### Insert some data into the todo table

On the Hasura control panel, click the \*_GraphiQL_ tab.

To insert data into our table, we use GraphQL mutations. Mutations are used to create, update and delete data on the server.

In the editor paste the following snippet to create our first todo task and click the **Play** button.

```graphql
mutation toto {
  insert_todo_one(object: { task: "My first task" }) {
    id
    status
    created_at
    task
    updated_at
  }
}
```

This query inserts only one todo task _My first task_ and returns the todo task id, task, created_at, update_at, and status.

### Retrieve our todo tasks

Now to retrieve our todo tasks, execute the following GraphQL query:

```graphql
query getTasks {
  todo {
    id
    task
    created_at
    updated_at
    status
  }
}
```

This query retrieves all todo tasks and returns for each its id, task, created_at, update_at, and status.

## Conclusion

In this guide, we discover how to deploy the Hasura GraphQL engine and koyeb, created a todo table, and perform basic GraphQL queries to insert and retrieve data.
Hasura provides great features not covered in this guide that we probably cover in the next tutorial.

To go deeper and learn more about how Hasura works, we recommend you to check out the Hasura official [documentation](https://hasura.io/docs/latest/graphql/core/index.html)

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


This tutorial explains how to deploy and configure the Hasura GraphQL engine on Koyeb to instantly expose GraphQL API to query your database backend.

APIs

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

Deploy a Rest API using Koa, Prisma, and Aiven on Koyeb

Python Flask Application Deployment on Koyeb

Deploy the Hasura GraphQL Engine to Expose and Create APIs from your Databases on Koyeb