DEV Community: Daniel Easterman

Deploy a Python FastAPI Application to Render

Daniel Easterman — Wed, 10 Jul 2024 10:39:27 +0000

In the world of Python frameworks, FastAPI is the new kid on the block and a great choice for building APIs. Equally, Render is a good option for developers who want to quickly test their applications in a production environment for free.

In this post, we'll run through how to deploy a FastAPI app to Render. First, though, let's explore why FastAPI and Render are often chosen by developers.

Why FastAPI?

FastAPI is a high-performance microframework used primarily for building APIs (the clue is in the name). As such, FastAPI offers several advantages over older, better-known frameworks such as Django and Flask.

The first and most obvious advantage of FastAPI is that it was built with scalability and performance in mind.

For example, FastAPI is based on an asynchronous ASGI server rather than the older WSGI used by Django and other frameworks. ASGI servers can handle multiple requests simultaneously (concurrently). This is often seen as a better option for apps that need to handle high levels of user traffic.

FastAPI also makes it easier for developers to write asynchronous code by simply using the async keyword when defining asynchronous functions.

But FastAPI's shiny "newness" is also its main drawback. Because it was only introduced in 2018, FastAPI has a much smaller community and fewer learning resources (such as coding tutorials) compared to the more established frameworks. This is something to bear in mind when choosing FastAPI for your next project.

Why Render?

Render is a great option for developers who want to quickly test their applications in a production environment for free.

With Render, you don't even have to enter your credit card details to gain access to the free tier. So unlike other cloud services, there is no way to rack up charges by mistake.

As we will see in the section below, Render also provides an excellent overall developer experience with a clean, very easy-to-use UI and smooth integration with Git and GitHub. An added bonus is that any app you host on Render gets a free TLS certificate right out of the box.

The downside with Render's free tier is that it can take a long time for deployments to complete. Once this starts to become an issue, you might want to consider upgrading to one of the paid plans.

Create a FastAPI Demo Application

You can view, download, or clone the full code used in this article.

The first thing we need to do is create an empty directory where our project will live. Let's call it fastapi-render-appsignal.

Run the following commands in your terminal:

mkdir fastapi-render-appsignal
cd flask-heroku-appsignal
touch main.py

The entry point for the project will be main.py.

Next, we need to make our project a git repository by running the git initialize command in the root of the directory:

git init

Also, create a requirements.txt file in the project's root directory. Add these two lines to the file:

fastapi
uvicorn[standard]

Then run:

pip install -r requirements.txt

If the installation goes smoothly, you should see the following output in the terminal:

Installing collected packages: websockets, uvloop, typing-extensions, sniffio, pyyaml, python-dotenv, idna, httptools, h11, exceptiongroup, click, annotated-types, uvicorn, pydantic-core, anyio, watchfiles, starlette, pydantic, fastapi
Successfully installed annotated-types-0.6.0 anyio-4.2.0 click-8.1.7 exceptiongroup-1.2.0 fastapi-0.109.0 h11-0.14.0 httptools-0.6.1 idna-3.6 pydantic-2.5.3 pydantic-core-2.14.6 python-dotenv-1.0.1 pyyaml-6.0.1 sniffio-1.3.0 starlette-0.35.1 typing-extensions-4.9.0 uvicorn-0.27.0 uvloop-0.19.0 watchfiles-0.21.0 websockets-12.0

Now, in main.py, copy and paste the following barebones boilerplate code:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

Let's go line-by-line and explain what is being done in this short code snippet.

After the import statements, we create an instance of the FastAPI class and assign it to the variable app.
@app.get("/") is a Python decorator that tells FastAPI to create an API endpoint via the HTTP GET method at the root URL /.
async def root() defines an asynchronous function named root. We are using the async keyword here because FastAPI is built to work with asynchronous I/O operations. This means it can handle concurrent requests, which is better for performance.
In the body of the function, we return a Python dictionary which FastAPI helpfully converts to JSON for us. So, when the user goes to the root / endpoint, our API will automatically respond with a JSON object.

We can now run our project using the server package Uvicorn (that we installed earlier) with the following command:

uvicorn main:app --reload

If we open our browser at http://127.0.0.1:8000, we will just see the following plain JSON response:

{ "message": "Hello World" }

But if we add /docs to the end of the URL, we can take advantage of FastAPI's in-built interactive API documentation capabilities.

The documentation UI in the screenshot below is provided by Swagger UI:

You can also try another documentation UI style that's automatically included with FastAPI.

Enter the URL http://127.0.0.1:8000/redoc in your browser.

This one is provided by ReDoc:

Deploy on Render

