Desenvolvimento Web com FastAPI e Python

Introdução

O desenvolvimento web é um setor em constante evolução, com novas tecnologias e ferramentas emergindo regularmente. Nesse contexto, é fundamental ter conhecimento de uma linguagem de programação flexível e robusta que permita a criação de aplicativos escaláveis e eficientes.

Python é uma dessas linguagens, amplamente utilizada em diversas áreas do desenvolvimento de software, incluindo o desenvolvimento web. A biblioteca FastAPI, surgida recentemente, tem chamado a atenção de muitos profissionais por sua capacidade de criar API com baixo overhead e alta performance.

Nesse artigo, vamos explorar as funcionalidades e vantagens de utilizar FastAPI para desenvolver aplicativos web. Além disso, apresentaremos uma introdução ao framework e às suas principais características, preparando o leitor para seguir em frente e aprender como implementá-lo em projetos reais.

Ao final desse artigo, você estará capacitado a:

• Conhecer as principais características de FastAPI
• Entender como criar API com essa biblioteca
• Aprender sobre os recursos de desenvolvimento web oferecidos por FastAPI

Essa abordagem detalhada visa proporcionar uma compreensão sólida dos conceitos e técnicas necessárias para o uso eficaz de FastAPI no desenvolvimento de software.

O que é e por que importa

FastAPI é um framework de desenvolvimento web construído sobre a sintaxe moderna da linguagem Python, utilizando o protocolo HTTP/1.1 e oferecendo uma abordagem reativa, escalável e eficiente para criar APIs RESTful. Seu objetivo principal é fornecer uma experiência rápida e produtiva ao desenvolvedor, permitindo a criação de aplicações web com alta performance e baixo overhead.

A biblioteca surgiu como resposta à necessidade de um framework que resolvesse os problemas encontrados em outras tecnologias existentes. Algumas das principais motivações para o desenvolvimento de FastAPI incluem:

• Baixa complexidade: FastAPI visa ser fácil de aprender e usar, permitindo que os desenvolvedores se concentrem no negócio em vez de lidar com a implementação do framework.
• Alta performance: Com base na arquitetura reativa, o framework permite que as requisições sejam processadas de forma eficiente, reduzindo o tempo de resposta e aumentando a capacidade de suportar uma grande quantidade de solicitações simultâneas.
• Escalabilidade: FastAPI é projetado para ser escalável, permitindo que os desenvolvedores construam aplicações que cresçam junto com as necessidades do negócio.

A escolha da tecnologia certa pode ser crucial para o sucesso de um projeto. Aumentar a complexidade do código não deve aumentar seu valor; ao contrário, deve-se simplificar e tornar eficiente o processo de desenvolvimento.

Como funciona na prática

O ciclo de requisição-resposta em FastAPI

Aqui estão as principais etapas que compõem o funcionamento interno do FastAPI:

• Requisição: Quando uma requisição é feita ao servidor, ela segue para o endpoint correspondente no código.
• Parser de requisição: O FastAPI utiliza um parser de requisição (por exemplo, urllib) para extrair as informações da requisição e criar um objeto que contém essas informações.
• Verificação de autenticação: Se a autenticação estiver ativada, o servidor verificará se a requisição é válida e tem autorização para acessar os recursos solicitados.
• Caminho das rotas: O FastAPI então segue o caminho da rota que corresponde à requisição. Isso envolve executar as funções associadas a cada parte do caminho.
• Execução de função: A função correspondente é executada, permitindo manipular os dados e produzir uma resposta.
• Montagem da resposta: Uma resposta é criada com base nos resultados da execução da função. Isso pode incluir dados gerados durante a execução ou informações pré-existentes no servidor.
• Envio da resposta: A resposta final é enviada de volta ao cliente que fez a requisição.

O uso eficiente do recursos

• FastAPI utiliza o conceito de "cor" (threads) para tratar simultaneamente múltiplas solicitações, proporcionando escalabilidade.
• A utilização de modelos de dados Python em tempo de execução permite uma abordagem mais flexível e eficiente para lidar com os dados manipulados pela aplicação.

Compreensão do código

• Para entender como o FastAPI está funcionando no seu projeto, é importante explorar a estrutura do código.
• Cada ponto de entrada na API deve ser cuidadosamente documentado, usando a anotação da função para explicar suas ações.
• A utilização de comentários relevantes também pode ajudar a garantir que outros desenvolvedores possam entender facilmente como o código funciona.

