FastAPI é um framework web moderno e de alto desempenho para a criação de APIs com Python. Ele foi projetado para ser fácil de usar e aprender, ao mesmo tempo que oferece recursos poderosos como validação automática, serialização e documentação de API interativa automática. Além disso, funciona com qualquer mecanismo de modelos e permite que você use qualquer configuração de modelo padrão necessária para o seu projeto.

Vamos analisar em detalhes o FastAPI , seus recursos e como usá-lo de forma eficaz. Mais adiante neste artigo, também analisaremos o IronPDF , um pacote Python para geração de PDFs da Iron Software .

Principais funcionalidades da FastAPI

1. Alto desempenho: FastAPI é um dos frameworks Python mais rápidos disponíveis, comparável a Node.js e Go, graças ao uso de Starlette para as partes web e Pydantic para as partes de dados.
2. Facilidade de uso: Foi projetado para ser intuitivo e reduzir o tempo gasto na leitura da documentação. A estrutura utiliza dicas padrão do tipo Python para validação e serialização de dados.
3. Documentação Interativa Automática: O FastAPI gera automaticamente documentação de API interativa usando OpenAPI e JSON Schema, acessível via /docs (interface do usuário Swagger) e /redoc (ReDoc). Quaisquer atualizações na API são refletidas automaticamente na documentação.
4. Suporte do editor: Excelente suporte para preenchimento automático de código e verificação de tipos em editores como o VS Code, tornando o desenvolvimento mais rápido e reduzindo erros.
5. Baseado em padrões: É baseado em (e totalmente compatível com) os padrões abertos para APIs: OpenAPI e JSON Schema.

Instalação

Você pode instalar o FastAPI e o Uvicorn (um servidor ASGI) usando o pip:

pip install fastapi
pip install "uvicorn[standard]"

pip install fastapi
pip install "uvicorn[standard]"

Criando seu primeiro aplicativo FastAPI

Aqui está um exemplo simples para você começar a usar o FastAPI e expor dados Python por meio de uma interface de usuário:

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

# Create a FastAPI 'app' instance
app = FastAPI()

# Root path operation
@app.get("/")
def read_root():
    return {"Hello": "World"}

# Path operation for items including query parameter 'q'
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Para executar a aplicação, utilize o Uvicorn:

uvicorn main:app --reload

uvicorn main:app --reload

Este comando iniciará um servidor de desenvolvimento e recarregará automaticamente quando houver alterações no código. Você pode acessar a documentação interativa da API em http://127.0.0.1:8000/docs.

Recursos avançados

O FastAPI oferece suporte a uma ampla gama de recursos avançados, tornando-o adequado para aplicações complexas:

1. Injeção de Dependência: O FastAPI fornece um sistema de injeção de dependência poderoso que permite gerenciar dependências de forma limpa e eficiente.
2. Tarefas em segundo plano: Você pode definir tarefas em segundo plano para serem executadas após o retorno de uma resposta, o que é útil para tarefas como o envio de e-mails ou o processamento de dados.
3. WebSockets: O FastAPI oferece suporte a WebSockets, permitindo a comunicação em tempo real entre o cliente e o servidor.
4. Segurança: O FastAPI inclui ferramentas para lidar com segurança, incluindo OAuth2, tokens JWT e muito mais.
5. Integração com Banco de Dados: O FastAPI pode ser facilmente integrado a bancos de dados usando bibliotecas como SQLAlchemy ou Tortoise-ORM.

Exemplo: Construindo uma API CRUD

Vamos construir uma API CRUD (Criar, Ler, Atualizar, Excluir) simples para gerenciar itens.

1. Defina o modelo de dados:

from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

from pydantic import BaseModel

# Define a Pydantic model for the item with default description and tax
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

2. Crie o aplicativo FastAPI:

from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException

# Initialize 'app' instance and an empty 'items' dictionary
app = FastAPI()
items = {}

# Create operation: Add a new item
@app.post("/items/")
def create_item(item: Item):
    item_id = len(items) + 1
    items[item_id] = item
    return item

# Read operation: Retrieve an item by 'item_id'
@app.get("/items/{item_id}")
def read_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[item_id]

# Update operation: Replace an existing item
@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[item_id] = item
    return item

# Delete operation: Remove an item by 'item_id'
@app.delete("/items/{item_id}")
def delete_item(item_id: int):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[item_id]
    return {"message": "Item deleted"}

Apresentando o IronPDF

IronPDF é uma poderosa biblioteca Python projetada para criar, editar e assinar PDFs a partir de HTML, CSS, imagens e JavaScript. Oferece desempenho de nível comercial com baixo consumo de memória. As principais características incluem:

Conversão de HTML para PDF

Converter arquivos HTML, strings HTML e URLs em PDFs. Por exemplo, renderize uma página da web como um PDF usando o renderizador de PDF do Chrome.

Suporte multiplataforma

Compatível com diversas plataformas .NET , incluindo .NET Core, .NET Standard e .NET Framework. É compatível com Windows, Linux e macOS.

Edição e assinatura

Configure propriedades, adicione segurança com senhas e permissões e aplique assinaturas digitais aos seus PDFs.