This part assumes you have already created a repository for this project on GitHub. If you need instructions on how to do this, check out GitHub’s official docs.

One of Render’s advantages is that it provides an easy and intuitive way to connect to your GitHub repository.

First, go to render.com and create a new account with Render (you can use your GitHub credentials to speed things up).

Then click on the New button and select the option to create a new web service.

After linking your GitHub account, you should see the screen below, which provides a list of GitHub repos to connect to Render. Let's select our fastapi-render-appsignal example project.

This will then take us to the main configuration screen. Under region, simply select the region closest to your location (since I’m based in the UK, I will choose Frankfurt):

Further down the screen, we have a few more important options.

The build command will use the requirements.txt file we created earlier in the project to install all the packages from our project on Render’s remote server.

Under start command, we will use Uvicorn again in our production environment and tell Render to start the application using main.py in the root of our project.

Note: You must explicitly tell Render which host and port to use (unlike when using other servers like gunicorn). Unfortunately, this is not mentioned in any of the official Render documentation but I found the solution in the Render community forum and in the post 'Deploying FastAPI application to Render'.

Next, choose the free option under the list of instance types:

Lastly, under environment variables, specify the Python version as 3.10.7. Ensure this matches the same version you are using in your local project.

With our web service configuration done, now we simply click the Create Web Service button and watch the project get deployed:

Remember, this will take a bit of time since we are using the free plan.

If everything goes smoothly at the end of the deployment process, we should see a final message in Render's logs saying: "Your service is live".

Now we can click on the public link Render has generated for us and see our Hello World FastAPI example, including the automatic documentation links at /docs and /redoc:

Installing the AppSignal Dashboard for FastAPI and Monitoring Deploys

It's great that we now have a basic FastAPI app running and deployed to Render, but what if something goes wrong? Even with the best manual and automated testing, the reality is that errors and bugs happen in software development. The key thing is to get alerted as soon as errors happen and to quickly identify where the problem is in the code.

In this section of the tutorial, we are going to specifically look at how to enable AppSignal to monitor your deployments. This part of the setup is crucial for you to see which errors are associated with a specific deployment. This will allow you to diagnose and fix problems in your app quickly and efficiently.

First, sign up for an AppSignal account (you can do a 30-day free trial, no credit card details required).
Next, add appsignal and opentelemetry-instrumentation-fastapi to your requirements.txt file:

# requirements.txt
appsignal
opentelemetry-instrumentation-fastapi

Then run:

pip install -r requirements.txt

Now we need to create an appsignal.py configuration file and add the following code:

import os
import subprocess
from appsignal import Appsignal
from dotenv import load_dotenv
load_dotenv()

revision = None
try:
    revision = subprocess.check_output(
        "git log --pretty=format:'%h' -n 1", shell=True
    ).strip()
except subprocess.CalledProcessError:
  pass


appsignal = Appsignal(
    active=True,
    name="fastapi-render-appsignal",
    push_api_key=os.getenv("APPSIGNAL_API_KEY"),
    revision=revision,
)

In the code above, we initialize the Appsignal object with a few different parameters, including:

Setting active to True to enable monitoring.
Providing the name for our application.
Putting the API key in an environment variable.

But the key parameter to enable deploy tracking is the revision parameter. Inside the try-except block (above the AppSignal initialization code), we fetch the latest commit hash so AppSignal can keep track of our deploys.

Lastly, we need to update main.py to finish setting up AppSignal in our FastAPI app:

# main.py
from fastapi import FastAPI
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor #new
import appsignal #new

appsignal.start() #new

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.get("/items/{item_id}")
async def get_item(item_id: int):
    return {"item_id": item_id}

FastAPIInstrumentor().instrument_app(app) #new

When we check out our AppSignal dashboard, the first thing we will see is the Getting Started screen which will provide some suggestions on additional configuration steps to complete:

But here we'll just focus on ensuring that AppSignal can track our deploys.

Go to the Organization page in the AppSignal dashboard and then click on Organization settings to activate AppSignal's integration with GitHub. Check out AppSignal's official docs on linking your repo for step-by-step instructions.

With the GitHub integration set up and your repo linked, all you need to do now is trigger a deployment in Render for AppSignal to start monitoring your deploys.

In our case, we simply need to push to our main branch:

git push origin main

If everything is set up correctly, we should see AppSignal tracking our deploys and any errors associated with each deploy commit hash in the Deploys section of the dashboard:

And that's it!

Wrapping Up

In this guide, we covered a lot of ground! First, we briefly introduced some of the advantages and disadvantages of choosing FastAPI and Render.

