DEV Community: Gustavo Garcia Pereira

Guia Definitivo para Otimizar Aplicações FastAPI: 5 Estratégias de Performance com Python e Vue.js

Gustavo Garcia Pereira — Sun, 11 May 2025 19:01:05 +0000

Aprenda 5 técnicas práticas para melhorar o desempenho de apps FastAPI com Python e Vue.js. Exemplos de código, erros comuns e casos reais incluídos!

Introdução

FastAPI tornou-se um framework essencial para APIs rápidas e escaláveis. Combinado com Vue.js no frontend, permite criar aplicações modernas, mas otimizar performance exige estratégias específicas. Veja como evitar gargalos e garantir velocidade em produção.

1. Async/Await: Domine a Execução Não-Bloqueante (Python)

Problema: Rotas síncronas bloqueiam o event loop do FastAPI, reduzindo throughput.

Solução: Use async def para operações I/O (chamadas a APIs, bancos de dados).

from fastapi import FastAPI  
import httpx  

app = FastAPI()  

@app.get("/dados-externos")  
async def fetch_data():  
    async with httpx.AsyncClient() as client:  
        resposta = await client.get("https://api.externa.com/dados")  
    return resposta.json()

Comparação:

Síncrono: 100 req/s → Assíncrono: 1500+ req/s (teste com 10 workers).

2. Cache de Dados com Redis (Python + Docker)

Cenário: Consultas repetidas ao banco aumentam latência.

Implementação:

from fastapi import FastAPI  
from redis import asyncio as aioredis  

app = FastAPI()  
redis = aioredis.from_url("redis://localhost")  

@app.get("/produto/{id}")  
async def get_produto(id: int):  
    cache = await redis.get(f"produto:{id}")  
    if cache:  
        return JSONResponse(content=json.loads(cache))  
    # Consulta ao banco e atualização do cache...

Ferramenta: Use docker-compose para subir Redis rapidamente:

services:  
  redis:  
    image: redis:alpine  
    ports:  
      - "6379:6379"

3. Otimização de Consultas no Banco de Dados (SQLAlchemy)

Erro Comum: Trazer todas as colunas com SELECT *.

Solução: Use .options(load_only()) no SQLAlchemy:

from sqlalchemy.orm import load_only  

produtos = await db.execute(  
    select(Produto).options(load_only(Produto.nome, Produto.preço))  
)

Dica: Índices para campos filtrados (ex: produto.categoria_id).

4. Compressão de Respostas HTTP (FastAPI Middleware)

Impacto: Reduz tamanho de payloads em até 70%.

Implementação:

from fastapi.middleware.gzip import GZipMiddleware  

app.add_middleware(GZipMiddleware, minimum_size=500)

Configuração: Aplique apenas para conteúdos grandes (ex: JSON, HTML).

5. Lazy Loading no Vue.js (Frontend)

Problema: Carregamento inicial lento de SPA.

Solução: Dynamic imports para componentes não críticos:

// Vue 3  
const ModalLogin = defineAsyncComponent(() => import('@/components/ModalLogin.vue'));

Framework: Use vite-plugin-pages para rotas automáticas com code splitting.

Caso Real: E-commerce com 10k Requisições/Minuto

Desafio: Latência de 2s na página de produtos.

Soluções Aplicadas:

Cache de catálogo com Redis (TTL de 10min).
Compressão GZip + otimização de imagens via CDN.
Async endpoints para tracking de usuários. Resultado: Latência média de 400ms e redução de 40% no uso do servidor.

Erros Fatais a Evitar

❌ Misturar código síncrono (ex: requests.get) em rotas assíncronas.

❌ Não usar conexões persistentes para bancos de dados (ex: reutilize pools).

❌ Ignorar monitoramento (implemente métricas com Prometheus + Grafana).

Conclusão

Otimizar aplicações FastAPI exige atenção a back-end (Python) e front-end (Vue.js). Experimente as técnicas acima, monitore resultados com ferramentas como Locust para testes de carga, e compartilhe sua experiência nos comentários!

FastAPI: 5 Dicas Cruciais para Turbinar a Performance da sua API Python

Gustavo Garcia Pereira — Sun, 11 May 2025 18:54:22 +0000

FastAPI rapidamente se tornou um dos frameworks Python preferidos para construir APIs, graças à sua velocidade impressionante e facilidade de uso. No entanto, mesmo com um framework performático, existem otimizações que podem levar sua aplicação para o próximo nível.

Neste guia, exploraremos 5 dicas essenciais de performance para aplicações FastAPI, com exemplos práticos em Python. Veremos também como essas otimizações no backend podem beneficiar indiretamente seu frontend, como aplicações em Vue.js.

Por que a Performance em FastAPI Importa?

Performance é crucial. APIs rápidas significam melhor experiência do usuário, menor custo de infraestrutura e maior capacidade de escalar. Com FastAPI, você já tem uma base sólida, mas otimizar gargalos específicos pode fazer uma grande diferença.

1. Abrace o Poder do `async` e `await`

FastAPI é construído sobre Starlette e Pydantic, e seu principal trunfo para concorrência é o asyncio. Usar async e await corretamente é fundamental.

O que fazer:
Declare suas funções de rota (path operations) com async def se elas realizarem operações de I/O (entrada/saída) que podem ser aguardadas, como chamadas de banco de dados, requisições HTTP externas, ou leitura/escrita de arquivos.

# main.py
from fastapi import FastAPI
import httpx # Biblioteca HTTP assíncrona
import asyncio

app = FastAPI()

@app.get("/fetch-data")
async def fetch_external_data():
    # Simula uma chamada de API externa demorada
    async with httpx.AsyncClient() as client:
        # Use await para operações de I/O
        response = await client.get("https://rickandmortyapi.com/api/character/1")
        await asyncio.sleep(1) # Simula processamento adicional
    return response.json()

@app.get("/process-locally")
async def process_locally():
    # Operação que não é I/O bound, mas pode ser longa
    # Se for CPU-bound e longa, considere executar em um thread pool separado
    # com `def process_locally(): ...` e o FastAPI cuidará disso.
    # Mas para I/O, sempre async.
    await asyncio.sleep(0.5) # Simula alguma operação
    return {"message": "Processed locally (simulated IO-bound task)"}

Erro comum a evitar:
Usar bibliotecas de I/O bloqueantes dentro de uma função async def sem await ou sem executá-las em um executor de thread separado (FastAPI faz isso automaticamente para rotas def normais). Isso bloquearia o loop de eventos do asyncio, prejudicando a concorrência.

2. Utilize Tarefas em Background (`BackgroundTasks`)

Para operações que não precisam ser concluídas antes de enviar a resposta ao cliente (ex: enviar um e-mail de confirmação, processar um webhook, gerar um relatório), use BackgroundTasks.

Como funciona:
FastAPI permite que você adicione tarefas que serão executadas após a resposta ser enviada, liberando o worker para lidar com novas requisições rapidamente.

