Anuncio¡Presentamos MongoDB 8.0, el MongoDB más rápido de la historia! Leer más >

AnuncioVoyage AI se une a MongoDB para potenciar aplicaciones de IA más precisas y confiables en Atlas. Más información >

¿Qué es PyMongo? Introducción a Python y MongoDB

Pruebe Atlas hoy mismo

PyMongo es el controlador oficial de MongoDB para aplicaciones síncronas de Python. Si desea aprender a conectar y usar MongoDB desde su aplicación Python, ha llegado al lugar adecuado. En este tutorial de PyMongo, construiremos una aplicación CRUD sencilla (Crear, Leer, actualizar, borrar) utilizando FastAPI y MongoDB Atlas. La aplicación podrá crear, leer, actualizar y borrar documentos en una base de datos MongoDB, exponiendo la funcionalidad a través de una REST API. Puede encontrar la aplicación terminada en Github.

¿Qué es PyMongo? Comenzando con Python y MongoDB

Aplicación CRUD de gestión de libros
Requisitos
Establecimiento y configuración de proyectos
Conéctese a su clúster de MongoDB Atlas
Cree modelos para solicitudes y respuestas de la API
Implemente los endpoints de la REST API
Explore la página de documentación de la API y pruebe los endpoints
Conclusión

Aplicación CRUD para la gestión de libros

Mi forma favorita de aprender nuevas tecnologías es construyendo algo. Por eso programaremos la aplicación de backend más sencilla, pero útil: una aplicación CRUD para gestionar libros. Las operaciones CRUD estarán disponibles a través de una REST API. La API tendrá cinco puntos finales:

Code SnippetGET /book: to list all books
GET /book/<id>: to get a book by its ID
POST /book: to create a new book
PUT /book/<id>: to update a book by its ID
DELETE /book/<id>: to delete a book by its ID

Para compilar la API, utilizaremos el framework FastAPI. Es un marco ligero, moderno y fácil de usar para construir APIs. También genera una documentación de la API de Swagger que utilizaremos al probar la aplicación.

Almacenaremos los libros en un MongoDB Atlas clúster. MongoDB Atlas es la plataforma de base de datos como servicio de MongoDB. Es basado en cloud y puede crear una cuenta gratuita y un clúster en minutos, sin instalar nada en su máquina. Usaremos PyMongo para conectarnos al clúster y hacer query de datos.

Requisitos

El proyecto terminado está disponible en GitHub. También puede seguir las instrucciones paso a paso para compilar el proyecto desde cero. Para hacer eso, necesitará lo siguiente:

Python 3.6+—Puede instalarlo desde el sitio web de Python.
Un clúster de MongoDB Atlas: puede crear un clúster gratuito para siempre siguiendo la Guía de introducción a Atlas. Complete los pasos de la guía y localice su cadena de conexión: la necesitará para conectarse a la base de datos desde la aplicación.

Configuración e instalación del proyecto

Antes de comenzar, crearemos un entorno virtual de Python para aislar el proyecto del resto de los paquetes de Python instalados globalmente. Usaremos el paquete venv, que viene con su instalación de Python. Ejecute el siguiente comando desde el terminal:

Code Snippetpython3 -m venv env-pymongo-fastapi-crud
source env-pymongo-fastapi-crud/bin/activate

Nota: Es posible que deba ejecutar este comando usando el python3 ejecutable. Esto se debe a que, en algunos sistemas operativos, están instalados tanto Python 2 como 3. Una vez que haya iniciado sesión en su entorno virtual, el python ejecutable usará la versión 3 automáticamente.

Ahora que disponemos de un entorno virtual, podemos instalar los paquetes necesarios. Usaremos pip, el instalador de paquetes para Python, que también se incluye con su instalación de Python:

Code Snippet

Siguiente, crearemos un directorio para nuestro Proyecto, navegaremos hasta él y generaremos la estructura de los archivos necesarios para el Proyecto.

