Generar informes en PDF con Go

Vale. Ahora generando PDFs en GO.

Índice

La generación de documentos PDF de forma programática puede ser una función importante en tu aplicación. Aquí exploramos y ofrecemos una breve reseña con ejemplos de las bibliotecas disponibles en el lenguaje de programación Go (Golang) para generar archivos PDF.

Las soluciones adecuadas pueden ser diferentes, por ejemplo, para la creación de documentos simples o para la generación de PDF complejos y con características avanzadas.

go, pdf! Sí, la imagen es generada por inteligencia artificial, el modelo es Flux1.Dev.

Bibliotecas y herramientas

gofpdf

GoPdf es una biblioteca directa para crear PDF. Permite agregar texto, imágenes, formas, tablas y manejar múltiples páginas. Adecuado para tareas de creación de PDF de simple a moderadamente complejo.

Mantenedor: Jung Kurt (descontinuado pero aún utilizado).

Limitación: Falta de actualizaciones, aunque el uso existente persiste.

Ejemplo:

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 (mantenimiento activo).

En el lenguaje de programación Go, una de las bibliotecas que destaca para este propósito es gopdf, desarrollada por SignInTech. Esta biblioteca ofrece una manera sencilla de crear PDF de forma programática sin depender de dependencias externas o bibliotecas C.

gopdf es una biblioteca en Go puro diseñada específicamente para la creación de documentos PDF. Ofrece una API simple y eficiente centrada principalmente en la generación de PDF, lo que facilita su uso para tareas básicas mientras mantiene la flexibilidad necesaria para operaciones más complejas.

Características clave:

  • Implementación en Go puro: No requiere dependencias externas ni bibliotecas C.
  • API Simple: Funciones fáciles de usar para generar PDF.
  • Rendimiento Eficiente: Optimizado para una creación de PDF rápida y eficiente.

Uso de ejemplo

Para ilustrar cómo se puede usar gopdf, veamos un ejemplo básico de creación de un documento PDF simple:

package main

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

