Python REST APIs with FastAPI, CRUD application

Ousseynou Diop's photo
Ousseynou Diop
·

4 min read

Introduction

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.

Why you should use FastApi for your next project?

  • Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.

  • Fast to code: Increase the speed to develop features by about 200% to 300%. *

  • Fewer bugs: Reduce about 40% of human (developer) induced errors. *

  • Intuitive: Great editor support. Completion everywhere. Less time debugging.
  • Easy: Designed to be easy to use and learn. Less time reading docs.
  • Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
  • Robust: Get production-ready code. With automatic interactive documentation.
  • Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.

Project Setup

Start by creating a new folder to hold your project called "fastapi-blog":

mkdir fastapi-blog && cd fastapi-blog

Next, create and activate a virtual environment(we will use pipenv):

Learn how to use pipenv here

Install dependencies

pipenv install fastapi uvicorn

✔ Successfully created virtual environment!
Virtualenv location: /Users/rosie/.local/share/virtualenvs/fastapi-blog-FXGAPIoM
Creating a Pipfile for this project...
Installing fastapi...
Adding fastapi to Pipfile's [packages]...
✔ Installation Succeeded
Installing uvicorn...
Adding uvicorn to Pipfile's [packages]...
✔ Installation Succeeded
Pipfile.lock not found, creating...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
Building requirements...
Resolving dependencies...
✔ Success!
Updated Pipfile.lock (d74721)!
Installing dependencies from Pipfile.lock (d74721)...
  🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 0/0 — 00:00:00
To activate this project's virtualenv, run pipenv shell.
Alternatively, run a command inside the virtualenv with pipenv run

Run pipenv shell to activate your environment.

Create a new file and call it app.py we will put all codes in this file.

touch app.py

In this article we will use a Python list as a database, we will not use a real database.

Inside app.py file put this:

# app.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
  return {"home": "Home page"}

Open your terminal then run the server

$ uvicorn app:app

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

The first app is the name of the file and the second one is the name of our application app = FirstAPI.

Head up at http://127.0.0.1:8000

Learn more about uvicorn here

Let's create our fake database to store posts.

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional, Text
from datetime import datetime

app = FastAPI()

postdb = []

# post model
class Post(BaseModel):
    id: int
    title: str
    author: str
    content: Text
    created_at: datetime = datetime.now()
    published_at: datetime
    published: Optional[bool] = False

@app.get("/")
def read_root():
  return {"home": "Home page"}

Here we create a simple Python class with type annotations using Pydantic and Python types module.

For every blog post we store:

- the title
- the author
- the content
- the date we created it
- the date we published it
- and the status of the post

We use equal symbol(=) to add a default value.

Now, create a new route to view all posts.

# app.py
...
@app.get("/blog")
def get_posts():
    return postdb

Restart your server then open http://127.0.0.1:8000 you will see an empty list [].

Let's add our first post.

...
@app.post("/blog")
def add_post(post: Post):
    postdb.append(post.dict())
    return postdb[-1]

One of the things I really love about FastAPI is the auto-generated docs.

Head up at http://localhost:8000/docs.

Let's create our first post. Click on Try it out then put this:

{
  "id": 1,
  "title": "Getting started with Django",
  "author": "Ousseynou DIOP",
  "content": "Hello Django",
  "created_at": "2021-03-01T18:17:45.194020",
  "published_at": "2021-03-01T18:17:58.887Z",
  "published": true
}

Create more posts then go to http://localhost:8000/blog

Let's get a single post by its ID.

# app.py
...
@app.get("/blog/{post_id}")
def get_post(post_id: int):
    post = post_id - 1
    return postdb[post]

The last two pieces of the CRUD are Update and Delete.

Let's begin by updating a post.

# app.py
...
@app.post("/blog/{post_id}")
def update_post(post_id: int, post: Post):
    postdb[post_id] = post
    return {"message": "Post has been updated succesfully"}

Add now you can update a post easily.

To be able to delete a post, you need to add this.

# app.py
...
@app.delete("/blog/{post_id}")
def delete_post(post_id: int):
    postdb.pop(post_id-1)
    return {"message": "Post has been deleted succesfully"}

Wrap up

In this article, we've learned the basic building blocks of FastAPI by creating a simple CRUD application. Let me know if you want to learn how to integrate a database with FastAPI.

See you in the next tutorial.