Code Snippetmkdir pymongo-fastapi-crud
cd pymongo-fastapi-crud
touch main.py routes.py models.py .env

Nota: Usaremos comandos de shell para crear archivos y directorios, y navegar por ellos. Si lo prefiere, puede usar un explorador gráfico de archivos.

Comencemos implementando un root / endpoint simple que devuelva un mensaje de bienvenida. Abra el archivo main.py en su editor de código favorito y añada lo siguiente:

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Welcome to the PyMongo tutorial!"}

Guarde el archivo y ejecute la aplicación utilizando el paquete uvicorn, que se instaló junto con el paquete fastapi.

Code Snippet

Debería ver la siguiente respuesta:

Code SnippetINFO:     Will watch for changes in these directories: ['/Users/you/pymongo-fastapi-crud']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2465] using watchgod
INFO:     Started server process [2467]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Abra http://127.0.0.1:8000 en su navegador. Debería ver el mensaje de bienvenida.

¡Bien hecho! Tenemos un servidor en ejecución. En la siguiente sección, nos conectaremos a nuestro MongoDB Atlas cluster.

Conéctese a su MongoDB Atlas cluster

A continuación, necesitamos conectarnos al MongoDB Atlas cluster que creamos anteriormente. Localice su cadena de conexión y añádala al .env archivo. Reemplace nombre de usuario y password con sus credenciales.

pymongo-fastapi-crud/.env

Code SnippetATLAS_URI=mongodb+srv://<username>:<password>@sandbox.lqlql.mongodb.net/?retryWrites=true&w=majority
DB_NAME=pymongo_tutorial

Usaremos el paquete python-dotenv para cargar las variables de entorno ATLAS_URI y DB_NAME desde el archivo .env archivo. Luego, utilizaremos el paquete pymongo para conectarnos al clúster de Atlas cuando se inicie la aplicación. Agregaremos otro controlador de eventos para cerrar la conexión cuando la aplicación se detenga. Vuelva a abrir el archivo main.py y reemplace su contenido con lo siguiente:

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]
    print("Connected to the MongoDB database!")

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

El proceso de uvicorn detectará el cambio de archivo y reiniciará el servidor. Debería ver el mensaje 'Conectado a la base de datos MongoDB!' en la terminal.

Cree modelos para solicitudes y respuestas de API

MongoDB tiene un modelo de esquema flexible que permite tener documentos con estructuras diferentes dentro de la misma colección. En la práctica, los documentos de una colección suelen compartir la misma estructura. Si es necesario, usted puede incluso aplicar reglas de validación por colección. No cubriremos la validación de bases de datos en nuestro tutorial de PyMongo. En cambio, nos aseguraremos de que los datos que pasan a través de la REST API sean válidos antes de almacenarlos en la base de datos.

Crearemos un par de modelos para las solicitudes y respuestas de la API y dejaremos que FastAPI haga el trabajo pesado por nosotros. El framework se encargará de la validación, de convertir a los tipos de datos correctos e incluso de generar la documentación de la API. Abra el archivo models.py y añada lo siguiente:

pymongo-fastapi-crud/models.py

Code Snippetimport uuid
from typing import Optional
from pydantic import BaseModel, Field

class Book(BaseModel):
    id: str = Field(default_factory=uuid.uuid4, alias="_id")
    title: str = Field(...)
    author: str = Field(...)
    synopsis: str = Field(...)

    class Config:
        allow_population_by_field_name = True
        schema_extra = {
            "example": {
                "_id": "066de609-b04a-4b30-b46c-32537c7f1f6e",
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "..."
            }
        }

class BookUpdate(BaseModel):
    title: Optional[str]
    author: Optional[str]
    synopsis: Optional[str]

    class Config:
        schema_extra = {
            "example": {
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "Don Quixote is a Spanish novel by Miguel de Cervantes..."
            }
        }

