Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF for Python
  2. Blog do IronPDF for Python
  3. Comparação de produtos
  4. FastAPI Python
COMPARAçãO DE PRODUTOS

FastAPI em Python (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

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]"
SHELL

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}
PYTHON

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

uvicorn main:app --reload
uvicorn main:app --reload
SHELL

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
PYTHON
  1. 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"}
PYTHON

Apresentando o IronPDF

FastAPI Python (Como funciona para desenvolvedores): Figura 1

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
pip install ironPDF
pip install fastapi
pip install ironPDF
SHELL 
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)
PYTHON

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 solicitações HTTP.

  3. Manipuladores de rotas básicos:

    • read_root(): Responde com uma mensagem JSON simples indicando "Olá IronPDF" ao acessar o URL raiz (/).
    • read_item(): Aceita um parâmetro de caminho item_id e um parâmetro de consulta opcional q. 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 endpoint /pdf com parâmetros de consulta opcionais denominados 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 diretamente 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 aciona 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.

FastAPI Python (Como funciona para desenvolvedores): Figura 2

PDF

FastAPI Python (Como funciona para desenvolvedores): Figura 3

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"
PYTHON

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.

Perguntas frequentes

Como posso converter conteúdo HTML em PDF em uma aplicação Python?

Você pode usar ChromePdfRenderer do IronPDF para converter conteúdo HTML, CSS e JavaScript em um arquivo PDF. Isso permite uma integração perfeita em aplicativos Python para gerar documentos PDF a partir de conteúdo da web.

Quais são os benefícios de usar o FastAPI para criar APIs?

FastAPI oferece alto desempenho, validação automática, serialização e documentação de API interativa. Utiliza Starlette e Pydantic para garantir velocidade e eficiência comparáveis a Node.js e Go, além de suportar padrões abertos como OpenAPI.

Como posso disponibilizar um documento PDF no FastAPI?

Você pode disponibilizar um documento PDF no FastAPI gerando-o com o IronPDF e retornando-o usando FileResponse do FastAPI. Essa abordagem permite criar e disponibilizar PDFs dinamicamente com base nas solicitações do cliente.

O que torna o FastAPI adequado para aplicações em tempo real?

O FastAPI oferece suporte a WebSockets, que permitem a comunicação em tempo real entre o cliente e o servidor, tornando-o uma escolha ideal para aplicativos que exigem atualizações instantâneas de dados ou interações ao vivo.

Como o FastAPI lida com a validação e serialização de dados?

A FastAPI utiliza modelos Pydantic e dicas padrão do tipo Python para lidar com a validação e serialização de dados. Isso garante que os dados de entrada sejam validados corretamente e convertidos para o formato desejado, reduzindo a probabilidade de erros.

Quais recursos de segurança o FastAPI oferece?

O FastAPI oferece recursos de segurança robustos, incluindo OAuth2, autenticação JWT e injeção de dependência, permitindo que os desenvolvedores criem aplicativos seguros com o mínimo de esforço.

O IronPDF pode ser usado em aplicações multiplataforma?

Sim, o IronPDF foi projetado para ser multiplataforma, compatível com Windows, Linux e macOS. Isso o torna uma opção versátil para desenvolvedores que desejam integrar a geração de PDFs em aplicativos executados em diferentes sistemas operacionais.

Como o FastAPI melhora a produtividade do desenvolvedor?

O FastAPI melhora a produtividade do desenvolvedor ao oferecer documentação automática de API, preenchimento automático de código e verificação de tipos. Isso reduz a necessidade de extensa documentação manual e ajuda a detectar erros no início do processo de desenvolvimento.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim