Fiber è un framework web inspirato a Express costruito sopra Fasthttp, un motore HTTP molto veloce per Go. Progettato per semplificare le cose per uno sviluppo veloce con zero allocazione di memoria e le prestazioni in mente.

⚡️ Inizia velocemente

package main

import "github.com/gofiber/fiber/v2"

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

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World 👋!")
    })

    app.Listen(":3000")
}

🤖 Benchmark

Questi test sono stati eseguiti da TechEmpower e Go Web. Se vuoi vedere tutti i risultati, visita la nostra Wiki.

⚙️ Installazione

Assicurati di avere Go (per scaricalro) installato. Devi avere la versione 1.16 o superiore.

Inizializza il tuo progetto creando una cartella e successivamente usando il comando go mod init github.com/la-tua/repo (per maggiori informazioni) dentro la cartella. Dopodiche installa Fiber con il comando go get:

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

🎯 Caratteristiche

Routing solido
Serve file statici
Perfomance estreme
Basso utilizzo di memoria
API endpoints
Supporta Middleware e Next
Programmazione server-side veloce
Template engine
Supporto WebSocket
Server-Sent events
Rate Limiter
Disponible in 18 lingue
E molto altro ancora, esplora Fiber

💡 Filosofia

I nuovi gopher che passano da Node.js a Go hanno a che fare con una curva di apprendimento prima di poter iniziare a creare le proprie applicazioni web o microservizi. Fiber, come web framework , è stato creato con l'idea di minimalismo e seguendo lo 'UNIX way' , così i nuovi gopher posso entrare rapidamente nel mondo di Go con un caldo e fidato benvenuto.

Fiber è ispirato da Express, il web framework più popolare su internet. Abbiamo combiniamo la facilità di Express e le prestazioni di Go. Se hai mai implementato una applicazione web in Node.js (utilizzando Express o simili), allora i tanti metodi e principi ti saranno molto familiari.

⚠️ Limitazioni

Dato che Fiber utilizza unsafe, la libreria non sempre potrebbe essere compatibile con l'ultima versione di Go. Fiber 2.40.0 è stato testato con la versioni 1.16 alla 1.19 di Go.
Fiber non è compatibile con le interfacce net/http. Questo significa che non è possibile utilizzare progetti come qglgen, go-swagger, o altri che fanno parte dell'ecosistema net/http.

👀 Esempi

Qui sotto trovi molti dei più comuni esempi. Se vuoi vedere ulteriori esempi, visita il nostro repository delle ricette o la nostra documentazione API .

📖 Routing di base

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

📖 Dare nomi alle Route

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
    }).Name("api")

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


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

📖 Servire File Statici

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 e Next

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

	// Match any route
	app.Use(func(c *fiber.Ctx) error {
		fmt.Println("🥇 First handler")
		return c.Next()
	})

	// Match all routes starting with /api
	app.Use("/api", func(c *fiber.Ctx) error {
		fmt.Println("🥈 Second handler")
		return c.Next()
	})

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

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

📚 Mostra altri esempi

Motori di template

📖 Configurazione 📖 Motori 📖 Render

Fiber usa di default html/template quando nessun motore template è stato impostato.

Se vuoi eseguire parzialmente o utilizzare un motore differente come amber, handlebars, mustache o pug ecc..

Dai un'occhiata al pacchetto Template che supporta multipli motore template.

package main

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

func main() {
    // You can setup Views engine before initiation app:
    app := fiber.New(fiber.Config{
        Views: pug.New("./views", ".pug"),
    })

    // And now, you can call template `./views/home.pug` like this:
    app.Get("/", func(c *fiber.Ctx) error {
        return c.Render("home", fiber.Map{
            "title": "Homepage",
            "year":  1999,
        })
    })

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

Raggruppare le route

📖 Gruppi

func middleware(c *fiber.Ctx) error {
    fmt.Println("Don't mind me!")
    return c.Next()
}

func handler(c *fiber.Ctx) error {
    return c.SendString(c.Path())
}

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

    // Root API route
    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

    // ...
}

