This tutorial showcases how to build a REST API with Flask and a Fauna database and deploy it on Koyeb serverless platform. It also explains how to add authentication to a REST API.

How to Deploy a REST API with Flask, Fauna, and Authentication on Koyeb


## Introduction

[Flask](/docs/deploy/flask) is a lightweight web framework written in Python that offers developers powerful tools and features to create web applications with ease and flexibility.

This guide demonstrates how to deploy a Flask application using Gunicorn on the Koyeb Severless Platform. You will create a "Hello World" Flask application, push your code to a GitHub repository, and then deploy your application on the Koyeb platform using its git-driven deployment.

With Koyeb's git-driven deployment, your application benefits from a built-in continuous deployment pipeline because each git push you make to your repository automatically triggers a new build and deployment for your application on the Koyeb Serverless Platform.

For those who prefer deploying Docker containers, we also published a guide explaining how to dockerize and deploy a [Python Flask application on the Koyeb Serverless Platform](/tutorials/python-flask-application-deployment-on-koyeb).

## Requirements

To successfully follow and complete this guide, you need:

- A [Koyeb account](//app.koyeb.com/auth/signin) to deploy and run your Python Flask application
- [Python](//www.python.org/downloads/) installed on your computer
- A [GitHub account](//github.com/)

## Steps

To successfully create and deploy Flask application on Koyeb using git-driven deployment, you will need to follow these steps:

1. [**Create a Flask application**](#create-a-flask-application)
2. [**Create a git directory for the Flask application**](#continuously-deploy-a-flask-app-using-gunicorn-on-koyeb#create-a-git-directory-for-the-flask-application)
3. [**Deploy the Flask application on Koyeb**](#deploy-the-flask-application-on-koyeb)

## Create a Flask application

Begin by creating a directory where our application will live and moving into it by running the following commands:

```
mkdir flask-on-koyeb
cd flask-on-koyeb
```

### Create a virtual environment

Next, we will create a virtual environment, also known as virtualenv. Virtual environments allow you to create an isolated Python environment to avoid interfering with Python's system packages or other virtual environments.

To create a virtual environment, execute:

```
python3 -m venv ~/.venv/flask-app
```

This command creates a new directory `flask-app` in the ~/.venv directory. The virtualenv contains a copy of the Python interpreter, pip, the standard library, and various supporting files.

To activate the virtualenv we just created, run:

```
source ~/.venv/flask-app/bin/activate
```

The virtualenv python and pip executables are now added into your shell’s PATH.

### Install Dependencies

Next, install the dependencies required to run the application. In this case, we need Flask and Gunicorn. Flask is the lightweight Python framework we are using for this application and Gunicorn is a web server gateway interface (WSGI) server implementation used to run Python web apps. Gunicorn is a high-performing server better suited for production traffic.

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

### Create the Flask application

In your `flask-on-koyeb` directory, create a new `app.py` file with the following:

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

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

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

This file is storing our Flask application code. In the snipper above, we define a route to handle `/` requests and return `Hello, World!` as a response.

Check to see if the application is working locally by running:

```
python3 app.py
```

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

## Create a git directory for the Flask application

Now that we have created our Flask application, we will create a git directory to store it.

Initialize a new git directory for your Flask project by running the following in your terminal:

```
git init
```

To keep only the necessary files in the repository, add this .gitignore file to exclude unnecessary files.

```
curl https://raw.githubusercontent.com/github/gitignore/master/Python.gitignore > .gitignore
```

Next, execute the following command to add your files and commit the changes to your repository:

```
git add .
git commit -m "Flask app initial commit"
```

Open a new tab in your browser and go to GitHub. Create a new repository named `flask-on-koyeb` and click the _Create repository_ button. Then, go back to your terminal and add GitHub as a remote repository by running:

```
git remote add origin git@github.com:YOUR_GITHUB_USERNAME/flask-on-koyeb.git
```

Rename the repository default branch to main executing:

```
git branch -M main
```

Next, push your changes to the GitHub repository by running:

```
git push -u origin main
```

Now, you are ready to deploy your application on Koyeb.

## Deploy the Flask application on Koyeb

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

1. Choose **GitHub** as the deployment method.
2. Select the repository for your Flask application.
3. In the **Builder** section, click the **Override** toggle associated with the **Run command** and enter `gunicorn app:app` in the field.
4. Choose a name for your App and Service, for example `koyeb-flask-demo`, and click **Deploy**.

**Note:** You can add more regions, change the instance size, set environment variables, and define horizontal scaling according to your needs.

You land on the deployment page of your service where you can follow the progress of your Flask application's deployment. Koyeb will take care to build and deploy your application. Once these steps are completed, you can access your application by clicking your App URL ending with koyeb.app in the Koyeb control panel.

If you want to learn about how Koyeb automatically builds your applications from git, make sure to read our [how we build from git](/docs/apps/build-from-git) documentation.

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.

## Conclusion

In this guide, you learned how to deploy a Flask application on Koyeb and benefit from its built-in continuous deployment pipeline. Each change you push to your repository will automatically trigger a new build and deployment on the Koyeb Serverless Platform. Your changes then go live as soon as the deployment passes all necessary health checks. In case of a failure during one of your deployments, we ensure to keep the latest working deployment active so your application is always up and running.

Other great benefits to deploying your Python Flask application on Koyeb include the platform's built-in autoscaling, automatic HTTPS (SSL), high availability, global load-balancing and edge network.

All of these features and more work out-of-the-box and from the getgo. You focus on your code while Koyeb handles all the necessary underlying infrastructure to keep your services scalable, high performing and available.

Want more Flask on Koyeb? Check out our [Flask documentation](/docs/deploy/flask) and [one-click Flask app](/deploy/flask) to learn how to deploy a Flask application on Koyeb.

Give Koyeb a try with your application! 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/)**!


This guide shows how to deploy a Python Flask application using Gunicorn on the Koyeb Serverless Platform. Using Koyeb's git-driven deployment lets you benefit from the platform's built-in continuous deployment pipeline.

Continuously Deploy a Flask App using Gunicorn 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.

Flask

How to Deploy a REST API with Flask, Fauna, and Authentication on Koyeb

Continuously Deploy a Flask App using Gunicorn on Koyeb

Python Flask Application Deployment on Koyeb