Introduction
FastAPI is a modern, high-performance web framework for building REST APIs in Python. Its key features, such as automatic OpenAPI documentation, asynchronous support, and ease of use, make it a preferred choice for developers. Powered by Python type hints and Pydantic for data validation, FastAPI ensures robust and scalable APIs with minimal effort.
This article walks you through the basics of building REST APIs using FastAPI, complete with examples, resources, and tips to get you started.
Getting Started with FastAPI
Installation
To install FastAPI and a server to run it, use the following commands:
pip install fastapi uvicorn
Creating a Simple FastAPI Application
Start with a basic “Hello, World!” API:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, World!"}
Run the application using uvicorn:
uvicorn main:app --reload
Visit http://127.0.0.1:8000 in your browser to see the API in action.
Example 1: A CRUD API for Managing Items
Let’s build a REST API for managing a list of items, complete with Create, Read, Update, and Delete (CRUD) operations.
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List
app = FastAPI()
# Define a model for the item
class Item(BaseModel):
id: int
name: str
description: str
price: float
# In-memory storage for items
items = []
# Create an item
@app.post("/items/", response_model=Item)
def create_item(item: Item):
items.append(item)
return item
# Read all items
@app.get("/items/", response_model=List[Item])
def get_items():
return items
# Read a single item by ID
@app.get("/items/{item_id}", response_model=Item)
def get_item(item_id: int):
for item in items:
if item.id == item_id:
return item
raise HTTPException(status_code=404, detail="Item not found")
# Update an item by ID
@app.put("/items/{item_id}", response_model=Item)
def update_item(item_id: int, updated_item: Item):
for index, item in enumerate(items):
if item.id == item_id:
items[index] = updated_item
return updated_item
raise HTTPException(status_code=404, detail="Item not found")
# Delete an item by ID
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
for index, item in enumerate(items):
if item.id == item_id:
del items[index]
return {"message": "Item deleted successfully"}
raise HTTPException(status_code=404, detail="Item not found")
This API supports full CRUD functionality and ensures data validation through Pydantic models.
Example 2: Integrating Database with SQLAlchemy
For production-grade applications, you’ll need a database. Here’s how you can integrate FastAPI with SQLAlchemy.
Install the required packages:
pip install sqlalchemy psycopg2
Create a database model:
from sqlalchemy import create_engine, Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
# Define the Item model
class Item(Base):
__tablename__ = "items"
id = Column(Integer, primary_key=True, index=True)
name = Column(String, index=True)
description = Column(String)
price = Column(Float)
Modify FastAPI to use the database:
from fastapi import Depends
from sqlalchemy.orm import Session
# Dependency to get the database session
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.post("/db/items/", response_model=Item)
def create_item_db(item: Item, db: Session = Depends(get_db)):
db_item = Item(**item.dict())
db.add(db_item)
db.commit()
db.refresh(db_item)
return db_item
Resources for Further Learning
- Documentation: FastAPI Official Docs
- Courses:
- “Building APIs with FastAPI” on platforms like Udemy or Pluralsight.
- Books: FastAPI Book by Sebastián Ramírez (creator of FastAPI).
- Community: Join the FastAPI GitHub Discussions or related forums.
Conclusion
FastAPI simplifies the process of building high-performance REST APIs by combining the best of Python’s type hints and modern web frameworks. From its automatic validation and documentation to seamless integration with databases, FastAPI is a great tool for both beginners and advanced developers.
Start building your API with FastAPI today and experience its speed and developer-friendly features firsthand! 🚀