Estamos extendiendo el BaseModel del paquete pydantic y añadiendo los campos para nuestros modelos. Para el modelo de libro, tenemos cuatro campos obligatorios: id, título, autor y sinopsis. El campo id se completa automáticamente con un UUID (identificador único universal). También tenemos un ejemplo para el modelo Book que se mostrará en la documentación de la API.

Los campos en el modelo BookUpdate son opcionales. Eso nos permitirá realizar actualizaciones parciales. No tenemos un campo de id en el modelo BookUpdate porque no queremos permitir que el usuario actualice el id.

Ahora que tenemos nuestros modelos definidos, implementemos los endpoints de la REST API y utilicemos los modelos para validar los datos.

Implemente los endpoints de la REST API

¡Es hora de la parte divertida! ¡Construyamos los endpoints de la API REST para nuestros libros! Añadiremos la implementación de los endpoints en el archivo routes.py, y cargaremos las rutas en el archivo main.py. Comenzaremos por inicializar un objeto APIRouter en routes.py:

pymongo-fastapi-crud/routes.py

Code Snippetfrom fastapi import APIRouter, Body, Request, Response, HTTPException, status
from fastapi.encoders import jsonable_encoder
from typing import List

from models import Book, BookUpdate

router = APIRouter()

Como habrá notado, estamos importando APIRouter desde el paquete fastapi. Utilizaremos este objeto para definir los endpoints de nuestra REST API. También estamos importando los modelos Book y BookUpdate que hemos definido anteriormente.

publicación /book

El primer endpoint que implementaremos es el endpoint publicación /books para crear un nuevo libro. Añada lo siguiente después de la línea router = APIRouter():

pymongo-fastapi-crud/routes.py

Code Snippet@router.post("/", response_description="Create a new book", status_code=status.HTTP_201_CREATED, response_model=Book)
def create_book(request: Request, book: Book = Body(...)):
    book = jsonable_encoder(book)
    new_book = request.app.database["books"].insert_one(book)
    created_book = request.app.database["books"].find_one(
        {"_id": new_book.inserted_id}
    )

    return created_book

La ruta es / porque antepondremos /books a todos los puntos finales de los libros. La descripción_de_respuesta se mostrará en la documentación de la API. El código de estado HTTP es el código de estado que se devuelve cuando la solicitud es exitosa. Utilizamos el modelo Book para validar tanto los datos pasados en el cuerpo de la solicitud como la respuesta que enviamos de vuelta. FastAPI gestiona la validación para nosotros. En el cuerpo de la función, estamos utilizando el método insert_one() de PyMongo para añadir el nuevo libro a la colección de libros. Estamos utilizando el método find_one() para recuperar el libro recién creado de la base de datos. Puede leer más sobre los métodos insert_one() y find_one() en el artículo de la documentación de PyMongo para operaciones a nivel de colección.

Finalmente, estamos devolviendo el libro creado.

GET /book

Lo siguiente, implementaremos el endpoint GET /book para devolver una lista con todos los documentos de la colección de libros. Añada lo siguiente al final del archivo routes.py:

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/", response_description="List all books", response_model=List[Book])
def list_books(request: Request):
    books = list(request.app.database["books"].find(limit=100))
    return books

Para el modelo de respuesta, estamos utilizando el tipo List[Book]. Esto significa que la respuesta será una lista de objetos de tipo Libro. También estamos utilizando el método find() para recuperar no más de 100 libros de la base de datos. Para aprender más sobre limit y los demás parámetros del método find(), consulte la página de documentación dedicada de PyMongo.

GET /book/{id}

Vamos a crear otro endpoint GET para recuperar un único libro por su id. Añada lo siguiente al final del archivo routes.py:

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/{id}", response_description="Get a single book by id", response_model=Book)
def find_book(id: str, request: Request):
    if (book := request.app.database["books"].find_one({"_id": id})) is not None:
        return book
    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Aquí, estamos utilizando el método find_one() para recuperar un único libro de la base de datos. Si se encuentra el libro, lo devolveremos. Si no se encuentra el libro, generaremos una HTTPException con un código de estado 404 Not Found y un mensaje apropiado.

