Construir uma API REST geralmente é uma tarefa mecânica, envolvendo muito design clichê e programação automática. Felizmente, ferramentas como FastAPI podem aliviar muitos detalhes tediosos.
Usando FastAPI, você pode criar rapidamente uma API REST eficiente e completa para seu aplicativo CRUD. Com o MongoDB como fonte de dados, este tutorial irá guiá-lo para configurar sua própria API rapidamente.
O que é FastAPI?
FastAPI é uma estrutura da web Python rápida e de código aberto para criar APIs. Ele fornece suporte integrado para solicitações assíncronas, validação automática de dados e documentação automática de endpoints de API.
As vantagens do FastAPI sobre outros frameworks Python
- FastAPI é relativamente mais rápido que outros frameworks como Django e Flask. Isso ocorre porque o FastAPI se baseia no asyncio, uma biblioteca de E/S assíncrona para Python que pode processar solicitações simultâneas com mais rapidez.
- FastAPI fornece uma maneira limpa e simples de criar APIs com esforço mínimo, pois requer menos código do que Flask ou Django.
- Por fim, o FastAPI facilita a geração de documentação para endpoints. Ele usa o Swagger para produzir documentação que você pode usar para testar endpoints executando solicitações e exibindo respostas.
Configurar um banco de dados MongoDB
Para começar, você precisará configurar o banco de dados MongoDB localmente. Alternativamente, você pode optar pela opção mais fácil de configurando um cluster MongoDB na nuvem.
Em seguida, usando a ferramenta de interface gráfica do usuário MongoDB instalada, Compass, crie uma conexão de banco de dados. Clique no Nova Conexão botão e forneça o URI de conexão para estabelecer uma conexão com o servidor MongoDB em execução localmente.
Por fim, crie um novo banco de dados e uma coleção para armazenar os dados da API de teste.
Configurar um servidor FastAPI
Usando um terminal, crie uma pasta de projeto e insira esse novo diretório.
Você pode encontrar o código deste projeto em seu Repositório GitHub.
Em seguida, verifique se você está executando o Python versão 3.6+. Se não, instale o mais recente Pitão versão.
python --versãoDepois, instale o Virtualenv para criar um ambiente de desenvolvimento virtual isolado. Isso é altamente recomendado porque permite evitar conflitos, especialmente se você estiver usando diferentes versões de pacotes para diferentes projetos.
pip instalar virtualenvEm seguida, crie um ambiente virtual chamado "venv" dentro do seu diretório atual:
virtualenv venvPor fim, ative o ambiente virtual.
# No Unix ou MacOS:
fonte venv/bin/ativar
# No Windows:
.\venv\Scripts\ativar
Depois de configurar o ambiente virtual, instale os pacotes FastAPI, PyMongo e Uvicorn.
pip instalar fastapi pymongo uvicornPyMongo é uma biblioteca baseada em Python para trabalhar com o banco de dados MongoDB. Ele fornece uma API que oferece suporte a todos os recursos do MongoDB e permite que você interaja com o MongoDB sem precisar escrever consultas brutas do MongoDB.
O Uvicorn, por outro lado, é um servidor web assíncrono baseado no módulo assíncrono do Python. Sua principal característica é recarregar seus servidores FastAPI em movimento. Usando Uvicorn, é semelhante a trabalhando com Nodemon.
Criar o servidor FastAPI
Por fim, crie um servidor FastAPI simples que receba solicitações provenientes da rota inicial. No diretório raiz da pasta do seu projeto, crie um arquivo server.py e adicione o código abaixo.
de fastapi importar FastAPI
aplicativo = FastAPI()
@app.get("/")
assíncronodeflar():
retornar {"mensagem": "Olá Mundo"}
Por fim, execute o comando abaixo para ativar o servidor de desenvolvimento. O Uvicorn servirá seu aplicativo na porta 8000.
servidor uvicon: app --reloadVá em frente e visualize a resposta do servidor em seu navegador em http://localhost: 8000.
Crie a API REST com operações CRUD
Agora crie a API REST que implementa os métodos CRUD (criar, ler, atualizar e excluir). No diretório raiz da pasta do seu projeto, crie quatro pastas: config, models, routes e schemas.
├── configuração
├── modelos
├── rotas
├── esquemas
└── servidor.py1. Configurar a conexão do banco de dados
No diretório config, crie um novo arquivo, db.py, e adicione o código abaixo.
de pimongo importar MongoClientName
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_connection.database_name
coleção = db["coleção_nome"]- Use o método MongoClient() para criar uma conexão com um banco de dados MongoDB. Ele usa uma string URI de conexão como um argumento que especifica o host e a porta do servidor MongoDB.
- As duas variáveis especificam qual banco de dados e coleção em seu servidor MongoDB o servidor deve acessar.
2. Definir um modelo de dados
Este modelo definirá a estrutura de seus dados no banco de dados, incluindo os campos e tipos de dados.
No diretório do modelo, crie um novo arquivo, user_model.py, e adicione o código abaixo.
de pidantico importar BaseModel
aulaDo utilizador(BaseModelo):
nome: str
função: estre
- O código acima cria uma classe chamada User, que é uma subclasse da classe BaseModel da biblioteca Pydantic. A classe User tem dois campos, nome e função com seus tipos de dados definidos como strings.
- Você pode usar a biblioteca Pydantic com FastAPI para criar modelos de dados. Você também pode usá-lo para validar dados, serializá-los (JSON para Python) e desserializá-los (Python para JSON).
3. Definir um esquema de dados
A partir do modelo de dados criado, você pode definir o esquema para seus dados. No diretório schemas, crie um novo arquivo: user_schema.py, e adicione o código abaixo.
defuser_serializer(do utilizador) -> ditado:
retornar {
'eu ia':str (usuario["_eu ia"]),
'nome':do utilizador["nome"],
'papel':do utilizador["papel"]
}
defusers_serializer(Usuários) -> lista:
retornar [user_serializer (usuário) para do utilizador em Usuários]
4. Definir as rotas da API
Finalmente, defina as rotas para as diferentes operações CRUD.
No diretório de rotas, crie um novo arquivo: user_routes.py e adicione o código abaixo.
Adicionar dados com o método Post
Crie a rota de postagem para adicionar dados.
de fastapi importar APIRouter
de models.user_model importar Do utilizador
de schemas.user_schema importar users_serializer
de bson importar ObjectId
de config.db importar coleçãousuario = APIRouter()
@user.post("/")
assíncronodefcriar_usuário(usuário: usuário):
_id = collection.insert_one (dict (usuário))
usuário = users_serializer (collection.find({"_eu ia": _id.inserted_id}))
retornar {"status": "OK","dados": do utilizador}
- FastAPI fornece o método APIRouter() que define um objeto roteador que fornece uma interface para fazer solicitações de API a um servidor.
- Especifique uma pós-rota que crie um novo objeto de usuário no banco de dados inserindo os dados na coleção após serializá-la. Em seguida, armazene e passe o insert_id para encontrar os dados do associado na coleção e, por fim, retorne um status de "Ok" com os dados na resposta, caso o post request seja bem-sucedido.
- Os métodos insert_one e find são definidos pelo cliente PyMongo.
Agora, adicione o código abaixo ao server.py para inicializar as rotas.
de rotas.user_routes importar do utilizador
app.include_router (usuário)Vá em frente e teste a rota de postagem em seu navegador usando a ferramenta Swagger UI API fornecida pela FastAPI.
Ler dados com o método Get
Após definir a pós-rota e inicializar as rotas, defina o restante das outras rotas.
@user.get("/")
assíncronodefencontrar_todos_usuários():
users = users_serializer (collection.find())
retornar {"status": "OK","dados": Usuários}
@user.get("/{id}")
assíncronodefget_one_user(id: str):
usuário = users_serializer (collection.find({"_eu ia": ObjectId (id)}))
retornar {"status": "OK","dados": do utilizador}Defina duas rotas get que recuperam todos os dados da coleção e recuperam dados específicos da coleção com base no ID.
Atualizar dados com o método Put
Crie a rota put para atualizar os dados armazenados no banco de dados.
@user.put("/{id}")
assíncronodefupdate_user(id: str, usuário: usuário):
coleção.find_one_and_update(
{
"_eu ia": ObjectId (id)
},
{
"$definir": dict (usuário)
})
usuário = users_serializer (collection.find({"_eu ia": ObjectId (id)}))
retornar {"status": "OK","dados": do utilizador}O método put usa o ID para localizar os dados específicos na coleção e atualiza o valor dos campos no documento com os novos dados transmitidos pela API. Você pode pesquisar os dados atualizados por ID e retorná-los na resposta da API.
Excluir dados com o método Delete
Crie a rota de exclusão para excluir os dados armazenados no banco de dados.
@user.delete("/{id}")
assíncronodefdeletar usuário(id: str):
coleção.find_one_and_delete({"_eu ia": ObjectId (id)})
users = users_serializer (collection.find())
retornar {"status": "OK","dados": []} A rota de exclusão leva o ID do documento específico que você deseja excluir da coleção.
Crie APIs REST com FastAPI
O FastAPI fornece uma ótima maneira de criar convenientemente APIs da web Python de back-end. Suas ferramentas integradas para integração de banco de dados e produção automática de API tornam o processo simples.
Você pode até dar um passo adiante e criar aplicativos completos. Tente integrar um cliente front-end usando tecnologias populares como React, Angular ou Vue.