Introdução

Neste tutorial, você aprenderá a desenvolver uma API RESTful usando o framework FastAPI e o banco de dados MongoDB. Mostraremos passo a passo como configurar seu ambiente de desenvolvimento, criar o projeto do zero, implementar a lógica da API, realizar operações CRUD e adicionar testes unitários. FastAPI é um framework moderno que facilita a construção de APIs rápidas e de fácil manutenção, enquanto o MongoDB fornece uma solução de banco de dados flexível e escalável. Este guia é ideal para iniciantes que desejam aprender sobre desenvolvimento de APIs com Python e MongoDB, proporcionando uma base sólida e prática.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o Python 3.7 ou superior instalado em sua máquina. Você também precisará ter o MongoDB em execução. Para instalar as bibliotecas necessárias, use o seguinte comando para instalar o FastAPI e o motor de servidor Uvicorn.

    commands
    # Verifique a versão do Python
    python --version
    # Instale FastAPI e Uvicorn
    pip install fastapi uvicorn pymongo

  2. Estrutura do Projeto FastAPI

    Crie uma nova pasta para o seu projeto e dentro dela crie os arquivos principais. A estrutura básica do projeto será a seguinte:

    “`
    /my_fastapi_app
    ├── main.py
    ├── models.py
    ├── schemas.py
    ├── database.py
    └── tests.py
    “`

    O arquivo `main.py` é onde executaremos o aplicativo FastAPI.

    commands
    mkdir my_fastapi_app
    cd my_fastapi_app
    touch main.py models.py schemas.py database.py tests.py

  3. Configuração do Banco de Dados MongoDB

    No arquivo `database.py`, configure a conexão com o MongoDB. Substitua ‘mongodb://localhost:27017’ pela URI do seu banco de dados MongoDB, caso ela seja diferente.

    database.py
    from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017')
db = client['mydatabase']  # Nome do seu banco de dados

  4. Definição do Modelo de Dados

    Crie um modelo de dados para a sua aplicação no arquivo `models.py`. Aqui, usamos classes para representar os dados que iremos armazenar no MongoDB.

    models.py
    from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str
    price: float
    quantity: int

  5. Implementando os Endpoints da API

    Agora, vamos criar a lógica da API no arquivo `main.py`. Adicione os endpoints para criar, ler, atualizar e deletar itens.

    main.py
    from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from models import Item
from database import db

app = FastAPI()

@app.post('/items/')
async def create_item(item: Item):
    result = db.items.insert_one(item.dict())
    item.id = str(result.inserted_id)
    return item

@app.get('/items/')
async def read_items():
    items = list(db.items.find())
    return items

@app.get('/items/{item_id}')
async def read_item(item_id: str):
    item = db.items.find_one({'_id': item_id})
    if item:
        return item
    raise HTTPException(status_code=404, detail='Item not found')

@app.put('/items/{item_id}')
async def update_item(item_id: str, item: Item):
    result = db.items.update_one({'_id': item_id}, {'$set': item.dict()})
    if result.modified_count:
        return item
    raise HTTPException(status_code=404, detail='Item not found')

@app.delete('/items/{item_id}')
async def delete_item(item_id: str):
    result = db.items.delete_one({'_id': item_id})
    if result.deleted_count:
        return {'detail': 'Item deleted'}
    raise HTTPException(status_code=404, detail='Item not found')

  6. Executando a Aplicação

    Utilize o Uvicorn para iniciar o servidor. Execute o seguinte comando no terminal para iniciar a aplicação FastAPI.

    commands
    # Executar a aplicação FastAPI
    uvicorn main:app --reload

  7. Testando a API

    Você pode usar ferramentas como Postman ou cURL para testar os endpoints da API. Aqui estão alguns exemplos de como interagir com a API usando cURL.

    curl_examples
    # Criar um novo item
    curl -X POST 'http://localhost:8000/items/' -H 'Content-Type: application/json' -d '{"name": "Item 1", "description": "Um item de teste", "price": 10.99, "quantity": 5}'
    # Listar todos os itens
    curl -X GET 'http://localhost:8000/items/'
    # Atualizar um item
    curl -X PUT 'http://localhost:8000/items/{item_id}' -H 'Content-Type: application/json' -d '{"name": "Item 1", "description": "Atualizado", "price": 12.99, "quantity": 10}'
    # Deletar um item
    curl -X DELETE 'http://localhost:8000/items/{item_id}'

  8. Implementação de Testes Unitários

    Crie o arquivo `tests.py` e adicione testes unitários para validar os endpoints da API utilizando a biblioteca pytest.

    tests.py
    from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_create_item():
    response = client.post('/items/', json={'name': 'Test', 'description': 'Test item', 'price': 10.99, 'quantity': 1})
    assert response.status_code == 200

def test_read_items():
    response = client.get('/items/')
    assert response.status_code == 200

  9. Executando os Testes

    Para executar os testes, você pode usar o pytest. No terminal, execute o seguinte comando para rodar os testes unitários da aplicação.

    commands
    # Para rodar os testes
    pytest tests.py

Conclusão

Neste tutorial, você aprendeu a desenvolver uma API RESTful utilizando FastAPI e MongoDB. Passamos por todas as etapas, desde a configuração do ambiente até a implementação de testes unitários para garantir o funcionamento correto da aplicação. Com essa experiência prática, você está pronto para explorar ainda mais o desenvolvimento de APIs em Python e integrar outras funcionalidades a seus projetos.

Hashtags

#Python #FastAPI #MongoDB #APIs #DesenvolvimentoDeSoftware