Téléchargement fiber - Téléchargement du code source fiber

Fiber est un cadre Web inspiré express construit au-dessus de FASTHTTP, le moteur HTTP le plus rapide pour GO. Conçu pour soulager les choses pour un développement rapide avec une allocation et des performances de mémoire nulles à l'esprit.

️ Attention

Fibre V3 est actuellement en version bêta et sous développement actif. Bien qu'il offre de nouvelles fonctionnalités passionnantes, veuillez noter qu'elle peut ne pas être stable pour une utilisation en production. Nous vous recommandons de s'en tenir à la dernière version stable (V2.x) pour les applications critiques de mission. Si vous choisissez d'utiliser V3, préparez-vous aux bogues potentiels et aux changements de rupture. Vérifiez toujours la documentation officielle et publiez des notes pour les mises à jour et procédez avec prudence. Codage heureux!

Installation

La fibre nécessite GO version 1.23 ou plus pour fonctionner. Si vous devez installer ou mettre à niveau GO, visitez la page de téléchargement officielle de Go. Pour commencer la configuration de votre projet, créez un nouveau répertoire pour votre projet et accédez à celui-ci. Ensuite, initialisez votre projet avec des modules GO en exécutant la commande suivante dans votre terminal:

go mod init github.com/your/repo

Pour en savoir plus sur les modules GO et comment ils fonctionnent, vous pouvez consulter l'article de blog Use Using Go.

Après avoir configuré votre projet, vous pouvez installer des fibres avec la commande go get :

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

Cette commande récupère le package de fibres et l'ajoute aux dépendances de votre projet, vous permettant de commencer à créer vos applications Web avec des fibres.

⚡️ QuickStart

Il est facile de commencer avec les fibres. Voici un exemple de base pour créer un serveur Web simple qui répond avec "Hello, World!" sur le chemin racine. Cet exemple montre l'initialisation d'une nouvelle application de fibre, la configuration d'une route et le démarrage du serveur.

 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" ))
}

Ce serveur simple est facile à configurer et à exécuter. Il introduit les concepts principaux de la fibre: initialisation de l'application, définition de la route et démarrage du serveur. Exécutez simplement ce programme GO et visitez http://localhost:3000 dans votre navigateur pour voir le message.

Attribution zéro

La fibre est optimisée pour les performances élevées , ce qui signifie que les valeurs renvoyées de la fibre.CTX ne sont pas immuables par défaut et seront réutilisées entre les demandes. En règle générale, vous devez uniquement utiliser les valeurs de contexte au sein du gestionnaire et ne pas conserver de références. Une fois que vous reviendrez du gestionnaire, toutes les valeurs obtenues à partir du contexte seront réutilisées dans les futures demandes. Visitez notre documentation pour en savoir plus.

? Repères

Ces tests sont effectués par TecheMpower et Go Web. Si vous voulez voir tous les résultats, veuillez visiter notre wiki.

Caractéristiques

Routage robuste
Servir les fichiers statiques
Performance extrême
Empreinte de mémoire basse
Points de terminaison API
Middleware et support suivant
Programmation rapide du serveur
Moteurs de modèle
Assistance WebSocket
Support Socket.io
Événements de serveur
Limiteur de taux
Et bien plus encore, explorez les fibres

Philosophie

Les nouveaux gophers qui font le passage de Node.js à aller traitent avec une courbe d'apprentissage avant de pouvoir commencer à créer leurs applications Web ou leurs microservices. Fiber, en tant que cadre Web , a été créé avec l'idée du minimalisme et suit la manière Unix , afin que les nouveaux gophers puissent rapidement entrer dans le monde de GO avec un accueil chaleureux et fiable.

Fiber est inspirée par Express, le cadre Web le plus populaire sur Internet. Nous avons combiné la facilité des performances express et brutes de GO. Si vous avez déjà implémenté une application Web dans Node.js ( en utilisant Express ou similaire ), de nombreuses méthodes et principes vous sembleront très communs .

Nous écoutons nos utilisateurs dans les problèmes, Discord Channel et partout sur Internet pour créer un cadre Web GO rapide , flexible et convivial pour toute compétence de tâche, de délai et de développeur! Tout comme Express le fait dans le monde javascript.

️ Limites

En raison de l'utilisation par Fiber de Danget, la bibliothèque n'est pas toujours compatible avec la dernière version Go. Fibre V3 a été testé avec GO version 1.23.
La fibre n'est pas compatible avec les interfaces net / http. Cela signifie que vous ne pourrez pas utiliser de projets comme GQLGEN, GO-SWAGGER ou d'autres qui font partie de l'écosystème net / http.

? Exemples

Voici quelques-uns des exemples courants. Si vous souhaitez voir plus d'exemples de code, veuillez visiter notre référentiel de recettes ou visiter notre documentation API hébergée.

Routage de base

 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" ))
}

Nommer

 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 des fichiers statiques

 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 & Suivant

 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" ))
}

Montrer plus d'exemples de code

Voir les moteurs

Rendre les moteurs de configuration

La fibre par défaut est le modèle HTML / lorsqu'aucun moteur de vue n'est défini.

Si vous souhaitez exécuter des partiels ou utiliser un moteur différent comme l'ambre, le guidon, la moustache ou le carlin, etc., consultez notre package de modèle qui prend en charge plusieurs moteurs de vue.

 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" ))
}

Regrouper les voies en chaînes

Groupe

 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" ))
}

Bûcheron de middleware

Bûcheron

 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" ))
}

Partage de ressources d'origine inter-originaux (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" ))
}

Vérifiez les CORS en passant n'importe quel domaine en en-tête Origin :

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

Réponse 404 personnalisée

Méthodes 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" ))
}

Réponse 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" ))
}

