Home > Article > Backend Development > Understanding FastAPI Fundamentals: A Guide to FastAPI, Uvicorn, Starlette, Swagger UI, and Pydantic
FastAPI is a modern, high-performance web framework for building APIs with Python, allowing developers to create powerful and efficient applications with minimal effort. It's designed with asynchronous programming in mind, making it extremely fast and able to handle multiple requests concurrently. Key components that power FastAPI include Uvicorn, Starlette, Swagger UI, and Pydantic. In this guide, we'll explore each of these components and see how they come together in FastAPI, with code examples to demonstrate key concepts.
FastAPI is built on two major foundations:
Let’s start with a simple FastAPI app to get an idea of its structure:
# main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def read_root(): return {"Hello": "World"}
This is a basic FastAPI application with a single route (/) that returns a JSON response with {"Hello": "World"}.
To run this app, you’ll use Uvicorn, an ASGI server designed to serve asynchronous web applications.
Uvicorn is a lightning-fast ASGI server, optimized for handling asynchronous code. It’s essential for running FastAPI applications because it handles incoming HTTP requests and manages the lifecycle of these requests.
To run your FastAPI app with Uvicorn, use the following command:
uvicorn main:app --reload
When you run this command, Uvicorn will start serving your FastAPI app, and you can access it at http://127.0.0.1:8000.
FastAPI is built on top of Starlette, a lightweight ASGI framework that handles the core HTTP operations, including routing, middleware, and WebSockets support. Starlette provides the low-level tools that FastAPI uses to manage HTTP requests, making it a stable and performant foundation for building web applications.
FastAPI leverages Starlette’s routing system to define API endpoints. For example:
@app.get("/items/{item_id}") async def read_item(item_id: int): return {"item_id": item_id}
In this example:
Starlette also allows you to add middleware for various operations, such as handling CORS (Cross-Origin Resource Sharing), request logging, or custom authentication:
# main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def read_root(): return {"Hello": "World"}
This flexibility in Starlette makes FastAPI highly configurable, allowing developers to easily add custom middlewares as needed.
FastAPI automatically generates interactive API documentation with Swagger UI. This documentation is available by default at /docs and allows developers to test endpoints directly from the browser.
To see this in action, start up your FastAPI app and visit http://127.0.0.1:8000/docs. You’ll see an interactive Swagger UI that lists all of your routes, their parameters, and the expected responses.
Another documentation interface, ReDoc, is also provided at /redoc by default, offering a more detailed view of API specifications.
One of the most powerful aspects of FastAPI is its use of Pydantic for data validation. Pydantic models allow you to define the structure of request and response data with strict type constraints and automatic validation.
Let’s add a Pydantic model to our example:
uvicorn main:app --reload
In this code:
Try sending a request like this using Swagger UI at /docs:
@app.get("/items/{item_id}") async def read_item(item_id: int): return {"item_id": item_id}
FastAPI will validate the data and automatically return any errors if the data doesn’t match the expected types. For instance, if price is given as a string (like "twenty"), FastAPI will respond with a detailed validation error.
Let’s expand our app by adding more routes and combining everything we’ve learned so far:
from starlette.middleware.cors import CORSMiddleware app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], )
With this setup:
To run this application, use Uvicorn:
# main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def read_root(): return {"Hello": "World"}
Navigate to http://127.0.0.1:8000/docs to see the interactive documentation, or use a tool like cURL or Postman to send requests to the different endpoints.
FastAPI combines the performance benefits of asynchronous programming with the simplicity of Python type hints to create a framework that’s fast, easy to use, and suitable for production applications. By integrating Uvicorn, Starlette, Swagger UI, and Pydantic, FastAPI provides an incredibly streamlined approach to API development, making it a great choice for both rapid prototyping and production-grade applications.
With these core fundamentals in place, you’re now equipped to dive deeper into the world of FastAPI and build scalable, high-performance applications.
The above is the detailed content of Understanding FastAPI Fundamentals: A Guide to FastAPI, Uvicorn, Starlette, Swagger UI, and Pydantic. For more information, please follow other related articles on the PHP Chinese website!