Then, we created a simple FastAPI app, deployed it to Render, and ended by monitoring those deploys with AppSignal.

Happy coding!

P.S. If you'd like to read Python posts as soon as they get off the press, subscribe to our Python Wizardry newsletter and never miss a single post!

How to Deploy a Python Flask app with Heroku

Daniel Easterman — Wed, 20 Dec 2023 15:09:33 +0000

In this tutorial, we will build a simple Flask app that is primed and ready to deploy to Heroku.

Once the bare bones of the app are built, we will guide you through the setup process on GitHub and Heroku so that you can start making automatic deploys in no time.

But before we dive straight into the code, why choose Flask and Heroku in the first place?

Why Flask for Python?

Flask is a super-minimalistic web framework for Python. It provides only the absolute core functionality needed to build web applications in a small and nimble package.

One major advantage of this approach is that Flask provides web developers with maximum flexibility to design and build their app from the very beginning.

On the other hand, frameworks such as Django prefer the "batteries-included" philosophy. This means more is taken care of for you out-of-the-box, but there will be more boilerplate code. The structure of your application is more rigid and harder to change later on.

Also, as the industry moves away from big code "monoliths" built on frameworks like Django, and towards smaller microservice architecture, it has never been a better time to get familiar with Flask.

Why Heroku?

When Heroku launched in 2007, it was one of the first cloud platforms renowned for its user-friendly interface and ease of use. Using Heroku was a huge time-saver, as it made deploying web applications much easier than configuring all your infrastructure from scratch using AWS. In fact, Heroku itself is built on AWS infrastructure. Another advantage was the fact that you could deploy your hobby app with a full Postgres database totally for free.

Since then, several other cloud services have sprung up to challenge Heroku's first-mover advantage in the sector of cloud computing known as Platform-as-a-Service (PaaS).

But Heroku still retains one significant edge over the newer cloud providers: its extensive library of third-party add-ons.

If you need functionality for your app like error tracking or performance monitoring (which, incidentally, AppSignal provides) you can simply install an add-on for that on Heroku's interface and get started immediately. For many developers, this speed and convenience might make the difference between shipping or not shipping.

Create a Python Flask Demo App for Heroku Deployment

The very first thing we need to do is create an empty Flask project. Lets call it flask-heroku-appsignal. We'll also create the main entry point file for our project, app.py:

mkdir flask_heroku_appsignal
cd flask-heroku-appsignal
touch app.py

Then we'll make our project a git repository by running the git initialize command in the root of the directory:

git init

By the way, if you want to view the full code for this article at any point, download or clone it here.

Next, we need to install the core dependencies, which include Flask itself, python-dotenv (to manage environment variables), and gunicorn, which will act as the "bridge" between Heroku's web servers and our web application.

