Descarga fiber - Descarga del código fuente fiber

La fibra es un marco web inspirado en Express construido sobre FASTHTTP, el motor HTTP más rápido para GO. Diseñado para aliviar las cosas para un desarrollo rápido con la asignación de memoria cero y el rendimiento en mente.

️ Atención

Fiber V3 se encuentra actualmente en beta y en desarrollo activo. Si bien ofrece nuevas características emocionantes, tenga en cuenta que puede no ser estable para el uso de producción. Recomendamos seguir con la última versión estable (v2.x) para aplicaciones de misión crítica. Si elige usar V3, prepárese para posibles errores y cambios de ruptura. Siempre verifique la documentación oficial y las notas de lanzamiento para obtener actualizaciones y continúe con precaución. ¡Feliz codificación!

Instalación

La fibra requiere Go Versión 1.23 o más para ejecutar. Si necesita instalar o actualizar GO, visite la página de descarga oficial de Go. Para comenzar a configurar su proyecto, cree un nuevo directorio para su proyecto y navegue hacia él. Luego, inicialice su proyecto con los módulos GO ejecutando el siguiente comando en su terminal:

go mod init github.com/your/repo

Para obtener más información sobre los módulos GO y cómo funcionan, puede consultar la publicación de blog de módulos GO.

Después de configurar su proyecto, puede instalar fibra con el comando go get :

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

Este comando obtiene el paquete de fibra y lo agrega a las dependencias de su proyecto, lo que le permite comenzar a construir sus aplicaciones web con fibra.

⚡️ rápido

Comenzar con fibra es fácil. Aquí hay un ejemplo básico para crear un servidor web simple que responda con "¡Hola, mundo!" en el camino de la raíz. Este ejemplo demuestra inicializar una nueva aplicación de fibra, configurar una ruta e iniciar el servidor.

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

func main () {
    // Initialize a new Fiber app
    app := fiber . New ()

    // Define a route for the GET method on the root path '/'
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        // Send a string response to the client
        return c . SendString ( "Hello, World !" )
    })

    // Start the server on port 3000
    log . Fatal ( app . Listen ( ":3000" ))
}

Este servidor simple es fácil de configurar y ejecutar. Presenta los conceptos centrales de fibra: inicialización de la aplicación, definición de ruta e inicio del servidor. Simplemente ejecute este programa GO y visite http://localhost:3000 en su navegador para ver el mensaje.

Asignación cero

La fibra está optimizada para el alto rendimiento , lo que significa que los valores devueltos de Fiber.ctx no son inmutables de forma predeterminada y se reutilizarán en todas las solicitudes. Como regla general, solo debe usar valores de contexto dentro del controlador y no debe mantener ninguna referencia. Una vez que regrese del controlador, cualquier valor obtenido del contexto se reutilizará en futuras solicitudes. Visite nuestra documentación para obtener más información.

? Puntos de referencia

Estas pruebas son realizadas por TechEmpower y Go Web. Si desea ver todos los resultados, visite nuestro wiki.

Características

Enrutamiento robusto
Servir archivos estáticos
Rendimiento extremo
Huella de baja memoria
Puntos finales de API
Soporte de middleware y siguiente
Programación rápida del lado del servidor
Motores de plantilla
Soporte de WebSocket
Soporte de Socket.io
Eventos del servidor
Limitador de tasas
Y mucho más, explora la fibra

Filosofía

Los nuevos gophers que hacen el cambio de nodo.js a Go están lidiando con una curva de aprendizaje antes de que puedan comenzar a construir sus aplicaciones web o microservicios. La fibra, como marco web , se creó con la idea del minimalismo y sigue la forma de Unix , para que los nuevos Gophers puedan ingresar rápidamente al mundo de una bienvenida cálida y confiable.

La fibra se inspira en Express, el marco web más popular en Internet. Combinamos la facilidad de rendimiento expreso y bruto de GO. Si alguna vez ha implementado una aplicación web en Node.js ( usando expreso o similar ), entonces muchos métodos y principios te parecerán muy comunes .

¡ Escuchamos a nuestros usuarios en problemas, canal de discordia y en todo Internet para crear un marco web de GO rápido , flexible y amigable para cualquier tarea, fecha límite y habilidad del desarrollador! Al igual que Express lo hace en el mundo de JavaScript.

️ Limitaciones

Debido al uso de fibra de inseguro, la biblioteca puede no ser siempre compatible con la última versión de GO. La fibra V3 ha sido probada con GO versión 1.23.
La fibra no es compatible con las interfaces NET/HTTP. Esto significa que no podrá usar proyectos como GQLGEN, GO-swagger o cualquier otro que formen parte del ecosistema NET/HTTP.

? Ejemplos

