Run a Server Manually

Warning

The current page still doesn't have a translation for this language.

But you can help translating it: Contributing.

Use the fastapi run Command

In short, use fastapi run to serve your FastAPI application:

fast →fastapi run main.pyINFO Using path main.py
INFO Resolved absolute path /home/user/code/awesomeapp/main.py
INFO Searching for package file structure from directories with __init__.py files
INFO Importing from /home/user/code/awesomeapp

╭─ Python module file ─╮
│ │
│ 🐍 main.py │
│ │
╰──────────────────────╯

INFO Importing module main
INFO Found importable FastAPI app

╭─ Importable FastAPI app ─╮
│ │
│ from main import app │
│ │
╰──────────────────────────╯

INFO Using import string main:app

╭─────────── FastAPI CLI - Production mode ───────────╮
│ │
│ Serving at: http://0.0.0.0:8000 │
│ │
│ API docs: http://0.0.0.0:8000/docs │
│ │
│ Running in production mode, for development use: │
│ │
│ fastapi dev │
│ │
╰─────────────────────────────────────────────────────╯

INFO: Started server process [2306215]
INFO: Waiting for application startup.
INFO: Application startup complete.
INFO: Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

restart ↻

That would work for most of the cases. 😎

You could use that command for example to start your FastAPI app in a container, in a server, etc.

ASGI Servers

Let's go a little deeper into the details.

FastAPI uses a standard for building Python web frameworks and servers called ASGI. FastAPI is an ASGI web framework.

The main thing you need to run a FastAPI application (or any other ASGI application) in a remote server machine is an ASGI server program like Uvicorn, this is the one that comes by default in the fastapi command.

There are several alternatives, including:

• Uvicorn: a high performance ASGI server.
• Hypercorn: an ASGI server compatible with HTTP/2 and Trio among other features.
• Daphne: the ASGI server built for Django Channels.

Server Machine and Server Program

There's a small detail about names to keep in mind. 💡

The word "server" is commonly used to refer to both the remote/cloud computer (the physical or virtual machine) and also the program that is running on that machine (e.g. Uvicorn).

Just keep in mind that when you read "server" in general, it could refer to one of those two things.

When referring to the remote machine, it's common to call it server, but also machine, VM (virtual machine), node. Those all refer to some type of remote machine, normally running Linux, where you run programs.

Install the Server Program

When you install FastAPI, it comes with a production server, Uvicorn, and you can start it with the fastapi run command.

But you can also install an ASGI server manually:

UvicornHypercorn

• Uvicorn, a lightning-fast ASGI server, built on uvloop and httptools.

fast →pip install "uvicorn[standard]"

restart ↻

Tip

By adding the standard, Uvicorn will install and use some recommended extra dependencies.

That including uvloop, the high-performance drop-in replacement for asyncio, that provides the big concurrency performance boost.

When you install FastAPI with something like pip install fastapi you already get uvicorn[standard] as well.

• Hypercorn, an ASGI server also compatible with HTTP/2.

fast →pip install hypercorn

restart ↻

...or any other ASGI server.

Run the Server Program

If you installed an ASGI server manually, you would normally need to pass an import string in a special format for it to import your FastAPI application:

UvicornHypercorn

fast →uvicorn main:app --host 0.0.0.0 --port 80
INFO: Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)

restart ↻

fast →hypercorn main:app --bind 0.0.0.0:80
Running on 0.0.0.0:8080 over http (CTRL + C to quit)

restart ↻

Note

The command uvicorn main:app refers to:

• main: the file main.py (the Python "module").
• app: the object created inside of main.py with the line app = FastAPI().

It is equivalent to:

from main import app

Warning

Uvicorn and others support a --reload option that is useful during development.

The --reload option consumes much more resources, is more unstable, etc.

It helps a lot during development, but you shouldn't use it in production.

Hypercorn with Trio

Starlette and FastAPI are based on AnyIO, which makes them compatible with both Python's standard library asyncio and Trio.

Nevertheless, Uvicorn is currently only compatible with asyncio, and it normally uses uvloop, the high-performance drop-in replacement for asyncio.

But if you want to directly use Trio, then you can use Hypercorn as it supports it. ✨

Install Hypercorn with Trio

First you need to install Hypercorn with Trio support:

fast →pip install "hypercorn[trio]"
restart ↻

Run with Trio

Then you can pass the command line option --worker-class with the value trio:

fast →hypercorn main:app --worker-class trio
restart ↻

And that will start Hypercorn with your app using Trio as the backend.

Now you can use Trio internally in your app. Or even better, you can use AnyIO, to keep your code compatible with both Trio and asyncio. 🎉

Deployment Concepts

These examples run the server program (e.g Uvicorn), starting a single process, listening on all the IPs (0.0.0.0) on a predefined port (e.g. 80).

This is the basic idea. But you will probably want to take care of some additional things, like:

• Security - HTTPS
• Running on startup
• Restarts
• Replication (the number of processes running)
• Memory
• Previous steps before starting

I'll tell you more about each of these concepts, how to think about them, and some concrete examples with strategies to handle them in the next chapters. 🚀