Você sabe como usar a FastAPI?

O FastAPI é um framework com abordagem moderna, que utiliza programação assíncrona, possui Type Hint e os recursos mais recentes do Python.

Você sabe como usar a FastAPI?

O FastAPI é um framework web focado no desenvolvimento de APIs com Python, que possui alta performance, pronto para produção, fácil de usar e de rápido aprendizado, programação e codificação. Com a modernidade, agilidade e simplicidade como principais características, ele foi criado por Sebastián Ramírez e lançado em 2018.

Segundo Ramírez, a ideia do framework surgiu após muitos anos desenvolvendo APIs com requisitos complexos, o que possibilitou que ele pudesse conhecer e utilizar diversas ferramentas, sempre buscando uma que realmente atendesse suas necessidades.

Após desbravar inúmeros frameworks e plug-ins, sentiu a necessidade de unir todas as funcionalidades que encontrava nessas ferramentas em um único lugar. E, com base em toda essa experiência adquirida ao longo de muitos projetos, criou o FastAPI.

Se você é programador ou programadora e está procurando um framework moderno para construir aplicações, então continue a leitura! Neste artigo, vamos falar um pouco sobre o que é, as vantagens e como usar o FastAPI. Boa leitura e aprendizado!

FastApi

O que é FastAPI?

FastAPI é uma estrutura de API REST (Representational State Transfer), de alto desempenho para Python. Moderno e rápido, esse framework web de alta performance é baseado nos Type Hints padrões do Python e oferece suporte a código assíncrono.

Construído com base no Starlette, usa Pydantic para validação de dados. Podendo gerar documentação OpenAPI a partir de seu código, além de também produzir uma interface de usuário do Swagger que pode ser usada para testar seu aplicativo. Os recursos-chave do FastAPI são:

Rapidez: alta performance, equivalente a NodeJS e Go (graças ao Starlette e Pydantic), sendo considerado um dos frameworks mais rápidos disponíveis atualmente.

Agilidade para codar: aumenta a velocidade para desenvolver recursos entre 200% e 300%.

Poucos bugs: reduz cerca de 40% de erros induzidos por humanos.

Intuitivo: amplo suporte a IDEs e com recurso de autocompletar, acarretando menos tempo debugando.

Fácil: projetado para ser de fácil aprendizado e usabilidade, resulta em menos tempo de leitura de documentação.

Enxuto: minimiza duplicação de código e, por possuir múltiplos recursos para cada declaração de parâmetro, proporciona menor taxa de bugs.

Robusto: possibilita ter códigos prontos para produção, além de documentação interativa automática.

Baseado em padrões: baseado (e totalmente compatível) nos padrões abertos para APIs: OpenAPI (anteriormente conhecido como Swagger) e JSON Schema.

FastApi

Como usar o FastAPI?

Quando se trata de framework web para construção de APIs com Python, o FastAPI veio para facilitar a rotina dos(as) programadores(as). Com uma série de boas dependências que fazem com que ele tenha alta performance, equivalente a NodeJS e Golang, como:

Como usar o FastAPI?

Posto isso, que tal criar uma API? Para começar, é imprescindível que você tenha instalado em sua máquina uma versão de Python 3.6 ou superior. Com ele instalado, é possível seguir para os próximos passos:

1- Crie uma pasta para iniciar o projeto e em um terminal de sua preferência, posicione nesse novo arquivo e execute os seguintes comandos (sendo que o primeiro controle cria um ambiente virtual e o seguinte o ativa):

python3 -m venv .venv

source .venv/bin/activate

2- Feito isso, é preciso instalar o FastAPI e o Uvicorn, que faz o trabalho de subir o servidor para acessar as rotas. O uso dele está referenciado no tutorial inicial da documentação do FastAPI. E, então, execute os seguintes comandos (lembrando que o pip é um gerenciador de pacotes que vem incluso na instalação do Python):

pip install fastapi

pip install uvicorn

3- Com o ambiente configurado e dependências instaladas, chegou a hora de criar a API. Elabore um arquivo chamado main.py, e adicione o código abaixo:

from fastapi import FastAPI, Body

from pydantic import BaseModel

from typing import Optional

app = FastAPI()

class User(BaseModel):

id: Optional[int] = 0

name: str

email: str

phone: Optional[str] = None


