How to use FastAPI Routers

The endpoint is one of the most important aspects when we plan to design an API. The endpoint is the entry point that is used by clients to send requests and receive responses. In this article we will see how Pro’s use endpoints and how you can write and manage fastAPI endpoints for small as well as for bigger applications. Managing endpoints in small web applications versus larger enterprise-level APIs involves considering factors such as scalability, maintainability, and organization. Let’s break down how you can approach this in FastAPI, focusing on both scenarios:

What is an Endpoint?

An endpoint is a specific URL within a web API or web service that performs a particular function or provides access to a resource. In simpler terms, it’s a unique web address that represents a specific interaction point between a client (such as a web browser or a mobile app) and a server e.g https://example.com/post/

Endpoints are typically categorized based on the HTTP methods they support, such as GET, POST, PUT, DELETE, etc. Each HTTP method represents a different type of action that can be performed on the resource identified by the endpoint.

For example, in a simple blog application, you might have the following endpoints:

• {host}/posts: Represents a collection of blog posts. A GET request to this endpoint might retrieve a list of all blog posts, while a POST request might create a new blog post.
• {host}/posts/{post_id}: Represents an individual blog post identified by its unique ID. A GET request to this endpoint might retrieve the details of a specific blog post, a PUT request might update the post, and a DELETE request might delete it.

In a more complex application, there could be many more endpoints, each serving a different purpose or accessing a different part of the application’s functionality. Endpoints are the fundamental building blocks of web APIs, allowing clients to interact with the server and perform various actions or retrieve data.

Small Web Applications:

In a small web application, simplicity and ease of development are often prioritized over complex architecture. Here’s how you can manage endpoints:

1. Organize Endpoints: Group related endpoints together in separate Python modules or files. This improves readability and maintainability.
2. Use FastAPI’s APIRouter: Even in a small application, using APIRouter can help organize your endpoints and make your code more modular.
3. Minimal Middleware: Keep middleware usage minimal unless absolutely necessary for your application’s functionality. This reduces overhead.
4. Sensible Error Handling: Implement basic error handling to handle common errors gracefully and provide meaningful responses to users.

Here’s an example of organizing endpoints in a small FastAPI application:

# main.py
from fastapi import FastAPI
from routers import user, item

app = FastAPI()

app.include_router(user.router)
app.include_router(item.router)

# routers/user.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/users/")
async def read_users():
    return {"message": "Get all users"}

@router.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"message": f"Get user with ID {user_id}"}

# routers/item.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/items/")
async def read_items():
    return {"message": "Get all items"}

@router.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"message": f"Get item with ID {item_id}"}

Larger Enterprise-Level APIs:

In larger enterprise-level APIs, scalability, maintainability, and extensibility become crucial. Here’s how you can manage endpoints:

.
├── app                  # "app" is a Python package
│   ├── __init__.py      # this file makes "app" a "Python package"
│   ├── main.py          # "main" module, e.g. import app.main
│   ├── dependencies.py  # "dependencies" module, e.g. import app.dependencies
│   └── routers          # "routers" is a "Python subpackage"
│   │   ├── __init__.py  # makes "routers" a "Python subpackage"
│   │   ├── items.py     # "items" submodule, e.g. import app.routers.items
│   │   └── users.py     # "users" submodule, e.g. import app.routers.users
│   └── internal         # "internal" is a "Python subpackage"
│       ├── __init__.py  # makes "internal" a "Python subpackage"
│       └── admin.py     # "admin" submodule, e.g. import app.internal.admin

1. Modular Design: Break your API into smaller modules or services based on functionality or business logic. Each module can have its own set of endpoints.
2. Versioning: Consider versioning your API endpoints to ensure backward compatibility and provide a clear upgrade path for clients.
3. Documentation: Comprehensive documentation becomes essential. FastAPI provides built-in OpenAPI documentation, which can be extended with additional information and examples.
4. Security: Implement robust security measures such as authentication and authorization, especially if your API deals with sensitive data.
5. Testing: Write extensive unit tests and integration tests to ensure the reliability of your endpoints.

Here’s an example of organizing endpoints in a larger FastAPI application:

# main.py
from fastapi import FastAPI
from routers import v1, v2

app = FastAPI()

app.include_router(v1.router, prefix="/v1")
app.include_router(v2.router, prefix="/v2")

# routers/v1/__init__.py
from fastapi import APIRouter
from . import users, items

router = APIRouter()

router.include_router(users.router, prefix="/users")
router.include_router(items.router, prefix="/items")

# routers/v1/users.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/")
async def read_users():
    return {"message": "Get all users"}

@router.get("/{user_id}")
async def read_user(user_id: int):
    return {"message": f"Get user with ID {user_id}"}

# routers/v2/__init__.py
from fastapi import APIRouter
from . import users, items

router = APIRouter()

router.include_router(users.router, prefix="/users")
router.include_router(items.router, prefix="/items")

# routers/v2/users.py
from fastapi import APIRouter

router = APIRouter()

@router.get("/")
async def read_users_v2():
    return {"message": "Get all users (v2)"}

@router.get("/{user_id}")
async def read_user_v2(user_id: int):
    return {"message": f"Get user with ID {user_id} (v2)"}

By following these practices, you can effectively manage endpoints in both small web applications and larger enterprise-level APIs using FastAPI.