Quais bibliotecas usar para gerar PDFs em GO?

Para gerar PDF em Go, use gofpdf ou Maroto para tarefas simples, e Unipdf ou pdfcpu para tarefas avançadas.

Gerando relatórios em PDF em GO

OK. Agora gerando PDFs em GO!

Conteúdo da página

Gerar documentos PDF de forma programática pode ser uma funcionalidade importante no seu aplicativo. Aqui exploramos e damos uma breve revisão com exemplos das bibliotecas disponíveis na linguagem de programação Go (Golang) para gerar arquivos PDF.

Soluções adequadas podem variar, por exemplo, para a criação de documentos simples ou para a geração de PDFs complexos e ricos em recursos.

go, pdf! Sim, a imagem é gerada por IA, o modelo é Flux1.Dev.

Bibliotecas e Ferramentas

gofpdf

GoPdf é uma biblioteca simples para criar PDFs. Permite adicionar texto, imagens, formas, tabelas e lidar com várias páginas. Adequada para tarefas de criação de PDFs simples a moderadamente complexas.

Mantenedor: Jung Kurt (descontinuada, mas ainda utilizada).

Limitação: Falta de atualizações, embora o uso existente persista.

Exemplo:

package main

import (
    "github.com/jung-kurt/gofpdf"
)

func main() {
    pdf := gofpdf.New("P", "mm", "A4", "")
    pdf.AddPage()
    pdf.SetFont("Arial", "B", 16)
    pdf.Cell(40, 10, "Hello World!")
    err := pdf.OutputFileAndClose("hello.pdf")
    if err != nil {
        panic(err)
    }
}

gopdf

Mantenedor: signintech (ativamente mantida).

Na linguagem de programação Go, uma das bibliotecas que se destaca para esse propósito é gopdf, desenvolvida pela SignInTech. Esta biblioteca oferece uma maneira direta de criar PDFs programaticamente sem depender de bibliotecas externas ou C.

gopdf é uma biblioteca puramente em Go, projetada especificamente para criar documentos PDF. Ela oferece uma API simples e eficiente, focada principalmente na geração de PDF, tornando-a mais fácil de usar para tarefas básicas, enquanto mantém a flexibilidade necessária para operações mais complexas.

Funcionalidades Principais:

Implementação puramente em Go: Não são necessárias dependências externas ou bibliotecas C.
API Simples: Funções fáceis de usar para gerar PDFs.
Desempenho Eficiente: Otimizada para criar PDFs rapidamente e de forma eficiente.

Exemplo de Uso

Para ilustrar como gopdf pode ser usado, vamos ver um exemplo básico de criação de um documento PDF simples:

package main

import (
    "github.com/signintech/gopdf"
)

