CRUD operations with FastAPI REST API

In this tutorial, we will be building a RESTful API using FastAPI that performs CRUD operations (Create, Read, Update, Delete) on a simple resource, such as a list of books. FastAPI is a modern, fast web framework for building APIs with Python.

To get started, you will need to have Python installed on your machine. You can install FastAPI and other required dependencies by running the following command:

pip install fastapi uvicorn

Next, we will create a new Python file named main.py where we will define our FastAPI application. Let’s start by importing the necessary modules:

from fastapi import FastAPI
from pydantic import BaseModel

Next, we will create an instance of the FastAPI class and define a basic route for testing:

app = FastAPI()

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

You can run the FastAPI application using the following command:

uvicorn main:app --reload

You should see output indicating that the server is running, and you can access it by visiting http://127.0.0.1:8000 in your web browser.

Now let’s define a simple data model for our books resource using Pydantic:

class Book(BaseModel):
    title: str
    author: str

Next, we will create an in-memory database to store our books data:

books = []

We will now define the CRUD operations for our API. Let’s start with the Create operation:

@app.post("/books/")
async def create_book(book: Book):
    books.append(book)
    return book

This route accepts a POST request with JSON data representing a new book, creates a Book object from the data using Pydantic, appends it to the books list, and returns the newly created book.

Next, let’s define the Read operation to retrieve all books:

@app.get("/books/")
async def get_books():
    return books

This route returns all the books stored in the database.

Now let’s define the Update operation to update an existing book by its index:

@app.put("/books/{index}")
async def update_book(index: int, book: Book):
    if index < len(books):
        books[index] = book
        return book
    else:
        return {"error": "Book not found"}

This route accepts a PUT request with JSON data representing the updated book and the index of the book to update. If the index is valid, the corresponding book is updated and returned. Otherwise, an error message is returned.

Finally, let’s define the Delete operation to delete a book by its index:

@app.delete("/books/{index}")
async def delete_book(index: int):
    if index < len(books):
        deleted_book = books.pop(index)
        return deleted_book
    else:
        return {"error": "Book not found"}

This route accepts a DELETE request with the index of the book to delete. If the index is valid, the corresponding book is deleted and returned. Otherwise, an error message is returned.

That’s it! You have now created a basic CRUD API using FastAPI. You can test the API using a tool like Postman by sending requests to the relevant endpoints (e.g., http://127.0.0.1:8000/books/) with the appropriate HTTP method and data.

This tutorial covers the basic CRUD operations, but you can extend the API further by adding authentication, validation, error handling, pagination, and more advanced features. FastAPI provides excellent documentation and features to help you build powerful and efficient APIs with Python.