Construindo APIs RESTful com FastAPI: um guia prático para iniciantes sobre estruturação, autenticação e testes

Introdução

Neste tutorial, você aprenderá a criar uma API RESTful utilizando o FastAPI, um framework moderno de Python que permite desenvolver APIs de forma rápida e eficiente. Vamos explorar as melhores práticas para estruturar sua aplicação, implementar autenticação, realizar testes e garantir que sua API seja robusta e escalável. Este guia prático é voltado para iniciantes que desejam começar a trabalhar com FastAPI e construir aplicações web de qualidade, aproveitando a alta performance e a facilidade de uso que este framework oferece.

Etapas

Configuração do Ambiente de Desenvolvimento
Antes de iniciar, verifique se o Python está instalado em sua máquina. Você pode verificar isso executando ‘python –version’ no terminal. Em seguida, crie um ambiente virtual e instale o FastAPI e o Uvicorn, um servidor ASGI que irá executar sua aplicação.
commands
```
# Verificar versão do Python
python --version
# Criar um ambiente virtual
python -m venv venv
# Ativar o ambiente virtual (Windows)
venv\Scripts\activate
# Ativar o ambiente virtual (Linux/Mac)
source venv/bin/activate
# Instalar FastAPI e Uvicorn
pip install fastapi uvicorn
```
Estruturação do Projeto
Crie a estrutura básica do seu projeto com diretórios para rotas, modelos e serviços. Esta organização facilita a manutenção do código. O exemplo abaixo mostra uma estrutura básica.
commands
```
# Criar diretórios
mkdir app
cd app
mkdir routes models services
```
Criação do Modelo `Item`
Crie o modelo `Item`, que representará os dados de um produto. Vamos usar Pydantic para validar os dados de entrada.
Item.py
```
from pydantic import BaseModel

class Item(BaseModel):
    id: int
    name: str
    price: float
    description: str = None
```

Implementação da Rota de Item

Crie um arquivo chamado `item_routes.py` dentro do diretório ‘routes’. Este arquivo conterá as rotas para operar sobre os itens criados.

item_routes.py

from fastapi import APIRouter
from models.Item import Item

router = APIRouter()

items = []

@router.post('/items/', response_model=Item)
def create_item(item: Item):
    items.append(item)
    return item

@router.get('/items/')
def get_items():
    return items

Criação do Arquivo Principal

Crie um arquivo chamado `main.py` que irá inicializar a aplicação FastAPI e incluir as rotas definidas.

main.py

from fastapi import FastAPI
from routes.item_routes import router

app = FastAPI()

app.include_router(router, prefix='/api')

@app.get('/')
def read_root():
    return {'message': 'Hello, World!'}

Autenticação com JWT

Implemente autenticação simples usando JWT (JSON Web Tokens). Instale a biblioteca necessária e crie um arquivo `auth.py` para gerenciar a autenticação.

commands

# Instalar biblioteca PyJWT
pip install PyJWT

auth.py

import jwt
from datetime import datetime, timedelta

SECRET_KEY = 'your_secret_key'
EXPIRE_MINUTES = 30

def create_jwt_token(data):
    to_encode = data.copy()
    expire = datetime.utcnow() + timedelta(minutes=EXPIRE_MINUTES)
    to_encode.update({'exp': expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm='HS256')

def decode_jwt_token(token):
    return jwt.decode(token, SECRET_KEY, algorithms=['HS256'])

Implementação dos Testes Unitários

Crie testes unitários para verificar o funcionamento das rotas utilizando o `pytest` e o `httpx` para simular requisições HTTP.

commands

# Instalar pytest e httpx
pip install pytest httpx

test_item.py

from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_create_item():
    response = client.post('/api/items/', json={'id': 1, 'name': 'Sample Item', 'price': 10.0})
    assert response.status_code == 200
    assert response.json() == {'id': 1, 'name': 'Sample Item', 'price': 10.0}


def test_get_items():
    response = client.get('/api/items/')
    assert response.status_code == 200
    assert isinstance(response.json(), list)

Executando a Aplicação e Testes
Utilize o Uvicorn para executar a aplicação e o pytest para rodar os testes que você implementou.
commands
```
# Executar a aplicação
uvicorn main:app --reload
# Rodar testes
pytest
```

Conclusão

Neste tutorial prático, você aprendeu como construir uma API RESTful utilizando FastAPI, incluindo a configuração do ambiente, a criação de rotas e modelos, a implementação de autenticação com JWT e a realização de testes unitários. Agora que você compreende as etapas essenciais para construir uma API robusta, pode expandir suas aplicações e aprimorar seus conhecimentos em Python e FastAPI.

Hashtags

#FastAPI #Python #APIs #DesenvolvimentoWeb #JWT #TestesUnitários

copycoda.com.br