# main.py
from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def write_notification(email: str, message=""):
    with open("log.txt", mode="a") as email_file:
        content = f"Notification for {email}: {message}\n"
        email_file.write(content)
    print(f"Sent notification to {email}") # Simula envio real

@app.post("/send-notification/{email}")
async def send_notification_endpoint(email: str, background_tasks: BackgroundTasks):
    message_content = "Your account has been updated."
    # A resposta é enviada ANTES de write_notification ser completada
    background_tasks.add_task(write_notification, email, message=message_content)
    return {"message": "Notification will be sent in the background"}

Caso de uso real:
Imagine um e-commerce. Após o cliente finalizar a compra, você envia uma resposta de sucesso imediatamente. O envio do e-mail de confirmação e a atualização do inventário podem ser feitos como tarefas em background.

3. Implemente Caching Inteligente

Muitas vezes, os dados solicitados não mudam com frequência. Implementar uma estratégia de caching pode reduzir drasticamente a carga no seu banco de dados e o tempo de resposta.

Ferramentas e Estratégias:

Redis: Um popular servidor de estrutura de dados em memória, ótimo para caching.
Memcached: Outra opção de caching em memória.
fastapi-cache2: Uma biblioteca que facilita a implementação de caching em rotas FastAPI com backends como Redis.

Exemplo Conceitual com fastapi-cache2 (requer instalação e configuração do Redis):

# main.py
from fastapi import FastAPI
from fastapi_cache import FastAPICache
from fastapi_cache.backends.redis import RedisBackend
from fastapi_cache.decorator import cache
from redis import asyncio as aioredis # Importe a versão asyncio do redis

app = FastAPI()

# Simulação de uma chamada demorada ao banco de dados
async def get_expensive_data_from_db(item_id: str):
    await asyncio.sleep(2) # Simula latência do DB
    return {"item_id": item_id, "data": "Some very important data"}

@app.on_event("startup")
async def startup():
    # Configure o cliente Redis para asyncio
    redis_client = aioredis.from_url("redis://localhost", encoding="utf8", decode_responses=True)
    FastAPICache.init(RedisBackend(redis_client), prefix="fastapi-cache")

@app.get("/items/{item_id}")
@cache(expire=60) # Cache por 60 segundos
async def get_item(item_id: str):
    data = await get_expensive_data_from_db(item_id)
    return data

Melhor prática:
Use chaves de cache granulares e defina tempos de expiração apropriados. Invalide o cache quando os dados subjacentes mudarem.

4. Otimize suas Consultas ao Banco de Dados

O banco de dados é frequentemente o maior gargalo de performance.

Dicas para otimização:

Use Drivers Assíncronos: Se seu ORM (como SQLAlchemy) e banco de dados suportam, utilize drivers assíncronos (ex: asyncpg para PostgreSQL, aiomysql para MySQL).

# Exemplo conceitual com SQLAlchemy e asyncpg
# from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
# from sqlalchemy.orm import sessionmaker

# DATABASE_URL = "postgresql+asyncpg://user:password@host/db"
# engine = create_async_engine(DATABASE_URL)
# AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)

# async def get_db():
#     async with AsyncSessionLocal() as session:
#         yield session

Consultas Eficientes:
- Evite o problema N+1: Use selectin_load (SQLAlchemy) ou equivalentes para carregar dados relacionados em uma única consulta.
- Selecione apenas as colunas necessárias (SELECT col1, col2 FROM ... em vez de SELECT *).
- Use índices de banco de dados para colunas frequentemente consultadas em cláusulas WHERE ou JOIN.
Connection Pooling: Certifique-se de que seu ORM ou driver de banco de dados está usando um pool de conexões para reutilizar conexões em vez de abrir e fechar novas para cada requisição.

Erro comum:
Buscar dados excessivos ou realizar múltiplas consultas pequenas onde uma consulta mais complexa (mas única) seria mais eficiente.

5. Gestão Eficiente de Dados com Pydantic e Modelos de Resposta

Pydantic não é apenas para validação; ele também otimiza a serialização e desserialização de dados.

Como usar para performance:

response_model: Sempre defina um response_model para suas rotas. Isso garante que apenas os dados definidos no modelo sejam serializados e enviados, evitando a exposição acidental de dados e reduzindo o tamanho da resposta.
response_model_exclude_unset=True: Por padrão, FastAPI/Pydantic inclui todos os campos no response_model com seus valores padrão, mesmo que não tenham sido explicitamente definidos na sua lógica de rota. Usar response_model_exclude_unset=True na sua rota (ou globalmente na FastAPI(default_response_model_exclude_unset=True)) envia apenas os campos que foram de fato definidos, o que pode reduzir significativamente o tamanho do payload.

# main.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

app = FastAPI(default_response_model_exclude_unset=True) # Configuração global

class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None
    internal_notes: Optional[str] = "Sensitive info" # Campo que não queremos expor

class ItemOut(BaseModel): # Modelo específico para saída
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None


# Simulação de um banco de dados
fake_items_db = {"foo": {"name": "Foo", "price": 50.2}}

@app.get("/items-optimized/{item_id}", response_model=ItemOut)
async def read_item_optimized(item_id: str):
    # Se tax não for definido, não será incluído na resposta
    # devido a default_response_model_exclude_unset=True e Optional
    item_data = fake_items_db.get(item_id)
    if not item_data:
        return {"error": "Item not found"} # Pydantic validará isso contra ItemOut

    # Apenas campos de ItemOut serão retornados. internal_notes é ignorado.
    return item_data

@app.get("/items-less-optimized/{item_id}", response_model=Item) # Usando modelo interno
async def read_item_less_optimized(item_id: str):
    # Aqui, internal_notes poderia vazar se não usássemos um ItemOut específico
    # E tax seria incluído como null mesmo se não explicitamente definido,
    # se default_response_model_exclude_unset não fosse True.
    return fake_items_db.get(item_id, {})

Impacto no Frontend (ex: Vue.js)

Um backend FastAPI otimizado beneficia diretamente qualquer frontend que o consome:

Tempos de Carregamento Mais Rápidos: Respostas mais rápidas da API significam que seu frontend Vue.js pode renderizar dados e atualizar a UI mais rapidamente.
Melhor Experiência do Usuário: Interações mais ágeis e menos espera para o usuário.
Menor Transferência de Dados: O uso de response_model e response_model_exclude_unset reduz o tamanho dos payloads, economizando banda e acelerando a desserialização no cliente.

Embora os exemplos de código sejam focados no backend Python/FastAPI, um frontend Vue.js consumindo estas APIs se beneficiaria diretamente da performance aprimorada sem precisar de alterações específicas no código Vue.js para essas otimizações de backend.

Melhores Práticas Adicionais

Profiling: Use ferramentas como cProfile, Py-Spy, ou Scalene para identificar gargalos de CPU e memória no seu código FastAPI. Para testes de carga, Locust é uma excelente opção.
Deployment: Utilize um servidor ASGI robusto como Uvicorn com múltiplos workers (ex: uvicorn main:app --workers 4) atrás de um proxy reverso como Nginx. Considere containers (Docker) para consistência e escalabilidade.
Monitoramento: Implemente monitoramento para acompanhar métricas de performance, erros e uso de recursos em produção.

