Python FastAPI MongoDB was chosen because Python has concise syntax and rich ecosystem, which is suitable for rapid development; FastAPI has extremely fast performance and supports asynchronous and automatic generation of API documents; MongoDB is a NoSQL document database with flexible data structures, easy to expand, and naturally compatible with JSON. This combination is particularly suitable for small and medium-sized projects, MVP products and API services that require rapid iteration. 2. When using FastAPI to build a REST API, you can quickly build routing, define data models and connect to MongoDB through sample code, and achieve efficient data operations with motor asynchronous drivers. After startup, you can directly test the interface through Swagger UI. 3. The front-end can be called simply through HTML JS, or it can integrate mainstream frameworks such as Vue.js and React, use fetch or axios to interact with FastAPI, or use Jinja2 templates to render pages directly in FastAPI. 4. In actual development, we need to pay attention to: the data verification provided by Pydantic can automatically verify the request format; exception handling is achieved through HTTPException; use python-dotenv to manage environment variables; configure CORS middleware to solve front-end cross-domain problems. 5. The deployment recommendations are: run MongoDB and Uvicorn hot reload locally in the development stage; the production environment is containerized by Docker, MongoDB can be used to use Atlas or self-built clusters, FastAPI is deployed with Nginx and Gunicorn/Uvicorn, and front-end static files can be deployed separately or integrated, ultimately achieving efficient and scalable full-stack applications.

If you are looking for an efficient, modern full-stack development technology stack, Python FastAPI MongoDB is a well worth considering combination. It combines development speed, performance and scalability, and is especially suitable for building RESTful APIs and lightweight backend services.

Next, I will take you to understand the full picture of this technology stack step by step and how to use them to build a complete full stack application.

1. Why choose FastAPI Python MongoDB?

? Python

• Concise grammar and rich in ecology
• A large number of mature library support (data processing, AI, automation, etc.)
• Suitable for rapid development and prototyping

? FastAPI

• Modern Web Framework Based on Python 3.7
• Extremely fast performance (based on Starlette and Pydantic)
• Automatically generate interactive API documents (Swagger UI and ReDoc)
• Supports asynchronous (async/await), suitable for high concurrency scenarios

? MongoDB

• NoSQL document database, flexible data structure
• Easy to scale, suitable for projects that iterate quickly
• Naturally compatible with JSON format, smoother front and back end interaction

This combination is particularly suitable for: small and medium-sized projects, MVP products, API services that require rapid iteration, systems with unfixed data structures (such as content management, user behavior records, etc.).

2. Backend: Build REST API with FastAPI

Let's take a look at the simplest FastAPI example:

 # main.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import List, Optional
from motor.motor_asyncio import AsyncIOMotorClient

app = FastAPI()

# MongoDB connection client = AsyncIOMotorClient("mongodb://localhost:27017")
db = client["myapp"]
collection = db["items"]

# Data model class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float

class ItemInDB(Item):
    id: str

#Route @app.get("/items", response_model=List[ItemInDB])
async def get_items():
    items = []
    async for doc in collection.find():
        items.append(ItemInDB(id=str(doc["_id"]), **doc))
    Return items

@app.post("/items", response_model=ItemInDB)
async def create_item(item: Item):
    doc = item.dict()
    result = await collection.insert_one(doc)
    return ItemInDB(id=str(result.inserted_id), **doc)

Start the command:

 uvicorn main:app --reload

Visit http://localhost:8000/docs to see the automatically generated Swagger document and can directly test the interface.

Tip: Use motor because it is a asynchronous driver of MongoDB, and it works best with the async feature of FastAPI.

3. How to connect the front-end? Simple and flexible

Although FastAPI is mainly responsible for the backend, you can match any front-end framework:

• Lightweight project : Directly use HTML JS (Fetch API to call FastAPI)
• Medium and large projects : Vue.js/React/Svelte, etc. call API through fetch or axios
• Full stack integration : You can also use Jinja2 templates to directly render pages in FastAPI (suitable for simple backgrounds)

Sample front-end call (JavaScript):

 async function getItems() {
  const res = await fetch("http://localhost:8000/items");
  const items = await res.json();
  console.log(items);
}

4. Key points in actual development

? Data verification and model

FastAPI integrates Pydantic and can automatically verify request data:

 class UserCreate(BaseModel):
    email: str
    password: str

@app.post("/users")
async def create_user(user: UserCreate):
    # If email is not a legal mailbox format, it will automatically return 422 error {"email": user.email}

? Exception handling

 from fastapi.exceptions import HTTPException

@app.get("/items/{item_id}")
async def get_item(item_id: str):
    doc = await collection.find_one({"_id": ObjectId(item_id)})
    if not doc:
        raise HTTPException(status_code=404, detail="Item not found")
    return ItemInDB(id=str(doc["_id"]), **doc)

? Environment variable management

Use python-dotenv to manage configuration:

 # .env
MONGODB_URL=mongodb://localhost:27017
DATABASE_NAME=myapp

 from dotenv import load_dotenv
import os

load_dotenv()
MONGODB_URL = os.getenv("MONGODB_URL")

? CORS support (front-end cross-domain)

 from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:3000"], # front-end address allow_methods=["*"],
    allow_headers=["*"],
)

5. Deployment Recommendations

• Development phase : Run MongoDB Uvicorn locally and hot reload
• Production environment :
  • Use Docker to containerize applications
  • MongoDB can be deployed in Atlas (cloud service) or built in self-built clusters
  • Deploy FastAPI with Nginx Gunicorn/Uvicorn
  • After packaging the front end, put it in a static directory or deploy it separately

Docker sample snippet:

 FROM python:3.10
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0.0", "--port", "8000"]

Summarize

Python FastAPI MongoDB is a lightweight, efficient, modern full-stack combination that is especially suitable for:

• Rapidly develop MVP
• Build high-performance APIs
• Projects that require flexible data structures
• Want to use the backend of Python ecosystem (such as data analysis, AI)

It is not as "all-inclusive" as Django, but it is more flexible and modern, especially with obvious advantages in asynchronous support and type safety.

Basically all is it, not complicated but it is easy to ignore details. Master FastAPI's dependency injection, Pydantic model and MongoDB asynchronous operations, and you can quickly build a production-level backend service.

The above is the detailed content of Full-Stack Development with Python, FastAPI, and MongoDB. For more information, please follow other related articles on the PHP Chinese website!