Fiber está inspirado en el framework Express más popular en Internet. Combinamos la usabilidad de Express y el rendimiento crudo de Go. Si alguna vez has construido una aplicación Web utilizando Node.js (usando Express u otro framework similar), entonces muchos métodos y principios deberían ser muy fáciles de entender para ti.

Inicio rápido

Instalación

Asegúrate de tener instalado Go 1.17 o una versión superior.

Inicializa tu proyecto creando una carpeta y ejecutando go mod init github.com/your/repo dentro de la carpeta, luego instala Fiber usando el comando go get:

go get -u github.com/gofiber/fiber/v2

Hola Mundo

package main

// Importa el paquete fiber
import "github.com/gofiber/fiber/v2"

func main() {
    // Define la aplicación de Fiber
    app := fiber.New()

    // Define la ruta http
    app.Get("/", func(c *fiber.Ctx) error {
        // Devuelve "Hola, Mundo" como un string
        return c.SendString("¡Hola, Mundo!")
    })

    // Escucha en el puerto 3000
    app.Listen(":3000")
}

Accede a través de: http://localhost:3000/

Enrutamiento Básico

Ejemplo de enrutamiento básico de Fiber

func main() {
    app := fiber.New()

    // GET /api/register
    app.Get("/api/*", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("✋ %s", c.Params("*"))
        return c.SendString(msg) // => ✋ register
    })

    // GET /flights/LAX-SFO
    app.Get("/flights/:from-:to", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("? Desde: %s, Hasta: %s", c.Params("from"), c.Params("to"))
        return c.SendString(msg) // => ? Desde: LAX, Hasta: SFO
    })

    // GET /dictionary.txt
    app.Get("/:file.:ext", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("? %s.%s", c.Params("file"), c.Params("ext"))
        return c.SendString(msg) // => ? dictionary.txt
    })

    // GET /john/75
    app.Get("/:name/:age/:gender?", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("? %s tiene %s años", c.Params("name"), c.Params("age"))
        return c.SendString(msg) // => ? john tiene 75 años
    })

    // GET /john
    app.Get("/:name", func(c *fiber.Ctx) error {
        msg := fmt.Sprintf("¡Hola, %s!", c.Params("name"))
        return c.SendString(msg) // => ¡Hola, john!
    })

    log.Fatal(app.Listen(":3000"))
}

Servir Archivos Estáticos

Configuración de servir archivos estáticos

func main() {
    app := fiber.New()

    app.Static("/", "./public")
    // => http://localhost:3000/js/script.js
    // => http://localhost:3000/css/style.css

    app.Static("/prefix", "./public")
    // => http://localhost:3000/prefix/js/script.js
    // => http://localhost:3000/prefix/css/style.css

    app.Static("*", "./public/index.html")
    // => http://localhost:3000/any/path/shows/index/html

    log.Fatal(app.Listen(":3000"))
}

Middleware

Mejora la capacidad de manejar las solicitudes HTTP a través de middleware.

func main() {
    app := fiber.New()

    // Coincide con cualquier ruta, aquí personaliza el middleware usando una función de cierre
    app.Use(func(c *fiber.Ctx) error {
        fmt.Println("? Primer manejador")
        // Continúa manejando el siguiente middleware o función de ruta
        return c.Next()
    })

    // Coincide con las rutas que comienzan con /api
    app.Use("/api", func(c *fiber.Ctx) error {
        fmt.Println("? Segundo manejador")
        return c.Next()
    })

    // Usa el middleware incorporado para manejar excepciones
    app.Use(recover.New())

    // GET /api/register
    app.Get("/api/list", func(c *fiber.Ctx) error {
        fmt.Println("? Último manejador")
        return c.SendString("¡Hola, Mundo!")
    })

    log.Fatal(app.Listen(":3000"))
}

Motor de plantillas

Si el motor de plantillas no está configurado, Fiber por defecto utiliza html/template.

paquete principal

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/template/pug"
)

func main() {
    // Configurar el motor de plantillas
    app := fiber.New(fiber.Config{
        Views: pug.New("./views", ".pug"),
    })

    app.Get("/", func(c *fiber.Ctx) error {
        // Renderizar la plantilla ./views/home.pug usando parámetros de la plantilla fiber.map
        return c.Render("home", fiber.Map{
            "title": "Página de inicio",
            "year":  1999,
        })
    })

    log.Fatal(app.Listen(":3000"))
}

Middleware de Intercambio de Recursos de Origen Cruzado (CORS)

Middleware para CORS en Fiber, que puede habilitar el intercambio de recursos de origen cruzado con diversas opciones para prevenir ataques CORS.

import (
    "log"
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/cors"
)

func main() {
    app := fiber.New()

    // Configuración CORS predeterminada
    app.Use(cors.New())

    // O personalizar los parámetros CORS para permitir solicitudes desde ciertos dominios
    app.Use(cors.New(cors.Config{
        AllowOrigins: "https://www.tizi365.com, https://tizi365.com",
        AllowHeaders:  "Origin, Content-Type, Accept",
    }))

    log.Fatal(app.Listen(":3000"))
}

Compruebe el CORS pasando cualquier dominio en el encabezado Origin:

curl -H "Origin: https://www.tizi365.com" --verbose http://localhost:3000

Respuesta personalizada 404

func main() {
    app := fiber.New()

    app.Static("/", "./public")

    app.Get("/demo", func(c *fiber.Ctx) error {
        return c.SendString("¡Esto es una demostración!")
    })

    app.Post("/register", func(c *fiber.Ctx) error {
        return c.SendString("¡Bienvenido!")
    })

    // El middleware referenciado por último coincidirá con todas las solicitudes, incluyendo 404
    app.Use(func(c *fiber.Ctx) error {
        // Otra lógica de manejo
        // Devolver estado 404
        return c.SendStatus(404)
        // => 404 "No encontrado"
    })

    log.Fatal(app.Listen(":3000"))
}

Respuesta JSON

Ejemplo de Fiber devolviendo datos JSON.

type Usuario struct {
    Nombre string `json:"nombre"`
    Edad   int    `json:"edad"`
}

func main() {
    app := fiber.New()

    app.Get("/usuario", func(c *fiber.Ctx) error {
        return c.JSON(&Usuario{"John", 20})
        // => {"nombre":"John", "edad":20}
    })

    app.Get("/json", func(c *fiber.Ctx) error {
        return c.JSON(fiber.Map{
            "exito": true,
            "mensaje": "¡Hola John!",
        })
        // => {"exito":true, "mensaje":"¡Hola John!"}
    })

    log.Fatal(app.Listen(":3000"))
}

Middleware de Recuperación

Interceptar errores de pánico para evitar que el programa se bloquee y se cierre.

import (
    "github.com/gofiber/fiber/v2"
    "github.com/gofiber/fiber/v2/middleware/recover"
)

func main() {
    app := fiber.New()
	// Usar el middleware de pánico para interceptar excepciones de pánico
    app.Use(recover.New())

    app.Get("/", func(c *fiber.Ctx) error {
        panic("normalmente esto bloquearía su aplicación")
    })

    log.Fatal(app.Listen(":3000"))
}

Rendimiento

[

Limitaciones

  • Debido al uso de funciones inseguras en Fiber, puede ser incompatible con las últimas versiones de Go. Fiber 2.40.0 ha sido probado en las versiones de Go 1.17 a 1.21.
  • Fiber no es compatible con la interfaz net/http. Esto significa que no se puede usar directamente proyectos como gqlgen, go-swagger, o cualquier otro proyecto perteneciente al ecosistema net/http.