PUT /book/{id}

Probablemente, el punto final más importante para nuestra REST API es el punto final PUT /book/{id}. Este punto de conexión nos permite actualizar un solo libro. Agregue la implementación al final del archivo routes.py:

pymongo-fastapi-crud/routes.py

Code Snippet@router.put("/{id}", response_description="Update a book", response_model=Book)
def update_book(id: str, request: Request, book: BookUpdate = Body(...)):
    book = {k: v for k, v in book.dict().items() if v is not None}
    if len(book) >= 1:
        update_result = request.app.database["books"].update_one(
            {"_id": id}, {"$set": book}
        )

        if update_result.modified_count == 0:
            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

    if (
        existing_book := request.app.database["books"].find_one({"_id": id})
    ) is not None:
        return existing_book

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Repasemos el código. Primero, estamos construyendo un objeto que usaremos para actualizar el libro. Luego, si hay campos en el objeto libro, estamos usando el método update_one() para actualizar el libro en la base de datos. Es importante tener en cuenta que estamos utilizando el Operador de actualización $set para asegurarnos de que solo se actualicen los campos especificados en lugar de reescribir todo el documento.

Luego, verificamos el atributo modified_count del update_result para asegurarnos de que el libro fue actualizado. Si ese es el caso, estamos utilizando el método find_one() para recuperar el libro actualizado de la base de datos y devolverlo.

Si no hay campos en el objeto del libro, simplemente devolvemos el libro existente. Sin embargo, si no se encuentra el libro, generaremos una HTTPException con un código de estado 404 Not Found.

borrar /book/{id}

El último endpoint que implementaremos es el endpoint DELETE /book/{id} para borrar un solo libro por su id. Añada lo siguiente al final del archivo routes.py:

pymongo-fastapi-crud/routes.py

Code Snippet@router.delete("/{id}", response_description="Delete a book")
def delete_book(id: str, request: Request, response: Response):
    delete_result = request.app.database["books"].delete_one({"_id": id})

    if delete_result.deleted_count == 1:
        response.status_code = status.HTTP_204_NO_CONTENT
        return response

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Lo único notable aquí es que si se borrara el libro, estamos devolviendo un código de estado 204 No Content. Este es un código de estado de éxito que indica que la solicitud se ha completado con éxito y que no hay contenido para enviar en el cuerpo de la respuesta.

Registre el

Finalmente, necesitamos registrar los endpoints de /book. Abra el archivo main.py, importe el módulo de rutas y registre el enrutador de libros. Su versión final del archivo main.py debería verse así:

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient
from routes import router as book_router

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

app.include_router(book_router, tags=["books"], prefix="/book")

Explore la página de documentación de la API y pruebe los endpoints

Asegúrese de que su proceso de uvicorn siga funcionando antes de continuar. Si no es así, puede comenzar con el mismo comando en la terminal:

Code Snippet

Navegue a la URL http://localhost:8000/docs en su navegador. ¡Esta es la página de documentación de la API que FastAPI y Swagger generaron para nosotros!

Podemos ver todos los endpoints que creamos e incluso podemos enviar solicitudes directamente desde esta página. Abra la pestaña publicación y haga clic en el botón Probar. Debería ver un cuerpo de solicitud prellenado con nuestro libro de ejemplo. Haga clic en Ejecutar para enviar la solicitud. Debería ver una respuesta exitosa con el libro que creamos. Puede obtener el id del libro de la respuesta y utilizarlo en uno de los otros puntos finales: GET /book/{id}, PUT /book/{id} o borrar /book/{id}.