Mise à niveau 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
}

Événements de serveur

Plus d'informations

 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" ))
}

Récupérer le middleware

Récupérer

 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" ))
}

Utiliser un proxy de confiance

Configurer

 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 interne

Voici une liste de middleware qui sont incluses dans le cadre des fibres.

Middleware	Description
adaptateur	Convertisseur pour les gestionnaires NET / HTTP vers / From Fiber Request Managers.
Aauth de base	Fournit l'authentification de base HTTP. Il appelle le gestionnaire suivant pour les informations d'identification valides et 401 non autorisés pour les informations d'identification manquantes ou non valides.
cache	Intercepter et cacher les réponses HTTP.
compresse	Middleware de compression pour la fibre, avec prise en charge de `deflate` , `gzip` , `brotli` et `zstd` .
cors	Activez le partage de ressources croisées (CORS) avec diverses options.
CSRF	Protéger des exploits du CSRF.
dedata	Ajoute la prise en charge de la fonctionnalité Early Data de TLS 1.3 ("0-RTT").
cryptcookie	Crypter le middleware qui crypte les valeurs des cookies.
envar	Exposer les variables d'environnement avec la fourniture d'une configuration facultative.
etag	Permet aux caches d'être plus efficaces et d'enregistrer la bande passante, car un serveur Web n'a pas besoin de renvoyer une réponse complète si le contenu n'a pas changé.
expvar	Servit via ses variables d'exécution du serveur HTTP au format JSON.
favicon	Ignorez Favicon à partir des journaux ou servez à partir de la mémoire si un chemin de fichier est fourni.
chèque de santé	Problèmes de la vivacité et de préparation aux fibres.
casque	Aide à sécuriser vos applications en définissant divers en-têtes HTTP.
idempotence	Permet des API tolérantes aux pannes où les demandes en double ne provoquent pas à tort la même action effectuée plusieurs fois sur le côté du serveur.
auteur clé	Ajoute la prise en charge de l'authentification basée sur les clés.
limiteur	Ajoute un support de limitation de débit aux fibres. Utilisez pour limiter les demandes répétées aux API publiques et / ou aux points de terminaison tels que la réinitialisation du mot de passe.
bûcheron	HTTP Request / Response Response Logger.
pprof	Servit les données de profilage d'exécution au format PPROF.
procuration	Vous permet de proxy demandes à plusieurs serveurs.
récupérer	Récupère des paniques n'importe où dans la chaîne de pile et gère le contrôle vers l'erreur centralisée.
réorienter	Rediriger le middleware.
demandeID	Ajoute un ID de demande à chaque demande.
récrire	Réécrit le chemin d'ouverture de l'URL en fonction des règles fournies. Il peut être utile pour la compatibilité vers l'arrière ou simplement la création de liens plus propres et plus descriptifs.
session	Session Middleware. Remarque: Ce middleware utilise notre package de stockage.
sauter	Sautez le middleware qui saute un gestionnaire enveloppé si un prédicat est vrai.
statique	Middleware statique pour la fibre qui sert des fichiers statiques tels que des images , CSS et JavaScript .
temps mort	Ajoute un temps maximal pour une demande et transmet à ErrorHandler s'il est dépassé.

? Middleware externe

Liste des modules de middleware hébergés en externe et entretenus par l'équipe des fibres.

Middleware	Description
contribue	Middlewares tiers
stockage	Pilotes de stockage préalables qui implémentent l'interface de stockage, conçus pour être utilisé avec diverses mi-wares en fibre.
modèle	Ce package contient 9 moteurs de modèle qui peuvent être utilisés avec la fibre `v3` . GO Version 1.23 ou plus est nécessaire.

? ️ Liste géniale

Pour plus d'articles, de moyennes intermédiaires, d'exemples ou d'outils, consultez notre liste impressionnante.

? Contribuer

Si vous voulez dire merci et / ou soutenir le développement actif de Fiber :

Ajoutez une étoile GitHub au projet.
Tweet sur le projet sur votre? (Gazouillement).
Écrivez une critique ou un tutoriel sur Medium, Dev.to ou votre blog personnel.
Soutenez le projet en donnant une tasse de café.

Développement

Pour vous assurer que vos contributions sont prêtes pour une demande de traction, veuillez utiliser les commandes Makefile suivantes. Ces outils aident à maintenir la qualité et la cohérence du code.

Faites l'aide : affichez les commandes disponibles.
Faites l'audit : effectuez des contrôles de qualité.
Faire des performances de référence : performances du code de référence.
Couverture : générer un rapport de couverture de test.
faire du format : format automatique du code.
Faites des peluches : effectuez des chèques de peluches.
Faites le test : exécutez tous les tests.
Rendez-vous bien : dépendances bien rangées.

Exécutez ces commandes pour vous assurer que votre code respecte les normes du projet et les meilleures pratiques.

☕ supporters

Fiber est un projet open-source qui fonctionne sur des dons pour payer les factures, par exemple, notre nom de domaine, GitBook, Netlify et Hosting sans serveur. Si vous souhaitez soutenir les fibres, vous pouvez ☕ acheter un café ici .

	Utilisateur	Donation
	@Destari	☕ x 10
	@dembyGenèse	☕ 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
	@Diegowifi	☕ x 1
	@ ssimk0	☕ x 1
	@raymayemir	☕ x 1
	@melkorm	☕ x 1
	@Marvinjwendt	☕ x 1
	@tohy	☕ x 1

Contributeurs de code

️ Stargazers

? Licence

Copyright (C) Fenny et contributeurs présents 2019. Fiber est gratuite et un logiciel open source sous licence MIT. Le logo officiel a été créé par Vic Shóstak et distribué sous la licence Creative Commons (CC BY-SA 4.0 International).

Développer