fake_users_db = [

User(id=1, name='Lucas', email='[email protected]'),

User(id=2, name='Fulano', email='[email protected]'),

User(id=3, name='Ciclano', email='[email protected]'),

User(id=4, name='Beltrano', email='[email protected]'),

User(id=5, name='Feltrano', email='[email protected]'),

]

@app.get('/')

async def root():

return {'message': 'Hello World, it is FastAPI!'}


@app.get('/users/me')

def read_me():

return {'user': 'I am you!'}


@app.get('/users/{user_id}')

def read(user_id: int):

return {'user': [user for user in fake_users_db if user.id == user_id]}

@app.get('/users/')

async def read_pagination(skip: int = 0, limit: int = 10):

return {'users': fake_users_db[skip: skip + limit]}


@app.post('/users')

def create_user(user: User):

user.id = fake_users_db[-1].id + 1

fake_users_db.append(user)

return {'message': 'User was created!'}

@app.post('/any')

def create_any(body = Body(...)):

return {'body': body}


@app.patch('/users/{user_id}')

def update(user_id: int, user: User):

index = [index for index, user in enumerate(fake_users_db) if user.id == user_id]

user.id = fake_users_db[index[0]].id

fake_users_db[index[0]] = user

return {'message': 'User was updated!'}


@app.delete('/users/{user_id}')

def delete(user_id: int):

user = [user for user in fake_users_db if user.id == user_id]

fake_users_db.remove(user[0])

return {'message': 'User was deleted!'}

Pronto, você acabou de criar uma API que recebe requisições HTTP em ambas as rotas que fazem operações GET (também conhecido como métodos HTTP). E, caso queira testá-la, basta executar no terminal o seguinte comando:

                                       uvicorn main:app --reload

Esse controle sobe um servidor para o FastAPI em sua máquina local através do Uvicorn, sendo “main” o nome do arquivo e “app” a variável do arquivo main.py que recebeu a instância do FastAPI, e a flag “ — reload” permite  que você continue escrevendo o código e vendo as alterações na API, sem precisar parar o servidor e executar novamente.

5 vantagens do FastAPI

O FastAPI vem ganhando bastante popularidades nos últimos meses. E se você ainda não entendeu o motivo, confira as 5 principais vantagens de utilizá-lo:

Vantagens do FastAPI

1- Interface simples e agradável

Todos os frameworks precisam ter um equilíbrio entre funcionalidade e liberdade para o desenvolvedor ou desenvolvedora, e o FastAPI consegue atingi-lo.

2- Assíncrono

O FastAPl possui capacidade de processar solicitações de forma assíncrona e implementa totalmente esse recurso. Tudo o que você precisa fazer é declarar endpoints usando uma palavra-chave async.

3- Injeção de dependência

Esse framework tem um excelente método 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.

4- Fácil integração com bancos de dados

O FastAPl não irá forçá-lo a construir seu aplicativo em torno de um banco de dados, independente da linguagem de programação que você escolher. Com ele, você não precisa fazer um gancho extra, pois adicionar o banco de dados a pilha será uma tarefa bem simples, dependendo da sua escolha.

5- Suporte GraphQL

Quando você está trabalhando com um modelo de dados complexo, REST pode ser um grande obstáculo, pois pode ocorrer de, futuramente, ao mudar algo em seu projeto, precise realizar uma atualização do esquema do terminal. Nesses casos, GraphQL pode salvar você eliminando a necessidade de instalar extensões adicionais.

Ao longo deste artigo podemos perceber como o FastAPI é moderno, com uma estrutura simples, além de ser flexível e com muitas possibilidades. Mas abordamos apenas as características mais importantes do que essa ferramenta pode fazer.

Para se aprofundar nesse universo e desenvolver ainda mais sua carreira em programação, a Digital House pode ajudar você! Com o curso de Desenvolvimento Web Full Stack, que capacita o(a) aluno(a) a criar sites e sistemas web, utilizando diferentes linguagens de programação, com aulas online, 100% ao vivo e ministradas por professores especialistas que estão no mercado.

Além disso, a DH conta com o departamento de Carreiras, onde os(as) alunos(as) podem acessar diversos conteúdos exclusivos sobre suas jornadas. Inscreva-se agora mesmo e garanta o seu futuro profissional!

E-Book Guia Full Stack Developer