Conclusão

Otimizar a performance de suas aplicações FastAPI é um processo contínuo, mas aplicar estas 5 dicas – abraçar o async/await, usar BackgroundTasks, implementar caching, otimizar queries de banco de dados e gerenciar dados eficientemente com Pydantic – fornecerá uma base sólida para APIs Python rápidas, escaláveis e robustas. Lembre-se que essas melhorias no backend têm um impacto direto e positivo na experiência dos usuários do seu frontend, seja ele Vue.js ou qualquer outra tecnologia.

Experimente estas técnicas em seus projetos FastAPI e compartilhe seus resultados e outras dicas de performance nos comentários!

Projeto de Integração: FastAPI, Jinja2 e JSX

Gustavo Garcia Pereira — Sun, 15 Sep 2024 15:34:14 +0000

o prijeto completo esta no meu github
todo-app-with-fastapi-and-react

Este projeto é um experimento para demonstrar como integrar FastAPI, Jinja2 e JSX em uma aplicação web simples. A aplicação resultante é uma lista de tarefas (to-do list) interativa, onde os usuários podem adicionar e remover tarefas.

Nota: Este é um projeto experimental de teste, destinado a fins educacionais e de demonstração.

Índice

Introdução
Visão Geral do Projeto
Tecnologias Utilizadas
Estrutura do Projeto
Instalação
Executando a Aplicação
Uso
Explicação do Código
- Backend (main.py)
- Frontend (app.js)
- Template Jinja2 (index.html)
- Estilos CSS (styles.css)
Considerações Finais

Introdução

Este projeto tem como objetivo mostrar a potencialidade da integração entre o FastAPI (um framework web rápido e moderno para construir APIs com Python), Jinja2 (um motor de templates para renderizar HTML no lado do servidor) e JSX (uma extensão de sintaxe para JavaScript que facilita a escrita de componentes React).

Visão Geral do Projeto

A aplicação é uma lista de tarefas simples que permite:

Adicionar Tarefas: Os usuários podem adicionar novas tarefas à lista.
Remover Tarefas: Cada tarefa possui um botão "Done" que, ao ser clicado, remove a tarefa da lista.
Interatividade em Tempo Real: A interface é atualizada em tempo real usando React com JSX.

Tecnologias Utilizadas

Python 3.6+
FastAPI
Jinja2
React (com JSX)
Babel (para transpilar JSX no navegador)
HTML/CSS
JavaScript

Estrutura do Projeto

- main.py
- templates/
    - index.html
- static/
    - app.js
    - styles.css

Instalação

Clone o repositório ou copie os arquivos para o seu ambiente local.
Crie um ambiente virtual e instale as dependências:

   # Criar o ambiente virtual
   python -m venv venv

   # Ativar o ambiente virtual
   # No Linux/macOS:
   source venv/bin/activate
   # No Windows:
   venv\Scripts\activate

   # Instalar as dependências
   pip install fastapi uvicorn jinja2 aiofiles python-multipart

Executando a Aplicação

Inicie o servidor FastAPI:

   uvicorn main:app --reload

Acesse a aplicação no seu navegador:

Abra http://127.0.0.1:8000/ no seu navegador preferido.

Uso

Adicionar uma Tarefa:
- Digite a descrição da tarefa no campo de entrada.
- Clique no botão "Adicionar" ou pressione "Enter".
Remover uma Tarefa:
- Clique no botão "Done" ao lado da tarefa que deseja remover.

Explicação do Código

Backend (`main.py`)

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
import uuid

app = FastAPI()
templates = Jinja2Templates(directory="templates")

# Montar a pasta static para servir arquivos estáticos
app.mount("/static", StaticFiles(directory="static"), name="static")

# Modelo de Tarefa
class Task(BaseModel):
    id: str
    text: str

# Lista de tarefas em memória
tasks = []

@app.get("/", response_class=HTMLResponse)
async def read_index(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

@app.get("/api/tasks")
async def get_tasks():
    return tasks

@app.post("/api/tasks")
async def add_task(task: Task):
    tasks.append(task)
    return {"message": "Tarefa adicionada com sucesso!"}

@app.delete("/api/tasks/{task_id}")
async def delete_task(task_id: str):
    global tasks
    tasks = [task for task in tasks if task.id != task_id]
    return {"message": "Tarefa removida com sucesso!"}

Descrição:

Servindo Arquivos Estáticos: Usamos StaticFiles para servir CSS e JavaScript da pasta static.
Modelo Task: Define o modelo de dados para uma tarefa, incluindo id e text.
Endpoints:
- GET /: Renderiza a página inicial usando um template Jinja2.
- GET /api/tasks: Retorna a lista de tarefas em formato JSON.
- POST /api/tasks: Adiciona uma nova tarefa à lista.
- DELETE /api/tasks/{task_id}: Remove uma tarefa pelo id.

Frontend (`app.js`)

function App() {
    const [tasks, setTasks] = React.useState([]);
    const [taskText, setTaskText] = React.useState("");

    React.useEffect(() => {
        fetch("/api/tasks")
            .then(response => response.json())
            .then(data => setTasks(data));
    }, []);

    const addTask = (e) => {
        e.preventDefault();
        if (taskText.trim() === "") return;

        const newTask = { id: uuidv4(), text: taskText };

        fetch("/api/tasks", {
            method: "POST",
            headers: {
                "Content-Type": "application/json"
            },
            body: JSON.stringify(newTask)
        })
        .then(response => response.json())
        .then(() => {
            setTasks([...tasks, newTask]);
            setTaskText("");
        });
    };

    const deleteTask = (id) => {
        fetch(`/api/tasks/${id}`, {
            method: "DELETE",
        })
        .then(response => response.json())
        .then(() => {
            setTasks(tasks.filter(task => task.id !== id));
        });
    };

    return (
        <div>
            <form onSubmit={addTask}>
                <input
                    type="text"
                    value={taskText}
                    onChange={(e) => setTaskText(e.target.value)}
                    placeholder="Adicione uma nova tarefa"
                />
                <button type="submit">Adicionar</button>
            </form>
            <ul>
                {tasks.map((task) => (
                    <li key={task.id}>
                        {task.text}
                        <button onClick={() => deleteTask(task.id)}>Done</button>
                    </li>
                ))}
            </ul>
        </div>
    );
}

// Função para gerar IDs únicos no frontend
function uuidv4() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
        const r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
        return v.toString(16);
    });
}

ReactDOM.render(<App />, document.getElementById('root'));

Descrição:

