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:

Tarefas em segundo plano (Background)

Em algumas aplicações, é preciso realizar tarefas que possam ser feitas sem atrapalhar o funcionamento principal do programa. É útil para enviar e-mails, processar arquivos ou fazer cálculos demorados, mas sem impactar a experiência do usuário, que pode continuar interagindo com a aplicação.

O FastAPI oferece suporte nativo para a execução de tarefas em segundo plano usando o objeto BackgroundTasks. Esse objeto permite que você adicione funções que serão executadas após a resposta ser enviada ao cliente. Dessa forma, o cliente não precisa esperar que a tarefa seja concluída para continuar suas interações.

Exemplo de implementação

No exemplo a seguir, criamos uma tarefa simples que dorme por um tempo especificado e retorna uma resposta indicando que a requisição foi recebida e está sendo processada.

app.py
from time import sleep

from fastapi import BackgroundTasks, FastAPI


app = FastAPI()


def tarefa_em_segundo_plano(tempo=0):
    sleep(tempo)  # Simula um processo demorado


@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!'}

Como funciona a execução

Quando um cliente acessa o endpoint /segundo-plano/{tempo}, o FastAPI envia imediatamente a resposta {'message': 'Sua requisição está sendo processada!'}. A tarefa, que simula um processo demorado, é executada em segundo plano, sem que o cliente tenha que aguardar sua conclusão.

Isso permite que você realize operações demoradas sem prejudicar a experiência do usuário, que pode seguir usando a aplicação enquanto a tarefa está em andamento.

Eventos de ciclo de vida

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

Da mesma forma, alguns casos para antes de a 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]