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 destaca-se como uma opção de topo 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 escalá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 armazenar e gerenciar dados, as bases de dados NoSQL oferecem flexibilidade e escalabilidade, tornando-as uma ótima escolha 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 tem os seguintes:

• Um servidor rodando 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 de essa lista e siga com nossa 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 sobre a linha de comando, você pode visitar este guia sobre Primeiro Passo no Linux – Linha de Comando.

• 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 – Criar Ambiente Virtual

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 êxito a menos que você trabalhe dentro de um ambiente virtual.

Neste passo, você criará um ambiente virtual para o seu projeto, que isolará as dependências do seu projeto para evitar conflitos entre versões diferentes de pacotes. 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 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:

(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 êxito.

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, vamos usar o MongoDB como base 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 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 depois de configurar as 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

Após a execução, você será solicitado a reiniciar os serviços. Após o reinício, instale o MongoDB usando o seguinte comando:

sudo apt-get install -y mongodb

Inicie e habilite 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

Assumindo que a mycollection de mydatabase está populada com algumas informações, 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ões de IA 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 e modelo simples
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

# rota_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))

# rota_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

# rota_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 a partir de Modelo Pydantic: Isto 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 de API interativa 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 na 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 containerizar seu aplicativo e executá-lo usando docker-compose. Containerizar seu aplicativo simplifica o processo de implantação, tornando seu aplicativo mais fácil de implantar, dimensionar e manter. Para definir seu aplicativo como um Dockerfile, siga os passos mencionados em Deploy FastAPI Application using Docker Compose.

Conclusão

Neste tutorial, você aprendeu como configurar com sucesso um aplicativo FastAPI com MongoDB, criando um simples aplicativo baseado em AI 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 aplicativos驱动器 por AI.