Pero, ¿y si intentamos crear el mismo libro dos veces? Obtendremos una respuesta de error interno del servidor 500. Si comprobamos el terminal donde se está ejecutando el proceso del servidor, deberíamos ver un mensaje de error que contenga lo siguiente:

Code Snippetpymongo.errors.DuplicateKeyError: E11000 duplicate key error collection: pymongo_tutorial.books index: _id

Hemos recibido un DuplicateKeyError porque intentamos insertar un libro con el mismo campo _id dos veces. El campo _id es un índice único que MongoDB crea para cada colección. No podemos tener dos libros con el mismo _id. El problema real aquí es que no estamos manejando este error en nuestro código. El error 'bulle hacia arriba' y el servidor responde con un error 500 de servidor interno. Como ejercicio, puede pensar en una respuesta adecuada para enviar al cliente y gestionar este error.

También puede probar las reglas de validación que hemos creado. Por ejemplo, intente Remover el campo de título obligatorio del cuerpo de la Solicitud y haga clic en Ejecutar. Debería ver un mensaje de error que indica que el campo 'título' es obligatorio.

La página de documentación generada de la API es muy útil para probar diferentes escenarios y observar cómo se comporta la API. ¡Diviértase explorando la API que hemos compilado!

Conclusión

En este tutorial, vimos cómo crear una aplicación CRUD simple con FastAPI y PyMongo, el controlador oficial de MongoDB para aplicaciones síncronas de Python. También vimos cómo podemos configurar rápidamente un MongoDB Atlas cluster y conectarnos a él. MongoDB Atlas es mucho más que una simple base de datos en la cloud de MongoDB. Por ejemplo, puede ampliar fácilmente su API para ofrecer una búsqueda en texto completo con Atlas Search. Todos estos servicios están disponibles en MongoDB Atlas. Si desea probarlos, cree su cuenta gratuita.

Preguntas frecuentes

PyMongo es el controlador oficial de MongoDB para aplicaciones síncronas de Python. Puede conectarse a una instancia de MongoDB y hacer una query de datos. Es una herramienta estupenda para desarrollar aplicaciones que interactuar con MongoDB.

PyMongo es un paquete de Python. Puede instalarlo con `pip`: `python -m pip install pymongo[srv]`.

Una vez que haya instalado PyMongo, puede importarlo a su aplicación, conectarlo a una instancia de MongoDB y empezar a consultar datos.

PyMongo es el controlador oficial de MongoDB para Python, mientras que MongoEngine es un ORM (Mapeador Relacional de Objetos) que utiliza PyMongo internamente. PyMongo cuenta con el respaldo y la recomendación oficiales de MongoDB. Lea más sobre las diferencias entre los dos en el artículo dedicado

Comience a usar Atlas hoy mismo

Comience en cuestión de segundos. Nuestros clústeres gratuitos vienen con 512 MB de almacenamiento para que pueda jugar con datos de muestra y orientarse con nuestra plataforma.

Probar gratisContactar a ventas

PRIMEROS PASOS CON:

Más de 125 regiones en todo el mundo
Conjuntos de datos de muestra
Autenticación siempre activa
Cifrado de extremo a extremo

Herramientas de línea de comandos

¿Qué es PyMongo? Introducción a Python y MongoDB

Aplicación CRUD para la gestión de libros

Requisitos

Configuración e instalación del proyecto

Conéctese a su MongoDB Atlas cluster

Cree modelos para solicitudes y respuestas de API

Implemente los endpoints de la REST API

publicación /book

GET /book

GET /book/{id}

PUT /book/{id}

borrar /book/{id}

Registre el

Explore la página de documentación de la API y pruebe los endpoints

Conclusión

Preguntas frecuentes

¿Qué puede hacer usted con PyMongo?

¿Cómo descargo e instalo PyMongo?

¿Cómo se utiliza PyMongo?

¿Debería usar PyMongo o MongoEngine?

Comience a usar Atlas hoy mismo