Modelos de página e configurações

Personalize PDFs com cabeçalhos, rodapés, números de página e margens ajustáveis. Suporta layouts responsivos e tamanhos de papel personalizados.

Conformidade com as normas

Está em conformidade com os padrões PDF, como PDF/A e PDF/UA. Suporta codificação de caracteres UTF-8 e lida com recursos como imagens, CSS e fontes.

Gere documentos PDF usando IronPDF e FastAPI.

pip install fastapi ironpdf

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

from fastapi import FastAPI
from fastapi.responses import FileResponse
from ironpdf import *

# Apply your IronPDF license key
License.LicenseKey = "key"

# Initialize 'app' instance
app = FastAPI()

# Route for simple greeting
@app.get("/")
def read_root():
    return {"Hello": "IronPDF"}

# Route that reads items with path and query parameters
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

# Route for generating a PDF document
@app.get("/pdf")
async def get_pdf(greet1: str = None, greet2: str = None):
    # Use ChromePdfRenderer to create PDF from HTML
    renderer = ChromePdfRenderer()
    content = "<h1>Document Generated using IronPDF with FastAPI GET</h1>"
    content += "<p> Demonstrate PDF generation using User Inputs</p>"
    content += f"<p>Greetings from: {greet1}</p>"
    content += f"<p>And Greetings from: {greet2}</p>"
    pdf = renderer.RenderHtmlAsPdf(content)
    
    # Save the PDF to a file
    pdf.SaveAs("fastapi.pdf")
    
    # Create a response with the generated PDF
    headers = {
        "Content-Disposition": "inline; filename=sample.pdf"
    }
    return FileResponse("fastapi.pdf", media_type="application/pdf", headers=headers)

Explicação do código

Este trecho de código demonstra a integração do IronPDF com o FastAPI para gerar dinamicamente documentos PDF com base nas entradas do usuário e disponibilizá-los como uma resposta para download.

1. Configurar chave de licença: Aplica a chave de licença do IronPDF para ativar seus recursos.

2. Inicialização do FastAPI: Inicializa uma instância do FastAPI (app) para lidar com requisições HTTP.

3. Manipuladores de rotas básicos:

   • read_root(): Responde com uma mensagem JSON simples indicando "Hello IronPDF" ao acessar o URL raiz (/).
   • read_item(): Aceita um parâmetro de caminho item_id e um parâmetro de consulta q opcional. Retorna uma resposta JSON com esses parâmetros.

4. Rota de Geração de PDF (/pdf):

   • get_pdf(): Esta função assíncrona lida com solicitações GET para o ponto de extremidade /pdf com parâmetros de consulta opcionais chamados greet1 e greet2.
   • Constrói uma string HTML (content) que inclui:
     • Um cabeçalho que indica a origem e a finalidade do documento.
     • Um parágrafo demonstrando a geração de PDF usando entradas do usuário (greet1 e greet2).
   • Usa ChromePdfRenderer() do IronPDF para renderizar o conteúdo HTML em um PDF (pdf = renderer.RenderHtmlAsPdf(content)).
   • Salva o PDF gerado como "fastapi.pdf" (pdf.SaveAs("fastapi.pdf")).

5. Servindo o PDF:

   • Configura os cabeçalhos de resposta para especificar que o PDF deve ser visualizado inline no navegador ("Content-Disposition": "inline; filename=sample.pdf").
   • Cria um objeto FileResponse apontando para o arquivo PDF gerado com o tipo de mídia apropriado ("application/pdf").
   • Retorna o objeto FileResponse, que dispara o download do documento PDF quando o endpoint /pdf é acessado.

Este trecho de código ilustra como o IronPDF pode ser perfeitamente integrado ao FastAPI para gerar e fornecer documentos PDF dinamicamente com base nas entradas do usuário. Ele demonstra a capacidade de converter conteúdo HTML em PDFs, tornando-o adequado para aplicações que exigem geração e entrega de documentos em tempo real via HTTP.

Saída

Abaixo, você encontrará a saída do Swagger gerada pelas APIs.

PDF

Licença IronPDF

O IronPDF funciona com a chave de licença do Python. O IronPDF for Python oferece uma chave de licença de avaliação gratuita para permitir que os usuários experimentem os recursos antes da compra.

Insira a chave de licença no início do script antes de usar o pacote IronPDF :

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

from ironpdf import *
# Apply your license key
License.LicenseKey = "key"

Conclusão

FastAPI é um framework poderoso e fácil de usar para construir APIs em Python. O FastAPI possui alto desempenho, documentação automática e recursos avançados, o que o torna uma excelente escolha tanto para iniciantes quanto para desenvolvedores experientes. Quer você esteja criando uma API simples ou um aplicativo web complexo, o FastAPI fornece as ferramentas necessárias para o seu sucesso.

IronPDF é uma biblioteca Python robusta para criar, manipular e renderizar documentos PDF a partir de conteúdo HTML. Oferece funcionalidades como conversão de HTML para PDF, criação de formulários interativos, manipulação de PDFs (fusão, divisão) e extração de texto. Ideal para gerar PDFs dinâmicos com facilidade e integrar em diversas aplicações Python.