Create a requirements.txt file in the root of the project and just add the dependency names to it (you don't need to include the version numbers):

Flask
python-dotenv
gunicorn

Then run:

pip install -r requirements.txt

If everything goes smoothly, we should see some output that looks something like this:

Collecting Flask
  Using cached Flask-2.2.3-py3-none-any.whl (101 kB)
Collecting python-dotenv
  Using cached python_dotenv-1.0.0-py3-none-any.whl (19 kB)
Collecting Werkzeug>=2.2.2
  Using cached Werkzeug-2.2.3-py3-none-any.whl (233 kB)
Collecting itsdangerous>=2.0
  Using cached itsdangerous-2.1.2-py3-none-any.whl (15 kB)
Collecting click>=8.0
  Using cached click-8.1.3-py3-none-any.whl (96 kB)
Collecting Jinja2>=3.0
  Using cached Jinja2-3.1.2-py3-none-any.whl (133 kB)
Collecting MarkupSafe>=2.0
  Using cached MarkupSafe-2.1.2-cp310-cp310-macosx_10_9_x86_64.whl (13 kB)
Installing collected packages: python-dotenv, MarkupSafe, itsdangerous, click, Werkzeug, Jinja2, Flask
Successfully installed Flask-2.2.3 Jinja2-3.1.2 MarkupSafe-2.1.2 Werkzeug-2.2.3 click-8.1.3 itsdangerous-2.1.2 python-dotenv-1.0.0

Preparing for Heroku Deployment

Now that all our basic project foundations are in place, let’s start building and configuring our Flask app with deployment to Heroku in mind.

First, let's copy this super-simple "hello world" code into app.py to check everything is working as expected so far:

from flask import Flask
from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

@app.route("/")
def index():
  return "Hello World!"

Then type flask run in the terminal. We should see the following output:

* Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit

When we go to localhost:5000, we will see the Hello World! string printed in the browser.

At this point, I have a nice time-saving Flask tip to share with you that isn't mentioned in most Flask tutorials.

By adding the simple one-liner below in your .env at the root of the project, you can save lots of time. You won't have to stop and start your local server every time you want to make changes to your backend code. While this doesn't sound like a huge thing, these small changes add up to loads of compounded saved time over the long run.

FLASK_DEBUG=True

As the “debug” name suggests, this setting will provide a nicely formatted error read-out in the browser to make it easier to debug your code.

Also, ensure that the .env file is included in your project's .gitignore so that it's not tracked by git. This means it will not be picked up by GitHub and Heroku (as we don’t want the debug mode to be part of our production settings).

After making this change, the output on our terminal will display Debug mode as on with the Debugger PIN:

* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 133-697-373

Development and Production Settings In Our Python Flask App

Next, we want to make a clear distinction between the development and production settings in our Flask app. This is an important step in preparing for deployment to Heroku. To do this, we will create a config.py file in the root of the project and add the following code with three classes:

class Config:
 DEBUG = False
 DEVELOPMENT = False
 CSRF_ENABLED = True
 ASSETS_DEBUG = False

class ProductionConfig(Config):
 pass

class DevelopmentConfig(Config):
 DEBUG = True
 DEVELOPMENT = True
 TEMPLATES_AUTO_RELOAD = True
 ASSETS_DEBUG = True

Back in app.py, add the following two lines before the index route function:

...
env_config = os.getenv("PROD_APP_SETTINGS", "config.DevelopmentConfig")
app.config.from_object(env_config)

So now the full app.py will look like this:

import os
from flask import Flask
from dotenv import load_dotenv
load_dotenv()

app = Flask(__name__)

env_config = os.getenv("PROD_APP_SETTINGS", "config.DevelopmentConfig")
app.config.from_object(env_config)

@app.route("/")
def index():
    return "Hello World!"

Essentially, the code above says that if we find a key called PROD_APP_SETTINGS in our environment, the config for our app should be set to config.ProductionConfig. Otherwise, we can safely assume we are in development mode and set it to config.DevelopmentConfig.

Now we are ready to set up our app in Heroku's web interface.

GitHub Setup

Before setting up on Heroku, we first need to create a repository on GitHub.

Go to github.com and create a new account (if you don't have one already).

We can call our GitHub repository the same name as our local Flask project:

Now we simply need to follow GitHub's instructions and push the code from our existing local repository to the remote one.

To double-check that the local and remote repositories have been linked correctly, run this command in the project directory:

git remote -v

We should get something very similar to the following output:

origin  https://github.com/daneasterman/flask-heroku-appsignal.git (fetch)
origin  https://github.com/daneasterman/flask-heroku-appsignal.git (push)

With the GitHub steps complete, we can start getting set up on Heroku by first creating a new app.

Heroku Deployment

We need to make sure that we have Heroku's special Procfile at the root of our project. The Procfile is a configuration text file specifying the various process types that will run when your app starts up. Without this, your app will not run on Heroku.

Copy the line below and add it to your Procfile:

web: gunicorn app:app

Also, remember the config.py we created in the previous section? We need to update our configuration in Heroku so that the app runs on our production settings, with DEBUG set to False.

First, click on the Setting tab on your Heroku dashboard. Then click the Reveal Config Vars button. Add the variable PROD_APP_SETTINGS and the value config.ProductionConfig.

Next, we need to connect our GitHub repository to Heroku. Click on the "Connect to GitHub" button. Then in the section that appears underneath, search for our flask-heroku-appsignal repository, and finally click on the second "Connect" button below.

Then click the "Enable Automatic Deploys" button. This means that every time you push your code to the main branch on GitHub, it will trigger an automatic deployment to Heroku.

Unfortunately, Heroku doesn't provide a free tier for demo apps anymore. So to complete the proof-of-concept for our flask-heroku-appsignal app, we need to purchase a dyno-type subscription.

This is where Heroku is a little cheeky and automatically puts you in the slightly more expensive Basic Plan. To change this, click on the Resources tab and then click: Change Dyno Type, which will bring up a modal screen. Finally select the Eco dyno, which will be absolutely fine for our purposes:

And we're done!

Wrapping Up

That concludes this introduction to deploying your Flask app to Heroku. Once you build out your web app with more functionality, you can think about installing the AppSignal add-on for Heroku, which now supports Python and Flask apps.

With this add-on, you can track errors, monitor performance, get access to advanced metric dashboards, and more. Happy building!

P.S. If you'd like to read Python posts as soon as they get off the press, subscribe to our Python Wizardry newsletter and never miss a single post!