Python sempre foi popular para o desenvolvimento de aplicativos da web leves, graças a estruturas incríveis como Flask, Django, Falcon e muito mais. Devido à posição de liderança do Python como linguagem de aprendizado de máquina, ele é especialmente útil para empacotar modelos e fornecê-los como um serviço.
Durante anos, o Flask foi a principal ferramenta para tais tarefas, mas caso você ainda não tenha ouvido, um novo candidato surgiu em seu lugar. FastAPI é uma estrutura Python relativamente nova inspirada em seus predecessores. Ele melhora sua funcionalidade e corrige muitas falhas. O FastAPI foi desenvolvido com base no Starlette e tem muitos recursos incríveis.
Recentemente, ele ganhou muita popularidade, e após os últimos 8 meses que tenho trabalhado com ele todos os dias, posso dizer com segurança que todo o hype em torno dele é totalmente justificado. Se você ainda não experimentou, reuni cinco motivos pelos quais você ainda deveria conhecê-lo.
Interface simples e agradável
Todos os frameworks são forçados a se equilibrar entre funcionalidade e liberdade para o desenvolvedor. Django é poderoso, mas muito teimoso. O Flask, por outro lado, é de alto nível o suficiente para fornecer liberdade de ação, mas muito resta para o usuário. FastAPI está mais perto do Flask nesse aspecto, mas consegue atingir um equilíbrio ainda mais saudável.
Por exemplo, vamos ver como FastAPI define um ponto de extremidade.
from fastapi import FastAPI
from pydantic import BaseModel
class User(BaseModel):
email: str
password: str
app = FastAPI()
@app.post("/login")
def login(user: User):
# ...
# do some magic
# ...
return {"msg": "login successful"}Ele usa o Pydantic para definir o esquema, que é uma biblioteca Python igualmente incrível para validação de dados. Parece bastante simples, mas há muita coisa acontecendo sob o capô. A responsabilidade pela validação dos dados de entrada é delegada ao FastAPI. Se uma solicitação incorreta for enviada, por exemplo, o campo e-mail contém um valor do tipo
int, o código de erro correspondente será retornado, mas o aplicativo não travará, gerando um Erro Interno do Servidor (500). E é quase gratuito.
Exemplo de aplicação simples com
uvicorn:
uvicorn main:appO aplicativo agora pode aceitar solicitações. Nesse caso, a solicitação terá a seguinte aparência:
curl -X POST "http://localhost:8000/login" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"email\":\"string\",\"password\":\"string\"}"A cereja do bolo é a geração automática de documentação de acordo com OpenAPI usando a interface interativa Swagger.
Interface Swagger para aplicativo FastAPI
Assíncrono
Uma das maiores desvantagens das estruturas da Web WSGI do Python em comparação com suas contrapartes em Node.js ou Go era a incapacidade de processar solicitações de forma assíncrona. Desde o início do ASGI, isso não é mais um problema e o FastAPI implementa totalmente esse recurso. Tudo que você precisa fazer é simplesmente declarar os endpoints usando a palavra-chave async como esta:
@app.post("/")
async def endpoint():
# ...
# call async functions here with `await`
# ...
return {"msg": "FastAPI is awesome!"}Injeção de dependência
FastAPI tem uma maneira muito legal de gerenciar dependências. Embora os desenvolvedores não sejam forçados a usar injeção integrada para lidar com dependências em terminais, isso é altamente recomendado.
Por exemplo, vamos criar um terminal onde os usuários podem comentar sobre artigos específicos.
from fastapi import FastAPI, Depends
from pydantic import BaseModel
class Comment(BaseModel):
username: str
content: str
app = FastAPI()
database = {
"articles": {
1: {
"title": "Top 3 Reasons to Start Using FastAPI Now",
"comments": []
}
}
}
def get_database():
return database
@app.post("/articles/{article_id}/comments")
def post_comment(article_id: int, comment: Comment, database = Depends(get_database)):
database["articles"][article_id]["comments"].append(comment)
return {"msg": "comment posted!"}FastAPI get_database em tempo de execução ao chamar o nó de extremidade, para que você possa usar o valor de retorno conforme achar adequado. Existem (pelo menos) duas boas razões para isso.
- Você pode substituir dependências globalmente, modificando o dicionário
app.dependency_overrides. Isso tornará o teste mais fácil e a simulação de objetos. - A dependência (em nosso caso
get_database) pode realizar verificações mais complexas e permite que você as separe da lógica de negócios. O assunto é muito simplificado. Por exemplo, para que você possa implementar facilmente a autenticação do usuário.
Fácil integração com bancos de dados
O que quer que você escolha, seja SQL, MongoDB, Redis ou qualquer outra coisa, o FastAPI não o forçará a construir seu aplicativo em torno de um banco de dados. Se você já trabalhou com MongoDB por meio do Django, sabe como isso pode ser doloroso. Com FastAPI, você não precisa fazer um gancho extra, já que adicionar o banco de dados à pilha é o mais simples possível. (Ou, mais precisamente, a quantidade de trabalho será ditada pelo banco de dados que você escolher, não pela complexidade que vem com o uso de uma estrutura específica.)
Sério, olhe para a beleza.
from fastapi import FastAPI, Depends
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
engine = create_engine("sqlite:///./database.db")
Session = sessionmaker(bind=engine)
def get_db():
return Session()
app = FastAPI()
@app.get("/")
def an_endpoint_using_sql(db = Depends(get_db)):
# ...
# do some SQLAlchemy
# ...
return {"msg": "an exceptionally successful operation!"}Voila! Já estou vendo você digitando
pip install fastapino terminal do seu computador.
Suporte GraphQL
Quando você está trabalhando com um modelo de dados complexo, REST pode ser um grande obstáculo. Não é muito legal quando a menor mudança na frente requer uma atualização do esquema do terminal. Nesses casos, GraphQL salva você. Embora o suporte a GraphQL não seja nenhuma novidade para estruturas da web Python, Graphene e FastAPI funcionam bem juntos. Não há necessidade de instalar nenhuma extensão adicional, por exemplo
graphene_djangopara Django, tudo funcionará desde o início.
+1: Excelente documentação
Claro, um framework não pode ser ótimo se tiver uma documentação pobre. Django, Flask e outros se saíram bem nisso, e o FastAPI está acompanhando-os. Claro que, por ser muito mais novo, ainda não existe um livro sobre ele, mas é só uma questão de tempo.
Se você quiser ver o FastAPI em ação, tenho um ótimo guia para você. Escrevi um tutorial detalhado com o qual você pode implantar seu modelo de ML no Docker, Docker Compose e GitHub Actions!
Para resumir, se você está procurando uma estrutura rápida e leve para trabalhar com seu modelo de aprendizado profundo ou algo mais complexo, FastAPI é sua opção. Tenho certeza de que funcionará para você.