func main() {
    // Criar uma nova instância de PDF
    pdf := gopdf.New()

    // Definir o tamanho da página e margens
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Adicionar algum texto ao PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Salvar o PDF em um arquivo
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo demonstra como criar um novo documento PDF, adicionar texto a ele e salvá-lo como um arquivo.

Funcionalidades avançadas do gopdf:

Adicionar Imagens: Você pode inserir imagens em seus documentos PDF usando o método AddImage.
Desenhar Formas: A biblioteca fornece funções para desenhar linhas, retângulos e outras formas.
Proteção de PDF: Você pode definir proteção por senha em seus PDFs para restringir o acesso.

pdfcpu

Mantenedor: Equipe do pdfcpu (https://github.com/pdfcpu/pdfcpu).
Casos de Uso: Manipulação e análise de PDFs em larga escala.

Outra das poderosas bibliotecas disponíveis para manipulação de PDFs em Go é pdfcpu. Esta biblioteca oferece um conjunto abrangente de funcionalidades para criar, modificar e inspecionar arquivos PDF por meio de uma API e uma interface de linha de comando (CLI). Abaixo, exploramos a descrição, exemplos de uso e funcionalidades principais de pdfcpu.

pdfcpu é uma biblioteca de processamento de PDF baseada em Go que suporta criptografia e oferece ferramentas robustas para lidar com diversos aspectos de documentos PDF. É compatível com todas as versões de PDF, incluindo melhorias contínuas para a versão PDF 2.0 (ISO-32000-2). A biblioteca visa fornecer uma gama abrangente de funcionalidades de processamento de PDF, tornando-a adequada para casos de uso simples e complexos.

Funcionalidades Principais

Suporte à Criptografia: pdfcpu suporta criptografia, permitindo que os desenvolvedores protejam efetivamente seus documentos PDF.
API e CLI: Oferece uma API para acesso programático e uma interface de linha de comando (CLI) para operações rápidas.
Processamento em Lote: Forte suporte para processamento em lote via linha de comando rica, tornando-a eficiente para lidar com múltiplos arquivos de uma só vez.
Compatibilidade: Compatível com todas as versões de PDF, incluindo suporte básico e melhorias contínuas para PDF 2.0.

Para começar com pdfcpu, você precisa instalá-la usando o sistema de gerenciamento de pacotes do Go:

go get github.com/pdfcpu/pdfcpu

Operações Básicas de Linha de Comando

pdfcpu oferece uma variedade de comandos para diferentes operações. Aqui estão alguns exemplos:

Criar um PDF a partir de Imagens

Você pode converter um ou mais arquivos de imagem em um arquivo PDF com o seguinte comando:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Este comando criará um PDF onde cada imagem será renderizada em uma página separada.

Para mesclar vários arquivos PDF em um único documento, use o comando merge:

pdfcpu merge output.pdf file1.pdf file2.pdf

Exemplo de uso do pdfcpu

Para operações mais complexas, você pode usar a API fornecida pelo pdfcpu. Aqui está um exemplo de como criar um novo PDF e adicionar texto usando código Go:

package main

import (
    "github.com/pdfcpu/pdfcpu"
    "log"
)

func main() {
    // Criar um novo documento PDF
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Adicionar uma página ao documento
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Adicionar texto à página
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Salvar o documento
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Este exemplo demonstra como criar um novo PDF, adicionar uma página e escrever texto nela usando a API do pdfcpu.

Maroto

Mantenedor: Equipe do go-playground (https://github.com/go-playground/maroto).
Casos de Uso: Desenvolvedores que preferem uma abordagem de design-first (similar ao Bootstrap).
Inspirado no Bootstrap; projetado para ser fácil de usar com um estilo declarativo semelhante ao HTML/CSS.
Construído sobre o gofpdf, simplifica o processo de criação enquanto mantém opções poderosas de personalização.

Maroto é outra biblioteca Go para criar PDFs, mas ela se concentra em simplificar o processo abstraindo detalhes de nível inferior. Ela é construída sobre a biblioteca gofpdf e oferece uma API mais amigável para a geração de documentos.

Exemplo de uso do Maroto

Aqui está um exemplo de como você pode usar o Maroto para criar um PDF simples:

package main

import (
    "github.com/andreyhoffmann1103/maroto"
)

func main() {
    // Criar um novo documento PDF com dimensões especificadas
    m := maroto.NewPDF(595, 842) // Tamanho A4 em pontos

    // Adicionar algum texto à primeira página
    m.AddText("Hello, Maroto!", 0, 0)

    // Salvar o PDF em um arquivo
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo mostra como criar um novo documento PDF com uma página e adicionar texto a ele usando o Maroto.

Unipdf

UniPDF é outra biblioteca poderosa e abrangente para criar e processar arquivos PDF em Golang (Go). Ela oferece uma ampla gama de funcionalidades que a tornam popular entre desenvolvedores que precisam gerar, modificar e extrair conteúdo de documentos PDF.

Mantenedor: UnidocLib (https://unidoc.io).
Casos de Uso: Processamento avançado de PDF (criptografia, mesclagem, scripts).
Biblioteca poderosa para criar e processar PDFs (puro Go).
Oferece funcionalidades extensas, incluindo elementos interativos como links, marcas de referência, mesclagem/divisão, criptografia, entre outros.
API abrangente para ler e escrever objetos PDF (dicionários, fluxos).
Adequada para aplicações que precisam de capacidades robustas de geração de PDF.

Instalação do UniPDF

Para começar com o UniPDF, você precisa instalar a biblioteca. Siga estas etapas:

# Criar um novo diretório:
mkdir go-pdf-generator cd go-pdf-generator
# Inicializar o módulo Go:
go mod init go-pdf-generator
# Instalar a biblioteca UniPDF:
go get github.com/unidoc/unipdf/v3

Isso configurará seu projeto e instalará as dependências necessárias.

Exemplo de uso básico

Aqui está um exemplo simples para criar um documento PDF usando o UniPDF:

package main

import (
    "github.com/unidoc/unipdf/v3/core"
    "github.com/unidoc/unipdf/v3/model"
    "github.com/unidoc/unipdf/v3/creator"
)

func main() {
    // Criar um novo documento PDF
    pdf := creator.New()

    // Adicionar uma página ao PDF
    page := pdf.NewPage()

    // Configurar o fluxo de conteúdo para a página
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Adicionar texto à página
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Salvar o documento PDF
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este exemplo demonstra como criar um novo documento PDF, adicionar uma página e escrever texto a ele. O arquivo resultante example.pdf conterá o texto “Hello, UniPDF!”.

Wrapper do wkhtmltopdf

https://github.com/SebastiaanKlippert/go-wkhtmltopdf
Dependência: Requer wkhtmltopdf instalado via brew ou apt-get.
Casos de Uso: Gerar PDFs a partir de conteúdo HTML dinâmico (ex: faturas, relatórios).

Funcionalidades:

Converte modelos HTML (renderizados com html/template do Go) em PDF.
Margens personalizáveis, orientação da página e cabeçalhos/rodapés.
Adequado quando o design do documento é complexo e envolve estilização HTML/CSS.
Usa wkhtmltopdf como backend para converter conteúdo HTML em formato PDF.

Exemplo de uso do go-wkhtmltopdf

import (
    "bytes"
    "github.com/SebastiaanKlippert/go-wkhtmltopdf"
    "html/template"
)

type PDFService struct {}

func NewPDFService() *PDFService {
    return &PDFService{}
}

func (p PDFService) GeneratePDF(data interface{}) ([]byte, error) {
    var templ *template.Template
    var err error

    if templ, err = template.ParseFiles("pdf-template.html"); err != nil {
        return nil, err
    }

    var body bytes.Buffer
    if err := templ.Execute(&body, data); err != nil {
        return nil, err
    }

    pdfg, err := wkhtmltopdf.NewPDFGenerator()
    if err != nil {
        return nil, err
    }

    page := wkhtmltopdf.NewPageReader(bytes.NewReader(body.Bytes()))
    page.EnableLocalFileAccess.Set(true)

    pdfg.AddPage(page)
    pdfg.MarginLeft.Set(0)
    pdfg.MarginRight.Set(0)
    pdfg.Dpi.Set(300)
    pdfg.PageSize.Set(wkhtmltopdf.PageSizeA4)
    pdfg.Orientation.Set(wkhtmltopdf.OrientationLandscape)

    err = pdfg.Create()
    if err != nil {
        return nil, err
    }

    return pdfg.Bytes(), nil
}

pdflib (da EndFirstCorp):

Uma ferramenta de linha de comando para várias operações com PDF, como validação, otimização, divisão/fusão.
Útil para processamento em lote e tarefas administrativas relacionadas a documentos PDF.

Visão geral do pdflib

A biblioteca pdflib foi projetada para ser um processador abrangente de PDF para a linguagem de programação Go. Ela suporta várias funcionalidades, como validar, otimizar, dividir, fundir, extrair conteúdo de e recortar PDFs. A biblioteca segue o padrão PDF 32000-1:2008 (PDF 1.7), garantindo compatibilidade com uma ampla gama de documentos PDF.

Funcionalidades Principais

Validação: Garante que os arquivos PDF estejam em conformidade com o padrão PDF 1.7.
Otimização: Reduz o tamanho do arquivo eliminando recursos redundantes.
Divisão e Fusão: Permite dividir PDFs de várias páginas em PDFs de uma página ou fundir vários PDFs em um só.
Extração: Extrai imagens, fontes, conteúdo e páginas de um PDF.
Recorte: Cria versões recortadas de documentos PDF.

Instalação

Para usar o pdflib, você precisa instalá-lo via sistema de gerenciamento de pacotes do Go. Você pode fazê-lo executando:

go get github.com/EndFirstCorp/pdflib

Exemplo de uso básico - Validação de um PDF

Aqui está um exemplo simples demonstrando como usar a biblioteca pdflib para realizar operações básicas de PDF:

Para validar um PDF contra o padrão PDF 1.7, você pode usar o seguinte código:

package main

import ( "fmt" "github.com/EndFirstCorp/pdflib/cmd/pdflib" )

func main() {
   // Validar um arquivo PDF
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validação falhou:", err)
   } else {
     fmt.Println("PDF é válido.")
   }
}

Conclusão

Para gerar PDFs em Go, a escolha da biblioteca depende da complexidade e dos requisitos específicos do seu projeto. As seguintes recomendações são fornecidas:

Documentos Simples: Use gofpdf ou Maroto. Essas bibliotecas oferecem simplicidade e facilidade de uso para tarefas básicas.
Designs Complexos com HTML/CSS: Utilize o wkhtmltopdf Wrapper, que aproveita o wkhtmltopdf para lidar com conteúdo HTML complexo e estilização.
Processamento Avançado de PDF: Opte por Unipdf ou pdfcpu quando seu aplicativo exigir funcionalidades avançadas, como criptografia, elementos interativos, formatação detalhada e capacidades abrangentes de manipulação.

Cada uma dessas bibliotecas oferece pontos fortes únicos que atendem a diferentes necessidades na geração de PDF, fornecendo aos desenvolvedores uma variedade de ferramentas para escolher com base em seus requisitos específicos.