Estado e Efeitos:
- tasks: Armazena a lista de tarefas.
- taskText: Armazena o texto da nova tarefa.
- useEffect: Busca as tarefas existentes ao montar o componente.
Funções:
- addTask: Adiciona uma nova tarefa enviando uma requisição POST ao backend.
- deleteTask: Remove uma tarefa enviando uma requisição DELETE ao backend.
Renderização:
- Formulário para adicionar novas tarefas.
- Lista de tarefas com botão "Done" para cada tarefa.

Template Jinja2 (`index.html`)

<!DOCTYPE html>
<html lang="pt">
<head>
    <meta charset="UTF-8">
    <title>Lista de Tarefas</title>
    <link rel="stylesheet" href="/static/styles.css">
</head>
<body>
    <h1>Minha Lista de Tarefas</h1>
    <div id="root"></div>

    <!-- Importar React e ReactDOM -->
    <script src="https://unpkg.com/react@17/umd/react.development.js" crossorigin></script>
    <script src="https://unpkg.com/react-dom@17/umd/react-dom.development.js" crossorigin></script>

    <!-- Babel para transpilar JSX no navegador -->
    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

    <!-- Seu código JSX -->
    <script type="text/babel" src="/static/app.js"></script>
</body>
</html>

Descrição:

Estrutura Básica: Contém o elemento <div id="root"></div> onde o React renderiza a aplicação.
Importações:
- React e ReactDOM para criar a interface do usuário.
- Babel para transpilar JSX em JavaScript no navegador.
Scripts:
- Carrega o código JSX de app.js.

Estilos CSS (`styles.css`)

body {
    font-family: Arial, sans-serif;
    margin: 20px;
}

h1 {
    color: #333;
}

form {
    margin-bottom: 20px;
}

input[type="text"] {
    padding: 10px;
    width: 300px;
    margin-right: 10px;
}

button {
    padding: 10px 15px;
}

ul {
    list-style-type: none;
    padding: 0;
}

li {
    display: flex;
    justify-content: space-between;
    align-items: center;
    background: #f4f4f4;
    margin-bottom: 5px;
    padding: 10px;
}

button:hover {
    background-color: #ddd;
    cursor: pointer;
}

Descrição:

Estilização Geral: Define fontes, cores e margens para uma aparência limpa.
Formulário e Entradas: Estiliza o formulário de adição de tarefas.
Lista de Tarefas: Estiliza a lista e os itens para melhor visualização.
Botão "Done": Adiciona estilos para o botão de remoção de tarefas.

Considerações Finais

Este projeto demonstra como combinar FastAPI, Jinja2 e JSX para criar uma aplicação web interativa e moderna. Embora seja um experimento de teste, ele fornece uma base sólida para entender como essas tecnologias podem trabalhar juntas.

Pontos Importantes:

Integração de Tecnologias: O FastAPI serve a aplicação e fornece endpoints de API, o Jinja2 renderiza o template inicial, e o React (com JSX) gerencia a interface do usuário.
Comunicação Frontend-Backend: A aplicação React se comunica com o backend usando fetch para realizar operações CRUD.
Estado e Atualização Dinâmica: O uso de React permite que a interface reflita mudanças de estado em tempo real.

Possíveis Extensões:

Persistência de Dados: Integrar um banco de dados para armazenar tarefas de forma persistente.
Autenticação e Autorização: Adicionar login de usuário para listas de tarefas personalizadas.
Melhorias na Interface: Implementar feedback visual, validação de entradas e estilos aprimorados.
Processo de Build do Frontend: Utilizar ferramentas como Webpack ou Parcel para transpilar e empacotar o código JSX para produção.

Nota Final: Este projeto é um experimento para fins educacionais. Em aplicações de produção, recomenda-se seguir as melhores práticas de segurança, desempenho e manutenção de código.

Espero que este projeto sirva como um ponto de partida útil para entender e explorar a integração entre FastAPI, Jinja2 e JSX em aplicações web.

Introdução ao ORM do Django: Exercícios Práticos

Gustavo Garcia Pereira — Wed, 10 Jul 2024 17:36:59 +0000

O ORM (Object-Relational Mapping) do Django é uma poderosa ferramenta que permite aos desenvolvedores interagir com bancos de dados relacionais usando código Python em vez de SQL. Essa abordagem orientada a objetos abstrai a complexidade das consultas SQL, tornando o processo de manipulação de dados mais intuitivo e alinhado com a lógica da aplicação. Com o ORM do Django, modelos de dados são definidos como classes Python, onde cada atributo da classe representa um campo no banco de dados. Isso permite que desenvolvedores trabalhem com dados de uma maneira mais natural e coesa dentro do ambiente de desenvolvimento Python.

Além de simplificar a interação com o banco de dados, o ORM do Django oferece uma série de funcionalidades avançadas que facilitam a execução de consultas complexas, a manipulação de dados e a manutenção da integridade referencial. Por exemplo, ao definir relações entre diferentes modelos, como OneToMany, ManyToMany e ForeignKey, o ORM do Django gerencia automaticamente as ligações entre tabelas, assegurando consistência e integridade dos dados. Adicionalmente, ele suporta operações de CRUD (Create, Read, Update, Delete) de forma eficiente e segura, além de permitir a construção de consultas dinâmicas e otimizadas usando Q objects e filtros. Com essas capacidades, o ORM do Django não só acelera o desenvolvimento, mas também promove práticas de codificação mais limpas e manuteníveis.

Introdução ao ORM do Django: Exercícios Práticos

Neste post, vamos explorar 10 exercícios práticos que cobrem os conceitos fundamentais do ORM do Django. Cada exercício inclui uma pergunta e sua respectiva resposta para que você possa praticar e consolidar seu entendimento.

1. Criação de um Modelo

Assunto: Como definir um modelo Django com campos específicos.

Exercício:
Crie um modelo chamado Book com os campos title (char), author (char) e published_date (date).

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

    def __str__(self):
        return self.title

2. Inserir Registros no Modelo

Assunto: Como inserir registros em um modelo usando o ORM do Django.

Exercício:
Insira um registro no modelo Book com os seguintes valores: title = "Django for Beginners", author = "gustavo g. Pereira", published_date = "2020-01-01".

Book.objects.create(
    title="Django for Beginners",
    author="gustavo g. Pereira",
    published_date="2020-01-01"
)

3. Consultar Registros

Assunto: Como consultar todos os registros de um modelo.

Exercício:
Consulte todos os registros do modelo Book.

books = Book.objects.all()
for book in books:
    print(book.title)

4. Filtrar Registros

Assunto: Como filtrar registros com base em um campo específico.

Exercício:
Filtre os registros do modelo Book onde o author é "William S. Vincent".

books = Book.objects.filter(author="gustavo g. Pereira")
for book in books:
    print(book.title)

5. Atualizar Registros

Assunto: Como atualizar registros existentes no banco de dados.

Exercício:
Atualize o campo title do registro onde o author é "gustavo g. Pereira" para "Django for Experts".

Book.objects.filter(author="gustavo g. Pereira").update(title="Django for Experts")

6. Excluir Registros

Assunto: Como excluir registros do banco de dados.

Exercício:
Exclua todos os registros do modelo Book onde o author é "gustavo g. Pereira".

