Ir para o conteúdo

B - Próximos passos

Esse apêndice se destina a mostrar alguns exemplos de código da página de despedida/próximos passos. Alguns exemplos simples de como fazer algumas tarefas que não trabalhamos durante o curso.

Templates

O FastAPI conta com um recurso de carregamento de arquivos estáticos, como CSS e JS. E também permite a renderização de templates com jinja.

Os templates são formas de passar informações para o HTML diretamente dos endpoints. Mas, comecemos pela estrutura. Criaremos dois diretórios. Um para os templates e um para os arquivos estáticos:

Estrutura dos arquivos
.
├── app.py
├── static 
│  └── style.css
└── templates 
   └── index.html

Vamos adicionar um arquivo de estilo bastante simples, somente para ver o efeito da configuração:

static/style.css
h1 {
    text-align: center;
}

E um arquivo html usando a tag dos templates:

templates/index.html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8"/>
    <title>index.html</title>
    <link href="static/style.css" rel="stylesheet"/>
  </head>
  <body>
    <h1>Olá {{ nome }}</h1> 
  </body>
</html>

Todas as variáveis incluídas em {{ variável }} são passadas pelo endpoint no momento de retornar o template jinja. Com isso, podemos incluir valores da aplicação no HTML.

Para unir os arquivos estáticos e os templates na aplicação podemos aplicar o seguinte bloco de código:

app.py
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates

app = FastAPI()

# Diretório contendo arquivos estáticos
app.mount('/static', StaticFiles(directory='static'), name='static')

# Diretório contendo os templates Jinja
templates = Jinja2Templates(directory='templates')


@app.get('/{nome}', response_class=HTMLResponse)
def home(request: Request, nome: str):
    return templates.TemplateResponse(
        request=request, name='index.html', context={'nome': nome}
    )

Para que os templates sejam renderizados pelo FastAPI precisamos instalar o jinja:

$ Execução no terminal!
poetry add jinja2

E executar nosso projeto com:

$ Execução no terminal!
task run

Desta forma, ao acessar o endpoint pela API, temos a junção de templates e estáticos acontecendo:

Asyncio

O FastAPI tem suporte nativo para programação assíncrona. A única coisa que precisa ser feita para isso, a nível do framework (não incluindo as dependências) é adicionar a palavra reservada async no início dos endpoints.

Da seguinte forma:

app.py
from asyncio import sleep

from fastapi import FastAPI

app = FastAPI()


@app.get('/')
async def home():
    await sleep(1)
    return {'message': 'Olá mundo!'}

O escalonamento do loop durante as chamadas nos endpoints pode ser feito por meio da palavra reservada await.

Para que os testes sejam executados de forma assíncrona, precisamos instalar uma extensão do pytest:

$ Execução no terminal!
poetry add pytest-asyncio

Dessa forma podemos executar funções de teste que também são assíncronas usando um marcador do pytest:

test_app.py
from fastapi.testclient import TestClient

from app import app

import pytest


@pytest.mark.asyncio 
async def test_async():
    client = TestClient(app)
    response = client.get('/')

    assert response.json() == {'message': 'Olá mundo!'}

Tarefas em segundo plano (Background)

TODO: adicionar explicação a esse tópico

app.py
from time import sleep

from fastapi import BackgroundTasks, FastAPI


app = FastAPI()


def tarefa_em_segundo_plano(tempo=0):
    sleep(tempo)


@app.get('/segundo-plano/{tempo}')
def segundo_plano(tempo: int, task: BackgroundTasks):
    task.add_task(tarefa_em_segundo_plano, tempo)
    return {'message': 'Sua requisição está sendo processada!'}

Eventos de ciclo de vida

Os eventos de ciclo de vida são formas de iniciar ou testar alguma condição antes da aplicação ser de fato inicializada. Você pode criar validações, como saber se outra aplicação está de pé, configurar coisas antes da aplicação ser iniciada, como iniciar o banco de dados, etc.

Da mesma forma alguns casos para antes da aplicação ser finalizada também podem ser criadas. Como garantir que todas as tarefas em segundo plano estejam de fato finalizadas antes da aplicação parar de rodar.

app.py
from logging import getLogger
from time import sleep

from fastapi import FastAPI


logger = getLogger('uvicorn')

@asynccontextmanager
async def lifespan(app: FastAPI):
    logger.info('Iniciando a aplicação')
    yield  # Executa a aplicação
    logger.info('Finalizando a aplicação')


app = FastAPI(lifespan=lifespan)

Podemos observar que os logs foram adicionados ao uvicorn antes e depois da execução da aplicação:

$ Execução no terminal!
uvicorn app:app
INFO:     Started server process [254037]
INFO:     Waiting for application startup.
INFO:     Iniciando a aplicação
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
# Apertando Ctrl + C
^C
INFO:     Shutting down
INFO:     Waiting for application shutdown.
INFO:     Finalizando a aplicação
INFO:     Application shutdown complete.
INFO:     Finished server process [254037]