Despedida e próximos passos
Objetivos da aula:
- Fazer uma revisão geral dos conceitos e práticas que abordamos ao longo do curso.
- Encorajar a exploração futura e o aprofundamento em áreas específicas.
- Agradecer a todos que acompanharam esta série de aulas.
- Apresentar outros materiais criados com FastAPI.
Caso prefira ver a aula em vídeo
Esse aula ainda não está disponível em formato de vídeo, somente em texto ou live!
Estamos chegando ao final de nossa jornada juntos neste curso. Durante esse tempo, tivemos a oportunidade de explorar uma série de conceitos e tecnologias essenciais para o desenvolvimento de aplicações web modernas e escaláveis. É importante lembrar que o que vimos aqui é apenas a ponta do iceberg. Ainda há muitos aspectos e detalhes que não pudemos cobrir neste curso, como tratamento de logs, observabilidade, segurança avançada, otimizações de desempenho, entre outros. Encorajo a todos que continuem explorando e aprendendo.
Revisão
Ao longo deste curso, cobrimos uma série de tópicos essenciais para o desenvolvimento de aplicações web modernas e robustas:
-
FastAPI: conhecemos e utilizamos o FastAPI, um moderno framework de desenvolvimento web para Python, que nos permite criar APIs de alto desempenho de forma eficiente e com menos código.
-
Docker: aprendemos a utilizar o Docker para criar um ambiente isolado e replicável para nossa aplicação, facilitando tanto o desenvolvimento quanto o deploy em produção.
-
Testes e TDD: abordamos a importância dos testes automatizados e da metodologia TDD (Test Driven Development) para garantir a qualidade e a confiabilidade do nosso código.
-
Banco de dados e migrações: trabalhamos com bancos de dados SQL, utilizando o SQLAlchemy para a comunicação com o banco de dados, e o Alembic para gerenciar as migrações de banco de dados.
-
Autenticação e autorização: implementamos funcionalidades de autenticação e autorização em nossa aplicação, utilizando o padrão JWT.
-
Integração Contínua (CI): utilizamos o Github Actions para criar um pipeline de CI, garantindo que os testes são sempre executados e que o código mantém uma qualidade constante.
-
Deploy em produção: por fim, fizemos o deploy da nossa aplicação em um ambiente de produção real, utilizando o Fly.io, e aprendemos a gerenciar e configurar esse ambiente.
Outros materiais produzidos por mim sobre FastAPI
Já cobrimos alguns temas não citados neste curso usando FastAPI em algumas Lives de Python. Você pode assistir para aprender mais também.
Templates e WebSockets
Na Live de Python #164 conversamos sobre websockets com Python e usamos FastAPI para exemplificar o comportamento. Durante essa live criamos uma aplicação de chat e usamos os templates com HTML e Jinja2 e Brython para ações dinâmicas como faríamos com JavaScript.
GraphQL (Strawberry)
Na Live de Python #185 conversamos sobre GraphQL um padrão alternativo a REST APIs. Todos os exemplos foram aplicados usando Strawberry e FastAPI
SQLModel
Na Live de Python #235 conversamos sobre SQLModel um ORM alternativo ao SQLAlchemy que se integra com o Pydantic. O SQLModel também foi desenvolvido pelo Sebastian (criador do FastAPI). Caminhando ao final dessa aula, podemos ver a implementação do SQLModel em uma aplicação básica com FastAPI.
FastUI
Na Live de Python #259 conversamos sobre FastUI. Uma forma de usar modelos do Pydantic para retornar componentes React e contruir o front-end da aplicação coordenado pelo back-end. Um esquema de interação de Back/Front conhecido como SDUI (Server-Driver User Interface).
Próximos passos
Parte importante do aprendizado vem de entender que o que vimos aqui é o básico, o mínimo que devemos saber para conseguir fazer uma aplicação consistente usando FastAPI. Agora é a hora de trilhar novos caminhos e conhecer mais as possibilidades. Tanto na construção de APIs, quanto no aprofundamento de recursos do FastAPI.
Observabilidade
Embora tenhamos conseguido colocar nossa aplicação no ar sem grandes problemas. Quando a aplicação passa da nossa máquina, em nosso contexto, para ser utilizada em escala no deploy. Perdemos a visualização do que está acontecendo de fato com a aplicação. Os erros que estão acontecendo, quais partes do sistema estão sendo mais utilizadas, o tempo que nossa aplicação está levando para executar algumas tarefas, etc.
Temos diversas práticas e ferramentas que nos ajudam a entender como a aplicação está rodando em produção. Como:
-
Logs: registros de eventos importantes do nosso sistema. Armazenados de forma estruturada e por data e hora. Por exemplo: se quiséssemos saber todas às vezes que alguém registrou um usuário ou adicionou uma tarefa no banco de dados. Poderíamos escrever isso em um arquivo de texto ou até mesmo enviar para um servidor de logs para vermos isso remotamente e entender um pouco sobre os eventos que estão ocorrendo em produção. É uma forma de criar um "histórico" de eventos importantes.
-
Tracing: rastreamento do que acontece na aplicação. Por exemplo: quando nossa aplicação recebe uma requisição, ela passa pelo ORM, o ORM faz uma chamada no banco de dados. Quanto tempo cada uma dessas operações leva? A ideia do tracing é rastrear o caminho por onde uma requisição passa. Monitorando isso, podemos entender o fluxo que a aplicação toma em tempo de execução.
-
Métricas: dados importantes sobre a utilização da aplicação. Como quantas vendas foram efetuadas nos últimos 15 minutos. Quantos erros nossa aplicação apresenta por dia. Qual a preferência de fluxos que os usuários e etc.
Caso queria aprender mais sobre observabilidade com FastAPI
Fizemos uma série sobre opentelemetry com os exemplos usando FastAPI e diversas integrações entre serviços. Pode ser que você goste e aprenda mais sobre o framework.
Uma introdução a observabilidade usando FastAPI:
Métricas de observabilidade usando FastAPI como exemplo:
Traces distribuídos com exemplos com FastAPI:
Uma forma de unir todos os conceitos de observabilidade é utilizando um APM ou construindo sua própria "central de observabilidade" com ferramentas como o Opentelemetry. Ele permite que instalemos diversas formas de instrumentação em nossa aplicação e distribui os dados gerados para diversos backends. Como o Jaeger e o Grafana Tempo para armazenar traces. O Prometheus para ser um backend de métricas. O Grafana Loki para o armazenamento de logs. E por fim, criar um dashboard juntando todas essas informações para exibir a saúde tanto da aplicação quanto das regras estabelecidas pelo negócio com o Grafana.
Assincronismo
Um exemplo básico
Um exemplo básico de uso de Asyncio + FastAPI pode ser encontrado no apêndice B.
Outro ponto importante, e talvez o carro chefe do FastAPI é poder ser usado de forma concorrente. O que significa que ele pode fazer outro trabalho enquanto aguarda por chamadas de input/ouput. Por exemplo, enquanto esperamos o postgres responder, podemos outra requisição. Nesse momento, enquanto essa requisição faz outra chamada ao banco, podemos responder a que estávamos aguardando a resposta no banco de dados. Isso faz com que o tempo da aplicação seja otimizado durante a execução.
Chamadas assíncronas em python são caracterizadas pelo uso das corrotinas async def e as esperas com await. A própria documentação do fastAPI apresenta um tutorial sobre AsyncIO.
Conversamos sobre AsyncIO diversas vezes na Live de Python. Se pudesse destacar um material que gostei de ter feito sobre esse assunto, seria a live sobre requisições assíncronas:
Se tiver curiosidade de ver um exemplo real de AsyncIO e FastAPI nos mesmos moldes que aprendemos durante esse curso.
Temos o projeto do chat que fica disponível durante as lives. Tanto na Twitch, quanto no YouTube. O livestream-chat.
Aqui temos vários conceitos aplicados ao projeto. Templates com HTML e Jinja, WebSockets com diferentes canais, requisições em backgroud, uso de asyncio, eventos do FastAPI, logs com loguru, integração com um APM (Sentry), testes assíncronos, etc.
Anotação de tipos
Um dos pontos principais do uso do Pydantic e do FastAPI, que não nos aprofundamos nesse material.
Durante esse material vimos tipos embutidos diferentes como typing.Annotated, tipos customizados pelo Pydantic como email: EmailStr ou até mesmo tipos criados pelo SQLAlchemy como: Mapped[str]. Entender como o sistema de tipos usa essas anotações em tempo de execução pode ser bastante proveitoso para escrever um código que será mais seguro em suas relações.
O sistema de tipos do python está descrito aqui. Você pode estudar mais por esse material.
Nota do @dunossauro
Meu próximo material em texto será um livro online e gratuito sobre tipagem gradual com python. Quando estiver disponível, eu atualizarei essa página com o link!
Tarefas em background
Um exemplo básico
Um exemplo básico de uso de tarefas em segundo plano pode ser encontrado no apêndice B.
Uma das coisas legais de poder usar AsyncIO é poder realizar tarefas em segundo plano. Isso pode ser uma confirmação de criação de conta, como um e-mail. Ou até mesmo a geração de um relatório semanal.
Existem várias formas incríveis de uso, não irei me estender muito nesse tópico, pois a documentação do fastAPI tem uma ótima página em português sobre Tarefas em segundo plano. Acredito que valha a pena a leitura!
Conclusão
Todos esses conceitos e práticas são componentes fundamentais no desenvolvimento de aplicações web modernas e escaláveis. Eles nos permitem criar aplicações robustas, confiáveis e eficientes, que podem ser facilmente mantidas e escaladas.
Gostaria de agradecer a todos que acompanharam essa série de aulas. Espero que tenham encontrado valor nas informações e práticas que compartilhamos aqui. Lembre-se, a jornada do aprendizado é contínua e cada passo conta. Continue explorando, aprendendo e crescendo.
Até mais!