Book.objects.filter(author="gustavo g. Pereira").delete()

7. Consultar Registros Ordenados

Assunto: Como consultar registros ordenados por um campo específico.

Exercício:
Consulte todos os registros do modelo Book ordenados pelo campo published_date.

books = Book.objects.all().order_by('published_date')
for book in books:
    print(book.title)

8. Usar Valores Distintos

Assunto: Como obter valores distintos de um campo específico.

Exercício:
Consulte todos os valores distintos do campo author no modelo Book.

authors = Book.objects.values('author').distinct()
for author in authors:
    print(author['author'])

9. Limitar a Quantidade de Registros Retornados

Assunto: Como limitar o número de registros retornados em uma consulta.

Exercício:
Consulte os primeiros 5 registros do modelo Book.

books = Book.objects.all()[:5]
for book in books:
    print(book.title)

10. Usar Q Objects para Consultas Complexas

Assunto: Como realizar consultas complexas usando Q objects para combinar múltiplas condições.

Exercício:
Consulte os registros do modelo Book onde o title contém a palavra "Django" e o published_date é após "2019-01-01".

from django.db.models import Q
books = Book.objects.filter(Q(title__icontains="Django") & Q(published_date__gt="2019-01-01"))
for book in books:
    print(book.title)

Espero que esses exercícios práticos ajudem você a entender melhor como utilizar o ORM do Django em suas aplicações. Se você tiver dúvidas ou quiser compartilhar suas próprias experiências, deixe um comentário abaixo!

Funcionalidades Essenciais de um Blog: Exemplos Práticos com Django REST Framework

Gustavo Garcia Pereira — Sun, 07 Jul 2024 01:00:26 +0000

Criar um blog usando Django REST Framework é uma excelente maneira de testar e aprimorar habilidades em desenvolvimento web e APIs RESTful. Este projeto oferece uma visão abrangente das funcionalidades essenciais para um blog, como autenticação de usuários, criação e gerenciamento de posts e comentários, categorização de conteúdos, e sistemas de busca e filtragem. A implementação dessas funcionalidades não só fortalece o entendimento dos conceitos fundamentais do Django e Django REST Framework, mas também prepara o desenvolvedor para enfrentar desafios mais complexos em projetos futuros. Através da criação de um blog, o desenvolvedor iniciante aprende a manipular modelos de dados, construir endpoints de API, e implementar permissões e autenticação, tudo dentro de um ambiente de desenvolvimento realista.

O processo de desenvolvimento de um blog envolve diversas etapas críticas que abrangem desde a configuração inicial do projeto até a definição de modelos de dados, criação de serializers e views, e configuração de rotas. Cada uma dessas etapas é essencial para garantir que o blog funcione de maneira eficiente e segura. Além disso, a integração de funcionalidades adicionais, como sistema de likes, upload de imagens, e paginação, enriquece a aplicação e proporciona uma experiência de usuário mais completa. Ao concluir este projeto, o desenvolvedor não apenas consolida suas habilidades técnicas, mas também ganha uma compreensão prática de como construir aplicações web robustas e escaláveis usando Django REST Framework.

Um exemplo de funcionalidades essenciais para um blog desenvolvido com Django REST Framework inclui a implementação de um sistema de autenticação e autorização. Isso envolve permitir que os usuários se registrem, façam login e logout, garantindo que apenas usuários autenticados possam acessar certas funcionalidades, como a criação e edição de posts. Além disso, cada post deve estar associado a um autor, e a proteção de rotas deve ser configurada para assegurar que apenas o autor possa editar ou deletar seus próprios posts. Essas funcionalidades são fundamentais para manter a integridade e a segurança do conteúdo do blog.

Outro exemplo crucial é a implementação de operações CRUD (Create, Read, Update, Delete) para posts e comentários. Os endpoints devem permitir a criação de novos posts e comentários, a listagem de todos os posts e comentários, a atualização de posts e comentários existentes, e a exclusão dos mesmos. Além disso, a funcionalidade de comentários deve permitir que os usuários adicionem, visualizem, atualizem e deletem comentários em posts de blog. Essa capacidade de gerenciar conteúdo dinamicamente é essencial para qualquer plataforma de blog.

Para enriquecer a funcionalidade do blog, é importante incluir recursos como categorização de posts, sistema de likes e busca/filtro. Posts podem ser associados a categorias ou tags, permitindo melhor organização e filtragem. Um sistema de likes pode ser implementado para permitir que os usuários curtam posts, aumentando a interatividade do blog. Além disso, um sistema de busca e filtragem pode ser adicionado para permitir que os usuários encontrem posts por título, conteúdo, categoria ou tags, melhorando significativamente a experiência do usuário. Essas funcionalidades adicionais tornam o blog mais completo e interativo, proporcionando uma experiência de usuário mais rica e envolvente.

Vamos implementar as funcionalidades para criar um blog usando Django e Django REST Framework. Seguirei uma abordagem paso a passo:

Passo 1: Configuração Inicial

1.1. Instalação do Django e Django REST Framework

Primeiro, crie um ambiente virtual e instale Django e Django REST Framework:

python -m venv env
source env/bin/activate  # On Windows use `env\Scripts\activate`
pip install django djangorestframework

1.2. Criar o Projeto Django

django-admin startproject blog_project
cd blog_project

1.3. Criar o Aplicativo do Blog

python manage.py startapp blog

1.4. Adicionar Aplicativos ao `INSTALLED_APPS`

Edite blog_project/settings.py para adicionar rest_framework e blog aos aplicativos instalados:

INSTALLED_APPS = [
    ...
    'rest_framework',
    'blog',
]

Passo 2: Modelos

2.1. Modelos de Post e Comentário

Edite blog/models.py para definir os modelos:

from django.db import models
from django.contrib.auth.models import User

class Category(models.Model):
    name = models.CharField(max_length=255)

    def __str__(self):
        return self.name

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    categories = models.ManyToManyField(Category)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.title

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name='comments', on_delete=models.CASCADE)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return f'Comment by {self.author} on {self.post}'

Passo 3: Serializers

Crie blog/serializers.py para definir os serializers:

from rest_framework import serializers
from .models import Post, Comment, Category
from django.contrib.auth.models import User

class CategorySerializer(serializers.ModelSerializer):
    class Meta:
        model = Category
        fields = '__all__'

class CommentSerializer(serializers.ModelSerializer):
    author = serializers.ReadOnlyField(source='author.username')

    class Meta:
        model = Comment
        fields = '__all__'

class PostSerializer(serializers.ModelSerializer):
    author = serializers.ReadOnlyField(source='author.username')
    comments = CommentSerializer(many=True, read_only=True)
    categories = CategorySerializer(many=True)

    class Meta:
        model = Post
        fields = '__all__'

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username']

Passo 4: Views

Crie blog/views.py para definir as views:

from rest_framework import viewsets
from .models import Post, Comment, Category
from .serializers import PostSerializer, CommentSerializer, CategorySerializer, UserSerializer
from django.contrib.auth.models import User
from rest_framework.permissions import IsAuthenticatedOrReadOnly

class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

class CommentViewSet(viewsets.ModelViewSet):
    queryset = Comment.objects.all()
    serializer_class = CommentSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

class CategoryViewSet(viewsets.ModelViewSet):
    queryset = Category.objects.all()
    serializer_class = CategorySerializer

class UserViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

Passo 5: URLs

Crie blog/urls.py e defina as rotas da API:

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import PostViewSet, CommentViewSet, CategoryViewSet, UserViewSet

router = DefaultRouter()
router.register(r'posts', PostViewSet)
router.register(r'comments', CommentViewSet)
router.register(r'categories', CategoryViewSet)
router.register(r'users', UserViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

Adicione as rotas do aplicativo blog ao blog_project/urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('blog.urls')),
]

Passo 6: Configuração de Autenticação

Adicione URLs de autenticação em blog_project/urls.py:

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('blog.urls')),
    path('api-auth/', include('rest_framework.urls')),  # Adicione esta linha
]

Passo 7: Migrações e Superusuário

Crie as migrações e o superusuário:

python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser

Passo 8: Teste

Execute o servidor de desenvolvimento:

python manage.py runserver

Agora, você deve ter um blog básico funcionando com as funcionalidades listadas. Você pode testar os endpoints usando ferramentas como Postman ou diretamente pelo navegador.

Construindo um Blog Simples com Server.js: Uma Introdução Prática ao Desenvolvimento Web com Node.js

Gustavo Garcia Pereira — Tue, 02 Jul 2024 23:28:57 +0000

Neste tutorial, exploraremos como o server.js, um framework ágil e robusto para Node.js, pode ser utilizado para criar um blog simples mas funcional. Demonstraremos passo a passo como configurar o servidor, gerenciar rotas, e processar dados, tudo isso utilizando a elegância e a simplicidade que o server.js oferece. Este guia prático é ideal para desenvolvedores que buscam implementar rapidamente aplicações web, oferecendo uma excelente introdução às capacidades do server.js, desde a criação de interfaces até o manejo eficiente de requisições web.
documentation

Sobre o Projeto

O projeto apresentado é a construção de um pequeno blog utilizando o framework server.js. Este blog é capaz de listar postagens armazenadas e permitir a criação de novas postagens através de uma interface web simples. A estrutura do projeto inclui um servidor configurado com rotas específicas para exibir as postagens existentes e receber novas através de formulários web. Os posts são armazenados em uma lista em memória, simulando um banco de dados, o que facilita a demonstração e o desenvolvimento sem necessidade de configurações adicionais de banco de dados.

Funcionalidades do Projeto

O sistema do blog permite que usuários visualizem uma lista de postagens e acessem conteúdo específico clicando nos títulos listados na página inicial. Além disso, usuários podem adicionar novos posts através de uma interface simples que coleta título e conteúdo via método POST. Esta aplicação é ideal para demonstrar o funcionamento básico do server.js, incluindo o manuseio de rotas, recebimento e processamento de dados de formulários, e a renderização de páginas dinâmicas com templates Handlebars.

Sobre o server.js

Server.js é um framework leve e moderno para Node.js, projetado para simplificar a criação de servidores web e APIs. Ele abstrai muitas complexidades do gerenciamento direto de servidores HTTP, permitindo que os desenvolvedores configurem rapidamente rotas, middleware, e respostas. O server.js é construído sobre o Express, uma das bibliotecas mais populares para aplicações web em Node.js, fornecendo uma camada adicional de simplicidade e funcionalidades prontas para usar.

Características da Ferramenta

A ferramenta server.js oferece uma maneira simplificada de lidar com rotas HTTP, processamento de requisições e envio de respostas, incluindo suporte a JSON e redirecionamentos. Ela facilita a integração de middlewares e a utilização de templates para renderizar páginas web, além de permitir uma configuração detalhada através de opções diversas que controlam desde a segurança até a personalização completa do servidor. Isso torna o server.js uma escolha eficiente para desenvolvedores que buscam rapidez no desenvolvimento de aplicações web com Node.js.

Estrutura do Projeto

Primeiramente, certifique-se de ter o Node.js instalado e crie um novo diretório para o seu projeto. No diretório do projeto, crie um arquivo chamado index.js, que será o ponto de entrada do seu servidor.

Instalando Dependências

Você precisa instalar o pacote server.js antes de começar. Abra o terminal e execute:

npm install server

Criando o Servidor

Aqui está o código para index.js que configura o servidor e as rotas:

const server = require('server');
const { get, post } = server.router;
const { render, json } = server.reply;

// Simulando um banco de dados simples em memória
let posts = [
  { id: 1, title: "Primeiro Post", content: "Este é o primeiro post do blog." }
];

// Rota para mostrar a lista de posts
server([
  get('/', ctx => render('index.hbs', { posts })),
  get('/post/:id', ctx => {
    const post = posts.find(p => p.id == ctx.params.id);
    return post ? render('post.hbs', { post }) : status(404);
  }),
  post('/', ctx => {
    const newPost = { id: posts.length + 1, title: ctx.data.title, content: ctx.data.content };
    posts.push(newPost);
    return redirect('/');
  })
]);

console.log('Servidor rodando na porta 3000...');

Templates Handlebars

Você também precisará de alguns templates Handlebars para renderizar o HTML. Crie um diretório views e adicione os seguintes arquivos:

index.hbs: Para mostrar a lista de todos os posts.
post.hbs: Para mostrar um post específico.

Exemplo de `index.hbs`