Esse ciclo interativo permite que o programador desempenhe seu papel eficaz no processo, mantendo as operações escaláveis e produtivas.

Exemplo real

from fastapi import FastAPI, Depends, HTTPException
from pydantic import BaseModel
from typing import List
from datetime import datetime

app = FastAPI()

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

db_items = [
    {"id": 1, "name": "Item 1", "description": "Descrição do item 1", "price": 10.99},
    {"id": 2, "name": "Item 2", "description": "Descrição do item 2", "price": 5.99}
]

@app.get("/items/")
async def read_items():
    return db_items

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    for item in db_items:
        if item["id"] == item_id:
            return item
    raise HTTPException(status_code=404, detail="Item não encontrado")

@app.post("/items/")
async def create_item(item: Item):
    db_items.append({
        "id": len(db_items) + 1,
        "name": item.name,
        "description": item.description,
        "price": item.price
    })
    return {"message": "Item cadastrado com sucesso"}

Esse exemplo ilustra como você pode criar uma API RESTful usando o FastAPI para gerenciar itens, incluindo buscar todos os itens, buscar um item específico pelo ID e cadastrar um novo item. Lembre-se de que esse é apenas um exemplo básico e você deve adaptá-lo às suas necessidades específicas.

Boas práticas

Use dependências e injecção de dependência para separar a lógica de negócios do código da API.

• Isso facilita manutenção, depuração e testes.

Faça uso eficiente de exceptions para lidar com erros.

• Em vez de retornar "códigos" de erro, utilize exceções personalizadas para informar ao desenvolvedor o problema ocorrido.

Use Type Hinting para garantir a consistência dos dados.

• Reduz bugs e facilita a escrita do código de acordo com as conveniências do IDE.

Armadilhas comuns

Não crie variáveis globais para armazenar dados da API.

• Utilize o padrão SRP (Princípio da Responsabilidade Única) para distribuir a lógica entre classes e funções.

Evite sobre-uso de async def no FastAPI.

• Use async/await apenas quando necessário para evitar problemas de concorrência em loops ou em código que não seja realmente assimétrico (um "espera" por outro, como é usual na API).

Não utilize a biblioteca SQLite com muitos acessos simultâneos.

• Utilize bancos de dados mais robustos, como PostgreSQL ou MySQL.

Conclusão

O uso do FastAPI e Python para desenvolvimento web oferece muitas vantagens, como a facilidade de uso, a velocidade de desenvolvimento e a capacidade de lidar com requisições assíncronas.

Para aproveitar ao máximo esse conjunto de ferramentas, é importante seguir as boas práticas mencionadas anteriormente, como utilizar dependências e injecção de dependência para separar a lógica de negócios do código da API, fazer uso eficiente de exceptions para lidar com erros e usar Type Hinting para garantir a consistência dos dados.

Além disso, é importante estar ciente das armadilhas comuns que podem ocorrer ao utilizar o FastAPI, como não criar variáveis globais para armazenar dados da API e evitar sobre-uso de async def no código.

Próximos passos incluem aprofundamento na utilização do FastAPI para desenvolvimento de APIs mais complexas, incluindo a implementação de autenticação e autorização, e a integração com bancos de dados robustos. Além disso, é importante explorar outras ferramentas e bibliotecas relacionadas ao Python, como o Django, Flask e Pydantic, para criar soluções mais escaláveis e sustentáveis.

Referências

• Pallett, Andrew. FastAPI: Asynchronous Web Framework for Python. Disponível em: https://fastapi.tiangolo.com/. Acesso: 2024.
• Martin Fowler. Patterns of Enterprise Application Architecture. Disponível em: http://martinfowler.com/eaaCatalog/index.html#Repository.htm. Acesso: 2024.
• ThoughtWorks. Domain-Driven Design in Python. Disponível em: https://www.thoughtworks.com/insights/blog/domain-driven-design-python#. Acesso: 2024.
• PEP 8 — Estilo de Codificação do Python. Disponível em: https://docs.python.org/3/devguide/style.html. Acesso: 2024.
• OWASP - OWASP Top Ten. Disponível em: https://owasp.org/www-project-top-ten/. Acesso: 2024.