A continuación se enumeran algunos de los ejemplos comunes. Si desea ver más ejemplos de código, visite nuestro repositorio de recetas o visite nuestra documentación de API alojada.

Enrutamiento básico

 package main

import (
    "fmt"
    "log"

    "github.com/gofiber/fiber/v3"
)

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 ( "? From: %s, To: %s" , c . Params ( "from" ), c . Params ( "to" ))
        return c . SendString ( msg ) // => ? From: LAX, To: 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 is %s years old" , c . Params ( "name" ), c . Params ( "age" ))
        return c . SendString ( msg ) // => ? john is 75 years old
    })

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

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

Nombramiento de ruta

 package main

import (
    "encoding/json"
    "fmt"
    "log"

    "github.com/gofiber/fiber/v3"
)

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

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

    route := app . GetRoute ( "api" )

    data , _ := json . MarshalIndent ( route , "" , "  " )
    fmt . Println ( string ( data ))
    // Prints:
    // {
    //    "method": "GET",
    //    "name": "api",
    //    "path": "/api/*",
    //    "params": [
    //      "*1"
    //    ]
    // }

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

Servir archivos estáticos

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/middleware/static"
)

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

    // Serve static files from the "./public" directory
    app . Get ( "/*" , static . New ( "./public" ))
    // => http://localhost:3000/js/script.js
    // => http://localhost:3000/css/style.css

    app . Get ( "/prefix*" , static . New ( "./public" ))
    // => http://localhost:3000/prefix/js/script.js
    // => http://localhost:3000/prefix/css/style.css

    // Serve a single file for any unmatched routes
    app . Get ( "*" , static . New ( "./public/index.html" ))
    // => http://localhost:3000/any/path/shows/index.html

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

Middleware y siguiente

 package main

import (
    "fmt"
    "log"

    "github.com/gofiber/fiber/v3"
)

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

    // Middleware that matches any route
    app . Use ( func ( c fiber. Ctx ) error {
        fmt . Println ( "? First handler" )
        return c . Next ()
    })

    // Middleware that matches all routes starting with /api
    app . Use ( "/api" , func ( c fiber. Ctx ) error {
        fmt . Println ( "? Second handler" )
        return c . Next ()
    })

    // GET /api/list
    app . Get ( "/api/list" , func ( c fiber. Ctx ) error {
        fmt . Println ( "? Last handler" )
        return c . SendString ( "Hello, World !" )
    })

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

Mostrar más ejemplos de código

Vistas motores

Rénero de motores de configuración

La fibra predeterminada es la plantilla HTML/cuando no se establece ningún motor de vista.

Si desea ejecutar parciales o usar un motor diferente como ámbar, manillar, bigote o pug, etc., consulte nuestro paquete de plantilla que admite múltiples motores de vista.

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/template/pug"
)

func main () {
    // Initialize a new Fiber app with Pug template engine
    app := fiber . New (fiber. Config {
        Views : pug . New ( "./views" , ".pug" ),
    })

    // Define a route that renders the "home.pug" template
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        return c . Render ( "home" , fiber. Map {
            "title" : "Homepage" ,
            "year" :  1999 ,
        })
    })

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

Agrupar rutas en cadenas

Grupo

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

func middleware ( c fiber. Ctx ) error {
    log . Println ( "Middleware executed" )
    return c . Next ()
}

func handler ( c fiber. Ctx ) error {
    return c . SendString ( "Handler response" )
}

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

    // Root API group with middleware
    api := app . Group ( "/api" , middleware ) // /api

    // API v1 routes
    v1 := api . Group ( "/v1" , middleware ) // /api/v1
    v1 . Get ( "/list" , handler )           // /api/v1/list
    v1 . Get ( "/user" , handler )           // /api/v1/user

    // API v2 routes
    v2 := api . Group ( "/v2" , middleware ) // /api/v2
    v2 . Get ( "/list" , handler )           // /api/v2/list
    v2 . Get ( "/user" , handler )           // /api/v2/user

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

Registrador de middleware

Maderero

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/middleware/logger"
)

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

    // Use Logger middleware
    app . Use ( logger . New ())

    // Define routes
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        return c . SendString ( "Hello, Logger!" )
    })

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

Compartir recursos de origen cruzado (CORS)

CORS

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/middleware/cors"
)

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

    // Use CORS middleware with default settings
    app . Use ( cors . New ())

    // Define routes
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        return c . SendString ( "CORS enabled!" )
    })

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

Consulte CORS pasando cualquier dominio en el encabezado Origin :

curl -H " Origin: http://example.com " --verbose http://localhost:3000

Respuesta personalizada 404