<h1>Blog</h1>
<ul>
  {{#each posts}}
    <li><a href="/post/{{this.id}}">{{this.title}}</a></li>
  {{/each}}
</ul>
<a href="/new">Novo Post</a>

Exemplo de `post.hbs`

<article>
  <h1>{{post.title}}</h1>
  <p>{{post.content}}</p>
</article>
<a href="/">Voltar</a>

Rodando o Servidor

Agora que você tem seu servidor configurado e seus templates prontos, você pode iniciar o servidor com o Node.js:

node index.js

Este exemplo básico demonstra como usar o server.js para construir um blog simples, com funcionalidades de visualização e criação de posts. As rotas lidam com as requisições GET e POST, enquanto os templates Handlebars apresentam os posts de forma agradável ao usuário.

Construindo APIs Rápidas e Eficientes com FastAPI e Jinja2: Uma Abordagem Arquitetural

Gustavo Garcia Pereira — Fri, 28 Jun 2024 23:59:19 +0000

Introdução:

No mundo do desenvolvimento web, a eficiência e a rapidez na entrega de aplicações são vitais. FastAPI, um moderno framework web para construção de APIs com Python, promete alta performance com sua capacidade de suportar programação assíncrona e a robustez dos tipos estáticos. Quando combinado com o motor de templates Jinja2, FastAPI não só acelera o back-end, mas também facilita a integração com front-ends dinâmicos. Neste artigo, exploraremos como essas ferramentas podem ser utilizadas juntas para criar uma arquitetura de aplicação eficaz e escalável.

Desenvolvimento:

1. FastAPI: O Motor por Trás de APIs Rápidas

FastAPI se destaca por sua simplicidade e performance. Baseado em Starlette para o handling de requisições web e Pydantic para a validação de dados, o framework permite o desenvolvimento rápido de APIs que são simultaneamente robustas e escaláveis. A capacidade de gerar documentação interativa através do Swagger UI e ReDoc, graças à incorporação de padrões OpenAPI, é um dos seus pontos fortes, permitindo que desenvolvedores e stakeholders testem as APIs em tempo real.

2. Jinja2: Flexibilidade no Front-End

Jinja2 serve como uma ponte entre o back-end e o front-end, permitindo a criação de páginas HTML dinâmicas com dados reativos. A sintaxe do Jinja2 é bastante intuitiva, oferecendo recursos poderosos como herança de templates e blocos reutilizáveis, que facilitam a manutenção do código e a coesão do design. Esta ferramenta é ideal para projetos que requerem uma renderização rápida e eficiente do lado do servidor.

3. Integrando FastAPI com Jinja2

A integração de FastAPI com Jinja2 pode ser realizada através do middleware que permite a renderização de templates Jinja2 dentro de respostas FastAPI. Isso possibilita que os desenvolvedores construam aplicações web completas sem a necessidade de um framework front-end separado. Exemplos práticos dessa integração incluem a criação de dashboards administrativos, plataformas de e-commerce e outras aplicações web que requerem interatividade complexa e desempenho de alta velocidade.

4. Arquitetura Recomendada: Construindo com Escalabilidade em Mente

Ao planejar uma aplicação usando FastAPI e Jinja2, é crucial considerar a arquitetura do sistema. Uma abordagem modular, onde os componentes são separados por responsabilidades claras, facilita a escalabilidade e a manutenção. Utilizando containers como Docker e orquestradores como Kubernetes, FastAPI e Jinja2 podem ser integrados em microserviços que são fáceis de gerenciar, atualizar e escalar.

Conclusão:

A combinação de FastAPI e Jinja2 oferece uma solução poderosa para o desenvolvimento de aplicações web modernas. Essa abordagem não só otimiza o desenvolvimento e a manutenção dos projetos, mas também garante uma performance superior. Com uma arquitetura bem planejada, as aplicações construídas com essas ferramentas estão preparadas para crescer e evoluir junto com as demandas do mercado.

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/admin", response_class=HTMLResponse)
async def get_admin(request: Request):
    users = [{"name": "Alice", "role": "Admin"}, {"name": "Bob", "role": "User"}]
    return templates.TemplateResponse("admin_dashboard.html", {"request": request, "users": users})

from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/blog", response_class=HTMLResponse)
async def view_blog(request: Request):
    blog_posts = [{"title": "FastAPI & Jinja2", "content": "Great for web apps!"}]
    return templates.TemplateResponse("blog.html", {"request": request, "posts": blog_posts})

from fastapi import FastAPI, Request, Form
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.post("/feedback", response_class=HTMLResponse)
async def receive_feedback(request: Request, feedback: str = Form(...)):
    # Aqui você salvaria o feedback no banco de dados
    return templates.TemplateResponse("feedback_received.html", {"request": request, "feedback": feedback})

@app.get("/feedbacks", response_class=HTMLResponse)
async def list_feedbacks(request: Request):
    feedbacks = ["FastAPI is awesome!", "Needs more documentation."]
    return templates.TemplateResponse("feedback_list.html", {"request": request, "feedbacks": feedbacks})

Python com Celery

Gustavo Garcia Pereira — Sat, 16 Oct 2021 23:21:31 +0000

Olá caro leitor, no video que vou deixar a baixo eu explico sobre o uso do celery o que é e o que eu posso fazer com ele.
Ainda dou um pequeno exemplo:

Link video

Server com node: serverjs

Gustavo Garcia Pereira — Sun, 11 Jul 2021 23:46:15 +0000

Servidor Simples com JavaScript e `server.js`

Neste post, mergulharemos no mundo da programação para entender como criar e gerenciar servidores, uma habilidade crucial para qualquer desenvolvedor que busca aprimorar suas capacidades. Compartilharei minha experiência com server.js, uma ferramenta intuitiva e eficiente para configurar servidores e criar APIs de maneira simples e rápida. Vou guiá-lo, passo a passo, mostrando como configurar, instalar e criar rotas, além de oferecer dicas valiosas sobre o uso de templates com Pug.

Motivação

O objetivo é consolidar meu conhecimento e apresentar uma forma simplificada de criar uma API.

Começando

Primeiro, instale o server.js:

bash
npm install server

Inclua a seguinte dependência em seu arquivo de configuração:

"dependencies": {
    "server": "^1.0.34"
  }

Após a instalação, vamos criar nossa primeira rota. Comece importando o server e os métodos necessários:

const server = require('server');
const { get, post, error } = server.router;

Configure o servidor com:

const CONFIG = {
    security:{csrf:false}, port:8080
}

Inicie o servidor com a seguinte estrutura:

server(CONFIG, []) // Aqui, adicionaremos nossos métodos e rotas.

Template Pug

Antes de prosseguir, vamos explorar os templates. Utilizo Pug para manipular templates de forma eficiente. Para mais informações, consulte a documentação do Pug. Para integrar o Pug ao seu projeto, utilize o método render:

const { render } = server.reply;

Rotas

As rotas são definidas utilizando métodos como get e post. Aqui estão alguns exemplos:

get('/', () => {
    return render('index.pug', {nome: "meu nome"});
}),
get('/sobre', () => {
    return render('sobre.html');
}),
post('/', (ctx) => {
    console.log(ctx.data['nome'], ctx.data['idade']);
    return render('boas_vindas.pug', {nome: ctx.data['nome'], idade: ctx.data['idade']});
})

O Pug permite passar objetos e realizar herança de templates, o que é extremamente útil e prático.

Código Completo

Aqui está o código completo do servidor com server.js:

const server = require('server')
const { get, post } = server.router
const { render } = server.reply
const CONFIG = {
    security:{csrf:false},port:8080
}

server(CONFIG, [
    // Adicione suas rotas aqui
])

Para mais detalhes, confira a documentação do server.js e serverjs.io.

Vídeo Tutorial

Gravei um vídeo explicando tudo o que está neste artigo com mais detalhes. Assista ao vídeo aqui.

A little about my literary passion

Gustavo Garcia Pereira — Tue, 29 Jun 2021 02:10:05 +0000

I am currently 25 years old, and from a very young age I have enjoyed reading.
But this passion only became more fervent after I was 20.

For a long time I read the wrong way, I wanted to read fast so I could finish quickly and acquire more knowledge quickly.

But it doesn't work like that, when you read, it is a dialogue between you and the author and this needs calm.

When I was younger I couldn't concentrate to read, so I resorted to dynamic reading 'techniques' and the like. But they never worked for me.

So I would pass my eyes over the books and read, but due to my little concentration nothing was stored and worse, I got very frustrated, I kept looking for some magic technique, this doesn't exist.

Well then how did I become a 'real' reader, it's a pretty simple thing really. First quiet, as I said before it's a conversation between you and the reader, I read at the speed I talk a little slower, in fact while imagining the story it makes you occupy your mind with just the story you are reading.

This causes a miracle in your mind, when you start reading and the story just sticks in your brain that is amazing, in the first book or two it may feel bored, but with time this is replaced by a feeling of satisfaction for what you are reading.

Some people will think this is too slow, I need a technique for yesterday, first this does not exist, second the speed and the quantity of reading only increase due to the frequency. I hope you enjoy this advice!

Um pouco sobre minha paixão literária

Gustavo Garcia Pereira — Wed, 23 Jun 2021 17:30:18 +0000

Tenho atualmente 25 anos, e desde muito novo gostei de ler.
Mas essa paixão só ficou mais fervorosa depois dos 20.

Turante muito 'muito' tempo li de forma errada, queria ler rápido para abar rápido e assim adquirir mais conhecimento rápido.

Mas no em tento não funciona assim, quando você lê, é um dialogo entre você e o autor e isso precisa de calma.

Quando era mais novo eu não conseguia me concentrar para ler, ai recorri a 'técnicas' de leitura dinâmica e coisas do gênero. No piorou nunca funcionaram comigo.

Então passava os olhos pelas letrar lia, mas devido à minha pouca concentração nada ficava armazenado e pior, me frustrava muito, ficava buscando alguma técnica mágica, isso não existe.

Bom então como eu me tornei um leitor 'de verdade', é uma coisa bem simples, na verdade. Primeiro calma, como disse anteriormente é uma conversa entre você e o leitor, eu leio na velocidade que eu falo um pouco mais lento, na verdade, enquanto isso imagine a história isso faz com que você ocupe a sua mente com somente a história que você esta lendo.

Isso provoca um milagre na sua mente, quando você começar a ler e a história simplesmente colar no teu cérebro isso é incrível, no primeiro livro ou segundo pode dar uma sensação de tédio, mas com o tempo isso é substituído por uma sensação de satisfação por quilo que esta lendo.

Algumas, pessoa vão pensar isso é muito lento, eu preciso que uma técnica para ontem, primeiro isso não existe, segundo a velocidade e a quantidade de leitura só aumentam devido à frequência. Espero que gostem deste conselho!

vuejs e django

Gustavo Garcia Pereira — Thu, 11 Mar 2021 22:38:36 +0000

Olá caro leitor, sou gustavo pereira.
Vim aqui escrever sobre um pequeno projeto que fiz com django e vuejs.

Bom, vamos lá.

tudo esta neste repo

O backend fiz em django: se encontra na pasta "backend" ,
clonado o repositório e entrando na pasta, pode criar um virtualenv,

   pip install -r requirements.txt

para instalar todas as dependência que precisa.
atualmento o back esta rodando no heroku, aqui

Front-end
Entrando na pasta

cd cadastro-entrevista/
yarn
yarn server

e o front esta rodando no github pages link aqui

pretendo fazer um post mais detalhado no futuro
mas se interessou pode olhar o readme.

obrigado e abraço!

DEV Community: Gustavo Garcia Pereira

Guia Definitivo para Otimizar Aplicações FastAPI: 5 Estratégias de Performance com Python e Vue.js

Introdução

1. Async/Await: Domine a Execução Não-Bloqueante (Python)

2. Cache de Dados com Redis (Python + Docker)

3. Otimização de Consultas no Banco de Dados (SQLAlchemy)

4. Compressão de Respostas HTTP (FastAPI Middleware)

5. Lazy Loading no Vue.js (Frontend)

Caso Real: E-commerce com 10k Requisições/Minuto

Erros Fatais a Evitar

Conclusão

FastAPI: 5 Dicas Cruciais para Turbinar a Performance da sua API Python

Por que a Performance em FastAPI Importa?

1. Abrace o Poder do async e await

2. Utilize Tarefas em Background (BackgroundTasks)

3. Implemente Caching Inteligente

4. Otimize suas Consultas ao Banco de Dados

5. Gestão Eficiente de Dados com Pydantic e Modelos de Resposta

Impacto no Frontend (ex: Vue.js)

Melhores Práticas Adicionais

Conclusão

Projeto de Integração: FastAPI, Jinja2 e JSX

Índice

Introdução

Visão Geral do Projeto

Tecnologias Utilizadas

Estrutura do Projeto

Instalação

Executando a Aplicação

Uso

Explicação do Código

Backend (main.py)

Frontend (app.js)

Template Jinja2 (index.html)

Estilos CSS (styles.css)

Considerações Finais

Introdução ao ORM do Django: Exercícios Práticos

Introdução ao ORM do Django: Exercícios Práticos

1. Criação de um Modelo

2. Inserir Registros no Modelo

3. Consultar Registros

4. Filtrar Registros

5. Atualizar Registros

6. Excluir Registros

7. Consultar Registros Ordenados

8. Usar Valores Distintos

9. Limitar a Quantidade de Registros Retornados

10. Usar Q Objects para Consultas Complexas

Funcionalidades Essenciais de um Blog: Exemplos Práticos com Django REST Framework

Passo 1: Configuração Inicial

1.1. Instalação do Django e Django REST Framework

1.2. Criar o Projeto Django

1.3. Criar o Aplicativo do Blog

1.4. Adicionar Aplicativos ao INSTALLED_APPS

Passo 2: Modelos

2.1. Modelos de Post e Comentário

Passo 3: Serializers

Passo 4: Views

Passo 5: URLs

Passo 6: Configuração de Autenticação

Passo 7: Migrações e Superusuário

Passo 8: Teste

Construindo um Blog Simples com Server.js: Uma Introdução Prática ao Desenvolvimento Web com Node.js

Sobre o Projeto

Funcionalidades do Projeto

Sobre o server.js

Características da Ferramenta

Estrutura do Projeto

Instalando Dependências

Criando o Servidor

Templates Handlebars

Exemplo de index.hbs

Exemplo de post.hbs

Rodando o Servidor

Construindo APIs Rápidas e Eficientes com FastAPI e Jinja2: Uma Abordagem Arquitetural

Python com Celery

Server com node: serverjs

Servidor Simples com JavaScript e server.js

Motivação

Começando

1. Abrace o Poder do `async` e `await`

2. Utilize Tarefas em Background (`BackgroundTasks`)

Backend (`main.py`)

Frontend (`app.js`)

Template Jinja2 (`index.html`)

Estilos CSS (`styles.css`)

1.4. Adicionar Aplicativos ao `INSTALLED_APPS`

Exemplo de `index.hbs`

Exemplo de `post.hbs`

Servidor Simples com JavaScript e `server.js`