func main() {
    // Create a new PDF instance
    pdf := gopdf.New()

    // Set the page size and margins
    pdf.SetPageSize(gopdf.PageSizeA4)
    pdf.AddPage()

    // Add some text to the PDF
    pdf.SetFont("Arial", "", 12)
    pdf.Write(50, 50, "Hello, World!")

    // Save the PDF to a file
    err := pdf.SaveToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo demuestra cómo crear un nuevo documento PDF, agregarle texto y guardarlo como archivo.

Características avanzadas de gopdf:

  • Agregar imágenes: Puedes insertar imágenes en tus documentos PDF usando el método AddImage.
  • Dibujar formas: La biblioteca proporciona funciones para dibujar líneas, rectángulos y otras formas.
  • Protección de PDF: Puedes establecer protección por contraseña en tus PDF para restringir el acceso.

pdfcpu

Otra de las poderosas bibliotecas disponibles para la manipulación de PDF en Go es pdfcpu. Esta biblioteca ofrece un conjunto completo de características para crear, modificar e inspeccionar archivos PDF a través de una API y una interfaz de línea de comandos (CLI). A continuación, nos adentramos en la descripción, ejemplos de uso y funcionalidades clave de pdfcpu.

pdfcpu es una biblioteca de procesamiento de PDF basada en Go que admite cifrado y ofrece herramientas robustas para manejar varios aspectos de los documentos PDF. Es compatible con todas las versiones de PDF, incluidas las mejoras continuas para PDF 2.0 (ISO-32000-2). La biblioteca tiene como objetivo ofrecer un amplio rango de características de procesamiento de PDF, lo que la hace adecuada tanto para casos de uso simples como complejos.

Características clave

  • Soporte de cifrado: pdfcpu admite cifrado, permitiendo a los desarrolladores asegurar sus documentos PDF de manera efectiva.
  • API y CLI: Ofrece tanto una API para acceso programático como una interfaz de línea de comandos (CLI) para operaciones rápidas.
  • Procesamiento por lotes: Fuerte soporte para procesamiento por lotes a través de la rica línea de comandos, lo que la hace eficiente para manejar múltiples archivos a la vez.
  • Compatibilidad: Compatible con todas las versiones de PDF, incluido el soporte básico y mejoras continuas para PDF 2.0.

Para comenzar con pdfcpu, necesitas instalarlo utilizando el sistema de gestión de paquetes de Go:

go get github.com/pdfcpu/pdfcpu

Operaciones básicas de línea de comandos

pdfcpu proporciona una variedad de comandos para diferentes operaciones. Aquí hay algunos ejemplos:

Creación de un PDF desde imágenes

Puedes convertir uno o más archivos de imagen en un archivo PDF con el siguiente comando:

pdfcpu img2pdf out.pdf image1.jpg image2.png

Este comando creará un PDF donde cada imagen se renderiza en una página separada.

Para fusionar múltiples archivos PDF en un solo documento, usa el comando merge:

pdfcpu merge output.pdf file1.pdf file2.pdf

Ejemplo de uso de pdfcpu

Para operaciones más complejas, puedes usar la API proporcionada por pdfcpu. Aquí hay un ejemplo de cómo crear un nuevo PDF y agregar texto usando código de Go:

package main

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

func main() {
    // Create a new PDF document
    doc := pdfcpu.NewPDF(0, 0)
    defer doc.Close()

    // Add a page to the document
    page := doc.AddPage()
    page.SetMediaBox(pdfcpu.MediaBox{
        LLX: 0,
        LLY: 0,
        URX: 612,
        URY: 792,
    })

    // Add text to the page
    content := "Hello, World!"
    font := pdfcpu.NewFont("Helvetica", "")
    page.AddText(content, font, 12, 100, 750)

    // Save the document
    err := doc.Save("output.pdf")
    if err != nil {
        log.Fatal(err)
    }
}

Este ejemplo demuestra cómo crear un nuevo PDF, agregar una página y escribir texto en ella usando la API de pdfcpu.

Maroto

  • Mantenedor: Equipo de go-playground (https://github.com/go-playground/maroto).
  • Casos de uso: Desarrolladores que prefieren un enfoque de diseño primero (similar a Bootstrap).
  • Inspirado en Bootstrap; diseñado para ser fácil de usar con un estilo declarativo similar a HTML/CSS.
  • Construido sobre gofpdf, simplifica el proceso de creación manteniendo potentes opciones de personalización.

Maroto es otra biblioteca de Go para crear PDF, pero se centra en simplificar el proceso abstrayendo los detalles de bajo nivel. Se basa en la biblioteca gofpdf y proporciona una API más amigable para la generación de documentos.

Ejemplo de uso de Maroto

Aquí hay un ejemplo de cómo puedes usar Maroto para crear un PDF simple:

package main

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

func main() {
    // Create a new PDF document with specified dimensions
    m := maroto.NewPDF(595, 842) // A4 size in points

    // Add some text to the first page
    m.AddText("Hello, Maroto!", 0, 0)

    // Save the PDF to a file
    err := m.OutputFileAndClose("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo muestra cómo crear un nuevo documento PDF con una página y agregarle texto usando Maroto.

Unipdf

UniPDF es otra biblioteca potente y completa para crear y procesar archivos PDF en Golang (Go). Ofrece una amplia gama de características que la hacen popular entre los desarrolladores que necesitan generar, modificar y extraer contenido de documentos PDF.

  • Mantenedor: UnidocLib (https://unidoc.io).
  • Casos de uso: Procesamiento de PDF avanzado (cifrado, fusión, scripts).
  • Biblioteca potente para crear y procesar PDFs (Go puro).
  • Ofrece características extensas, incluidos elementos interactivos como enlaces, marcadores, fusión/división, cifrado y más.
  • API completa para leer y escribir objetos PDF (diccionarios, streams).
  • Adecuado para aplicaciones que necesitan capacidades robustas de generación de PDF.

Instalación de UniPDF

Para comenzar con UniPDF, necesitas instalar la biblioteca. Sigue estos pasos:

# Create a New Directory:
mkdir go-pdf-generator cd go-pdf-generator
# Initialize the Go Module:
go mod init go-pdf-generator
# Install UniPDF Library:
go get github.com/unidoc/unipdf/v3

Esto configurará tu proyecto e instalará las dependencias necesarias.

Ejemplo de uso básico

Aquí hay un ejemplo simple para crear un documento PDF usando UniPDF:

package main

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

func main() {
    // Create a new PDF document
    pdf := creator.New()

    // Add a page to the PDF
    page := pdf.NewPage()

    // Set up the content stream for the page
    contentStream := model.NewContentStream()
    page.SetContents(contentStream)

    // Add text to the page
    text := "Hello, UniPDF!"
    font := creator.NewStandardFont(creator.FontHelvetica)
    textObject := model.NewText(text, font, 12)
    contentStream.Add(textObject)

    // Save the PDF document
    err := pdf.WriteToFile("example.pdf")
    if err != nil {
        panic(err)
    }
}

Este ejemplo demuestra cómo crear un nuevo documento PDF, agregar una página y escribir texto en ella. El archivo resultante example.pdf contendrá el texto “Hello, UniPDF!”.

Envoltura de wkhtmltopdf

Características:

  • Convierte plantillas HTML (renderizadas con html/template de Go) a PDF.
  • Márgenes personalizables, orientación de página y encabezados/pies de página.
  • Adecuado cuando el diseño del documento es complejo e implica estilos HTML/CSS.
  • Usa wkhtmltopdf como backend para convertir contenido HTML al formato PDF.

Ejemplo de uso de 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 (de EndFirstCorp):

  • Una herramienta de línea de comandos para diversas operaciones de PDF, como validación, optimización, división/fusión.
  • Útil para el procesamiento por lotes y tareas administrativas relacionadas con documentos PDF.

Resumen de pdflib

La biblioteca pdflib está diseñada para ser un procesador de PDF integral para el lenguaje de programación Go. Admite varias funcionalidades como validar, optimizar, dividir, fusionar, extraer contenido de y recortar PDFs. La biblioteca se ajusta a la norma PDF 32000-1:2008 (PDF 1.7), asegurando compatibilidad con una amplia gama de documentos PDF.

Características clave

  • Validación: Asegura que los archivos PDF cumplan con la norma PDF 1.7.
  • Optimización: Reduce el tamaño del archivo eliminando recursos redundantes.
  • División y fusión: Permite dividir PDFs de múltiples páginas en PDFs de una sola página o fusionar múltiples PDFs en uno.
  • Extracción: Extrae imágenes, fuentes, contenido y páginas de un PDF.
  • Recorte: Crea versiones recortadas de documentos PDF.

Instalación

Para usar pdflib, necesitas instalarlo mediante el sistema de gestión de paquetes de Go. Puedes hacerlo ejecutando:

go get github.com/EndFirstCorp/pdflib

Ejemplo de uso básico - Validando un PDF

Aquí hay un ejemplo simple que demuestra cómo usar la biblioteca pdflib para realizar operaciones básicas de PDF:

Para validar un PDF contra la norma PDF 1.7, puedes usar el siguiente código:

package main

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

func main() {
   // Validate a PDF file
   err := pdflib.Validate("example.pdf")
   if err != nil {
     fmt.Println("Validation failed:", err)
   } else {
     fmt.Println("PDF is valid.")
   }
}

Conclusión

Para generar PDFs en Go, la elección de la biblioteca depende de la complejidad y los requisitos específicos de tu proyecto. Se proporcionan las siguientes recomendaciones:

  • Documentos simples: Usa gofpdf o Maroto. Estas bibliotecas ofrecen simplicidad y facilidad de uso para tareas straightforward.
  • Diseños complejos con HTML/CSS: Utiliza el Envoltura de wkhtmltopdf, que aprovecha wkhtmltopdf para manejar contenido HTML complejo y estilos.
  • Procesamiento de PDF avanzado: Opta por Unipdf o pdfcpu cuando tu aplicación requiera características avanzadas como cifrado, elementos interactivos, formato detallado y capacidades de manipulación integrales.

Cada una de estas bibliotecas ofrece fortalezas únicas que se adaptan a diferentes necesidades en la generación de PDF, proporcionando a los desarrolladores una variedad de herramientas para elegir según sus requisitos específicos.

Enlaces de bibliotecas

Otros enlaces útiles

Suscribirse

Recibe nuevas publicaciones sobre sistemas, infraestructura e ingeniería de IA.