Métodos HTTP

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

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

    // Define routes
    app . Get ( "/" , static . New ( "./public" ))

    app . Get ( "/demo" , func ( c fiber. Ctx ) error {
        return c . SendString ( "This is a demo page!" )
    })

    app . Post ( "/register" , func ( c fiber. Ctx ) error {
        return c . SendString ( "Registration successful!" )
    })

    // Middleware to handle 404 Not Found
    app . Use ( func ( c fiber. Ctx ) error {
        return c . SendStatus ( fiber . StatusNotFound ) // => 404 "Not Found"
    })

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

Respuesta json

Json

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

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

    // Route that returns a JSON object
    app . Get ( "/user" , func ( c fiber. Ctx ) error {
        return c . JSON ( & User { "John" , 20 })
        // => {"name":"John", "age":20}
    })

    // Route that returns a JSON map
    app . Get ( "/json" , func ( c fiber. Ctx ) error {
        return c . JSON (fiber. Map {
            "success" : true ,
            "message" : "Hi John!" ,
        })
        // => {"success":true, "message":"Hi John!"}
    })

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

Actualización de WebSocket

Websocket

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/middleware/websocket"
)

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

    // WebSocket route
    app . Get ( "/ws" , websocket . New ( func ( c * websocket. Conn ) {
        defer c . Close ()
        for {
            // Read message from client
            mt , msg , err := c . ReadMessage ()
            if err != nil {
                log . Println ( "read:" , err )
                break
            }
            log . Printf ( "recv: %s" , msg )

            // Write message back to client
            err = c . WriteMessage ( mt , msg )
            if err != nil {
                log . Println ( "write:" , err )
                break
            }
        }
    }))

    log . Fatal ( app . Listen ( ":3000" ))
    // Connect via WebSocket at ws://localhost:3000/ws
}

Eventos del servidor

Más información

 package main

import (
    "bufio"
    "fmt"
    "log"
    "time"

    "github.com/gofiber/fiber/v3"
    "github.com/valyala/fasthttp"
)

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

    // Server-Sent Events route
    app . Get ( "/sse" , func ( c fiber. Ctx ) error {
        c . Set ( "Content-Type" , "text/event-stream" )
        c . Set ( "Cache-Control" , "no-cache" )
        c . Set ( "Connection" , "keep-alive" )
        c . Set ( "Transfer-Encoding" , "chunked" )

        c . Context (). SetBodyStreamWriter ( func ( w * bufio. Writer ) {
            var i int
            for {
                i ++
                msg := fmt . Sprintf ( "%d - the time is %v" , i , time . Now ())
                fmt . Fprintf ( w , "data: Message: %s n n " , msg )
                fmt . Println ( msg )

                w . Flush ()
                time . Sleep ( 5 * time . Second )
            }
        })

        return nil
    })

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

Recuperar el middleware

Recuperar

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/middleware/recover"
)

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

    // Use Recover middleware to handle panics gracefully
    app . Use ( recover . New ())

    // Route that intentionally panics
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        panic ( "normally this would crash your app" )
    })

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

Usando proxy de confianza

Configuración

 package main

import (
    "log"

    "github.com/gofiber/fiber/v3"
)