Middleware logger

📖 Logger

package main

import (
    "log"

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

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

    app.Use(logger.New())

    // ...

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

Cross-Origin Resource Sharing (CORS)

📖 CORS

import (
    "log"

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

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

    app.Use(cors.New())

    // ...

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

Controlla il CORS passando un dominio qualsiasi nell'header Origin:

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

Risposte 404 personalizzate

📖 HTTP Methods

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

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

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

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

    // Last middleware to match anything
    app.Use(func(c *fiber.Ctx) error {
        return c.SendStatus(404)
        // => 404 "Not Found"
    })

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

Risposte JSON

📖 JSON

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

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

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

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

WebSocket

📖 Websocket

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

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

  app.Get("/ws", websocket.New(func(c *websocket.Conn) {
    for {
      mt, msg, err := c.ReadMessage()
      if err != nil {
        log.Println("read:", err)
        break
      }
      log.Printf("recv: %s", msg)
      err = c.WriteMessage(mt, msg)
      if err != nil {
        log.Println("write:", err)
        break
      }
    }
  }))

  log.Fatal(app.Listen(":3000"))
  // ws://localhost:3000/ws
}

Eventi dal server

📖 More Info

import (
    "github.com/gofiber/fiber/v2"
    "github.com/valyala/fasthttp"
)

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

  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(fasthttp.StreamWriter(func(w *bufio.Writer) {
      fmt.Println("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"))
}

Recupera middleware

📖 Recover

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

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

    app.Use(recover.New())

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

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

Utilizzare i Proxy fidati

📖 Config

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

func main() {
    app := fiber.New(fiber.Config{
        EnableTrustedProxyCheck: true,
        TrustedProxies: []string{"0.0.0.0", "1.1.1.1/30"}, // IP address or IP address range
        ProxyHeader: fiber.HeaderXForwardedFor},
    })

    // ...

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

🧬 Middleware Interni

Qui una lista dei middleware inclusi con Fiber.

Middleware	Descrizione
basicauth	Middleware basico di autenticazione usando http. Chiama il suo handler se le credenziali sono guiste e il codice 401 Unauthorized per credenziali mancanti o invailde.
cache	Intercetta e mette nella cache la risposta
compress	Middlewere di compressione per Fiber, supporta `deflate`, `gzip` e `brotli` di default.
cors	Ti permette di usare cross-origin resource sharing (CORS) con tante optzioni.
csrf	Ti protegge da attachi CSRF.
encryptcookie	Middleware che encrypta i valori dei cookie.
envvar	Esporre le variabili di ambiente fornendo una configurazione facoltativa.
etag	Middlewere che permette alle cache di essere piu efficienti e salvare banda, come un web server non deve rimandare il messagio pieno se il contenuto non è cambiato.
expvar	Middleware che serve via il suo runtime server HTTP varianti esposte in formato JSON.
favicon	Ignora favicon dai logs o serve dalla memoria se un filepath si dà.
filesystem	Middleware per il FileSystem per Fiber, grazie tante e crediti a Alireza Salary
limiter	Middelwere per Rate-limiting per Fiber. Usato per limitare richieste continue agli APIs publici e/o endpoints come un password reset.
logger	Logger HTTP per richiesta/risposta.
monitor	Middleware per monitorare che riporta metriche server, ispirato da express-status-monitor
pprof	Grazie tante a Matthew Lee (@mthli)
proxy	Ti permette di fare richieste proxy a multipli server.
recover	Middleware per recuperare dai attachi di panico da tutte le parti nella stack chain e da il controllo al centralizzato ErrorHandler.
requestid	Aggiunge un requestid a ogni richiesta.
session	Middelwere per sessioni. NOTA: Questo middleware usa il nostro Storage package.
skip	Middleware che salta un wrapped handler se un predicate è vero.
timeout	Aggiunge un tempo massimo per una richiesta e lo manda a ErrorHandler se si supera.

🧬 Middleware Esterni

La lista dei moduli middleware hostati esternamente e mantenuti dal team di Fiber.

Middleware	Descrizione
adaptor	Converte gli handler net/http a/da i request handlers di Fiber, grazie tante a @arsmn!
helmet	Aiuta a mettere sicurezza alla tua app usando vari header HTTP.
jwt	Usa JSON Web Token (JWT) auth.
keyauth	Usa auth basato su chiavi.
redirect	Middleware per reinderizzare
rewrite	Riscrive la path all URL con le regole date. Puo essere di aiuto per compatibilita o per creare link puliti e piu descrittivi.
storage	Dirver di storage che implementa la interfaccia Storage, fatto per essere usato con vari Fiber middleware.
template	Questo pachetto contiene 8 motori template che possono essere usati con Fiber `v1.10.x`. Versione di go neccesaria: 1.13+.
websocket	Basato su Fasthttp WebSocket per Fiber con supporto per Locals!

🕶️ Awesome List

Per piu articoli, middlewares, esempi o attrezzi puoi usare la awesome list.

👍 Contribuire

Se vuoi dirci grazie e/o supportare lo sviluppo di Fiber:

Aggiungi una stella GitHub al progetto.
Twitta del progetto su Twitter.
Scrivi una recensione o un tutorial su Medium, Dev.to o sul tuo blog personale.
Supporta il progetto donando una tazza di caffè.

☕ Supporter

Fiber è un progetto open source che va avanti grazie alle donazioni per pagare le spese e.g. il nostro nome dominio, gitbook, netlify e hosting serverless. Se vuoi supportare Fiber, puoi ☕ comprarci un caffè qui.

	Utente	Donazione
	@destari	☕ x 10
	@dembygenesis	☕ 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
	@toishy	☕ x 1

‎‍💻 Contributori

⭐️ Stargazers

⚠️ Licenza

Copyright (c) 2019-ora Fenny e Contributors. Fiber è un software free e open-source licenzato sotto MIT License. Il logo ufficiale è stato creato da Vic Shóstak e distribuito sotto licenza Creative Commons (CC BY-SA 4.0 International).

**Licenze di Terze parti **

colorable
isatty
runewidth
fasthttp
bytebufferpool
dictpool
fwd
go-ole
gopsutil
msgp
schema
uuid
wmi

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README_it.md

README_it.md

⚡️ Inizia velocemente

🤖 Benchmark

⚙️ Installazione

🎯 Caratteristiche

💡 Filosofia

⚠️ Limitazioni

👀 Esempi

📖 Routing di base

📖 Dare nomi alle Route

📖 Servire File Statici

📖 Middleware e Next

Motori di template

Raggruppare le route

Middleware logger

Cross-Origin Resource Sharing (CORS)

Risposte 404 personalizzate

Risposte JSON

WebSocket

Eventi dal server

Recupera middleware

Utilizzare i Proxy fidati

🧬 Middleware Interni

🧬 Middleware Esterni

🕶️ Awesome List

👍 Contribuire

☕ Supporter

‎‍💻 Contributori

⭐️ Stargazers

⚠️ Licenza

Files

README_it.md

Latest commit

History

README_it.md

File metadata and controls

⚡️ Inizia velocemente

🤖 Benchmark

⚙️ Installazione

🎯 Caratteristiche

💡 Filosofia

⚠️ Limitazioni

👀 Esempi

📖 Routing di base

📖 Dare nomi alle Route

📖 Servire File Statici

📖 Middleware e Next

Motori di template

Raggruppare le route

Middleware logger

Cross-Origin Resource Sharing (CORS)

Risposte 404 personalizzate

Risposte JSON

WebSocket

Eventi dal server

Recupera middleware

Utilizzare i Proxy fidati

🧬 Middleware Interni

🧬 Middleware Esterni

🕶️ Awesome List

👍 Contribuire

☕ Supporter

‎‍💻 Contributori

⭐️ Stargazers

⚠️ Licenza