Como Configurar uma Aplicação de API Rápida com um Banco de Dados NoSQL

Introdução

Quando desenvolvemos aplicações em Python, o FastAPI é uma escolha de primeira linha para construir soluções de alto desempenho. Ele oferece velocidade, simplicidade e suporte para programação assíncrona, tornando-o ideal para desenvolver aplicações modernas, escalonáveis.
Neste tutorial, vamos guiar você pelo processo de configuração de uma aplicação FastAPI com uma base de dados NoSQL. Quando se trata de armazenamento e gerenciamento de dados, as bases de dados NoSQL oferecem flexibilidade e escalabilidade, tornando-as um ótimo conjunto para aplicações que precisam lidar com estruturas de dados diversas e complexas.

Pré-requisitos

Antes de começar, você precisa certificar-se de que você tem o seguinte:

• Um servidor executando o Ubuntu, juntamente com um usuário não-root com privilégios de sudo e uma firewall ativa. Para orientação sobre como configurar isso, por favor escolha sua distribuição da lista e siga com o guia de configuração inicial do servidor. Certifique-se de trabalhar com uma versão suportada do Ubuntu.

• Familiaridade com a linha de comando do Linux. Para uma introdução ou atualização das informações sobre a linha de comando, você pode visitar este guia sobre primeiro Linux command line.

• Execute sudo apt-get update no terminal do Ubuntu para certificar-se que o seu sistema tem as versões mais recentes e atualizações de segurança para o software disponível nos repositórios configurados no seu sistema.

Passo 1 – Configurar o Ambiente Python no Seu Computador

Throughout this tutorial, we will be using the python3 package to run commands. The latest Ubuntu versions come with Python 3 installation, so to verify its installation, run the following command:

python3 --version

In case this returns an error, you can install/re-install the package by running:

sudo apt-get install python3

Next, you need to install the pip to install Python packages and their dependencies in a secure manner.

sudo apt-get install python3-pip

Step 2 – Create Virtual Environment

A partir de Python 3.11 e pip 22.3, existe uma nova PEP 668 que define a marcação de ambientes básicos do Python como “gerenciados externamente”, o que significa que você não será capaz de usar pip para instalar pacotes com sucesso a menos que você trabalhe dentro de um ambiente virtual.

Neste passo, você criará um ambiente virtual para seu projeto, que isolará as dependências do seu projeto para evitar conflitos entre versões de pacotes diferentes. Execute o seguinte conjunto de comandos no terminal:

sudo apt-get install python3-venv

Isso instalará o pacote necessário venv necessário para criar um ambiente virtual.

python3 -m venv fastapi-env

Este comando criará um ambiente virtual fastapi-env dentro do seu diretório de trabalho. Para começar a trabalhar dentro deste ambiente, você precisa ativá-lo.

source fastapi-env/bin/activate

Após a execução bem-sucedida, você verá o prompt do terminal com o prefixo como este:

(fastapi-env) user@machine:~$

Agora, você pode começar a instalar as dependências necessárias neste ambiente virtual.

Passo 3 – Instalar Bibliotecas e Pacotes Necessários

Neste passo, você instalará alguns pacotes e bibliotecas que são necessários para seguir este tutorial com sucesso.

Vamos começar instalando o fastapi, que é necessário para construir o seu aplicativo FastAPI, e o uvicorn, que é necessário para executar o aplicativo FastAPI.

pip install fastapi uvicorn

Neste tutorial, usaremos o MongoDB como banco de dados NoSQL. Para interagir com o MongoDB a partir do seu FastAPI, você precisa instalar o motor, que é um driver assíncrono em Python para o MongoDB.

pip install motor

Passo 4 – Instalar e Configurar o MongoDB no Ubuntu

Para instalar o MongoDB em sua máquina Ubuntu, execute o seguinte conjunto de comandos no terminal:

wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

Após a execução bem-sucedida, isso retorna o parâmetro echo. Agora, faça um rápido:

sudo apt-get update

Isso garantirá que você obtenha as últimas atualizações após a configuração das chaves do MongoDB.

A seguir, você precisa instalar uma dependência de openssl no seu sistema, que é necessário para a instalação do MongoDB.

wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2_amd64.deb
sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2_amd64.deb

Upon execution, you will be asked to restart services. After restarting, install MongoDB using the following command:

sudo apt-get install -y mongodb

Inicie e ative os serviços do MongoDB:

sudo systemctl start mongod
sudo systemctl enable mongod

Você pode verificar o status do serviço do MongoDB e testar a conexão executando os seguintes comandos:

sudo systemctl status mongod

mongo --eval 'db.runCommand({connectionStatus: 1})'

Passo 5 – Criar Aplicação FastAPI

A próxima etapa é criar uma aplicação FastAPI. Em seu diretório de trabalho, crie um arquivo database.py:

nano database.py

Isso abre um editor de texto vazio. Escreva sua lógica de conexão com o banco de dados aqui.

from motor.motor_asyncio import AsyncIOMotorClient

MONGO_DETAILS = "mongodb://localhost:27017"

client = AsyncIOMotorClient(MONGO_DETAILS)

db = client.mydatabase

collection = db.mycollection

Ao assumir que a mycollection de mydatabase está populada com algum dado, você agora cria um main.py que contém a lógica da sua aplicação. Na seguinte aplicação FastAPI, uma conexão com o banco de dados é estabelecida usando database.py; as rotas para previsão por AI são definidas. Usando essas rotas, a entrada é validada.

nano main.py

No editor de texto, escreva a lógica:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sklearn.linear_model import LinearRegression
import numpy as np
from database import collection

app = FastAPI()

# conjunto de dados simples e modelo
x = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

model = LinearRegressions()
model.fit(x, y)

# define o modelo Pydantic para validação de entrada
class InputData(BaseModel):
  feature: float

# route_1 para prever a saída com base nas features de entrada
@app.post("/predict/")
async def predict(input_data: InputData):
  try:
    prediction = model.predict([[input_data.feature]])
    return {"prediction": prediction[0]}
  except Exception as ex:
    raise HTTPException(status_code=400, detail=str(ex))

# route_2 para interagir com o MongoDB
@app.get("/items/")
async def get_item():
  items = []
  async for item in collection.find():
    items.append(item)
  return items

# route_3 para adicionar um novo item ao MongoDB
@app.post("/items/")
async def create_item(item: dict):
  new_item = await collection.insert_one(item)
  created_item = await collection.fine_one({"_id": new_item.inserted_id})
  return created_item

Aqui está o resumo do que essa aplicação faz:

• Modelo de Regressão Linear do sklearn: Este modelo preve uma saída com base em uma única feature de entrada.
• Entrada de Dados de Modelo Pydantic: Isso define a estrutura de entrada esperada para o ponto de predição. Neste caso, é um float.
• Rotas MongoDB: As rotas /items/ e POST /items/ permitem que você recupere e insira itens na sua coleção MongoDB.

Passo 6 – Executar Aplicação FastAPI

Para executar corretamente esta aplicação, você precisa instalar as bibliotecas e pacotes usados na aplicação.

pip install pydantic scikit-learn numpy

Agora, use o comando seguinte para executar esta aplicação:

uvicorn main:app --reload

A saída deste comando será:

Output
INFO:     Will watch for changes in these directories: ['/path/to/your/project']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [XXXXX] using statreload
INFO:     Started server process [XXXXX]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

FastAPI automaticamente gerou uma documentação interativa de API usando Swagger UI. Você pode acessá-la navegando até http://127.0.0.1:8000/docs.

Você pode usar ferramentas como curl ou Postman para chamar o ponto final que prediz um valor com base em sua entrada.

curl -X POST "http://127.0.0.1:8000/predict/" -H "Content-type: application/json" -d '{"feature": 3}'

Passo 7 [OPCIONAL] – Executar Aplicação Usando Docker Compose

Você pode contêiner sua aplicação e executá-la usando docker-compose. Contêinerizar sua aplicação otimiza o processo de implantação, tornando sua aplicação mais fácil de implantar, dimensionar e manter. Para definir sua aplicação como um Dockerfile, siga os passos mencionados em Deploy FastAPI Application using Docker Compose.

Conclusão

Neste tutorial, você aprendeu como configurar com sucesso uma aplicação FastAPI com MongoDB, criando uma simples aplicação baseada em AI que é capaz de armazenar e recuperar previsões de entrada.

A combinação de FastAPI e um banco de dados não-relacional oferece um ambiente poderoso e flexível para construir e dimensionar aplicações baseadas em AI.