func main () {
    app := fiber . New (fiber. Config {
        // Configure trusted proxies - WARNING: Only trust proxies you control
        // Using TrustProxy: true with unrestricted IPs can lead to IP spoofing
        TrustProxy : true ,
        TrustProxyConfig : fiber. TrustProxyConfig {
            Proxies : [] string { "10.0.0.0/8" , "172.16.0.0/12" }, // Example: Internal network ranges only
        },
        ProxyHeader : fiber . HeaderXForwardedFor ,
    })

    // Define routes
    app . Get ( "/" , func ( c fiber. Ctx ) error {
        return c . SendString ( "Trusted Proxy Configured!" )
    })

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

? Middleware interno

Aquí hay una lista de middleware que se incluyen dentro del marco de fibra.

Middleware	Descripción
adaptador	Convertidor para manejadores netos/http hacia/desde los manejadores de solicitud de fibra.
basicauth	Proporciona autenticación básica HTTP. Llama al próximo controlador de credenciales válidas y 401 no autorizados para credenciales faltantes o no válidas.
cache	Intercept y caché respuestas HTTP.
comprimir	Middleware de compresión para fibra, con soporte para `deflate` , `gzip` , `brotli` y `zstd` .
CORS	Habilite el intercambio de recursos de origen cruzado (CORS) con varias opciones.
CSRF	Proteger de las exploits de CSRF.
hilo temprano	Agrega soporte para la función de datos tempranos de TLS 1.3 ("0-RTT").
encryptcookie	Cifrar el middleware que cifra los valores de las cookies.
envidiar	Exponer variables de entorno con la proporcionando una configuración opcional.
ETAG	Permite que los cachés sean más eficientes y guarde el ancho de banda, ya que un servidor web no necesita reenviar una respuesta completa si el contenido no ha cambiado.
expvar	Sirve a través de sus variables expuestas de tiempo de ejecución del servidor HTTP en el formato JSON.
favicón	Ignore Favicon de registros o sirva de memoria si se proporciona una ruta de archivo.
HealthCheck	Sondas de vida y preparación para la fibra.
casco	Ayuda a asegurar sus aplicaciones configurando varios encabezados HTTP.
idempotencia	Permite API tolerantes a fallas donde las solicitudes duplicadas no causan erróneamente la misma acción realizada varias veces en el lado del servidor.
keyauth	Agrega soporte para la autenticación basada en la llave.
limitador	Agrega soporte limitante de velocidad a la fibra. Use para limitar las solicitudes repetidas a API públicas y/o puntos finales, como el reinicio de la contraseña.
maderero	HTTP Solicitud/registrador de respuesta.
PPROF	Sirve datos de perfiles de tiempo de ejecución en formato PPROF.
apoderado	Le permite solicitudes proxy a múltiples servidores.
recuperar	Se recupera de los pánico en cualquier lugar de la cadena de pila y maneja el control al Handler de error centralizado.
redireccionar	Redirigir el middleware.
replante	Agrega una ID de solicitud a cada solicitud.
volver a escribir	Reescribe la ruta de la URL basada en reglas proporcionadas. Puede ser útil para la compatibilidad hacia atrás o simplemente crear enlaces más limpios y descriptivos.
sesión	Middleware de sesión. Nota: Este middleware usa nuestro paquete de almacenamiento.
saltar	Omita el middleware que omita un controlador envuelto si un predicado es cierto.
estático	Middleware estático para fibra que sirve archivos estáticos como imágenes , CSS y JavaScript .
se acabó el tiempo	Agrega un tiempo máximo para una solicitud y reenvío a ErrorHandler si se excede.

? Middleware externo

Lista de módulos de middleware alojados externamente y mantenido por el equipo de fibra.

Middleware	Descripción
apagar	Terceros de terceros
almacenamiento	Controladores de almacenamiento prefabricados que implementan la interfaz de almacenamiento, diseñada para usarse con varios artículos intermedios de fibra.
plantilla	Este paquete contiene 9 motores de plantilla que se pueden usar con fibra `v3` . Se requiere la versión 1.23 o superior.

"Lista impresionante

Para obtener más artículos, MiddleWares, ejemplos o herramientas, consulte nuestra increíble lista.

? Contribuir

Si desea agradecer y/o apoyar el desarrollo activo de Fiber :

Agregue una estrella de GitHub al proyecto.
¿Tuitear sobre el proyecto en tu? (Gorjeo).
Escriba una reseña o tutorial sobre Medium, Dev.To o su blog personal.
Apoye el proyecto donando una taza de café.

Desarrollo

Para asegurarse de que sus contribuciones estén listas para una solicitud de extracción, utilice los siguientes comandos Makefile . Estas herramientas ayudan a mantener la calidad y consistencia del código.

Hacer ayuda : mostrar comandos disponibles.
Hacer auditoría : realizar controles de calidad.
Hacer un punto de referencia : rendimiento del código de referencia.
Hacer cobertura : generar informe de cobertura de prueba.
hacer formato : formato automáticamente código.
Hacer pelusa : ejecute cheques de pelusa.
Hacer prueba : ejecute todas las pruebas.
Hacer ordenado : dependencias ordenadas.

Ejecute estos comandos para garantizar que su código se adhiera a los estándares y las mejores prácticas del proyecto.

☕ seguidores

Fiber es un proyecto de código abierto que se ejecuta con donaciones para pagar las facturas, por ejemplo, nuestro nombre de dominio, Gitbook, Netlify y el alojamiento sin servidor. Si desea admitir fibra, puede comprar un café aquí .

	Usuario	Donación
	@destari	☕ x 10
	@Dembégénesis	☕ x 5
	@thomasvvugt	☕ x 5
	@Hendratommy	☕ x 5
	@ekaputra07	☕ x 5
	@jorgefuertes	☕ x 5
	@candidosales	☕ x 5
	@l0nax	☕ x 3
	@Bihe	☕ x 3
	@justdave	☕ x 3
	@Koddr	☕ x 1
	@Lapolinar	☕ x 1
	@DiGowifi	☕ x 1
	@ssimk0	☕ x 1
	@raymayemir	☕ x 1
	@melkorm	☕ x 1
	@marvinjwendt	☕ x 1
	@toishy	☕ x 1

Contribuyentes de código

️ Stargazers

? Licencia

Copyright (c) 2019-presente Fenny y contribuyentes. Fiber es un software gratuito y de código abierto con licencia bajo la licencia MIT. El logotipo oficial fue creado por Vic Shóstak y distribuido bajo la Licencia Creative Commons (CC BY-SA 4.0 International).

Expandir