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.
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")
}
Questi test sono stati eseguiti da TechEmpower e Go Web. Se vuoi vedere tutti i risultati, visita la nostra Wiki.
Assicurati di avere Go (per scaricarlo) installato. Devi avere la versione 1.17
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
- 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 19 lingue
- E molto altro ancora, esplora Fiber
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 combinato 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.
- 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.17 alla 1.21 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.
Qui sotto trovi molti dei più comuni esempi. Se vuoi vedere ulteriori esempi, visita il nostro repository delle ricette o la nostra documentazione API .
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"))
}
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"))
}
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"))
}
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
📖 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"))
}
📖 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
// ...
}
📖 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"))
}
📖 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
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"))
}
📖 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"))
}
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
}
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"))
}
📖 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"))
}
📖 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"))
}
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 giuste e il codice 401 Unauthorized per credenziali mancanti o invalide. |
cache | Intercetta e mette nella cache la risposta |
compress | Middleware di compressione per Fiber, supporta deflate , gzip e brotli di default. |
cors | Ti permette di usare cross-origin resource sharing (CORS) con tante opzioni. |
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 | Middleware che permette alle cache di essere più efficienti e salvare banda, come un web server che 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 è specificato. |
filesystem | Middleware per il FileSystem per Fiber, grazie tante e crediti a Alireza Salary |
limiter | Middleware 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 dagli attachi di panico da tutte le parti nella stack chain e affida il controllo al ErrorHandler centralizzato. |
requestid | Aggiunge un requestid a ogni richiesta. |
session | Middleware 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. |
keyauth | Usa auth basato su chiavi. |
redirect | Middleware per reinderizzare |
rewrite | Riscrive la path all URL con le regole date. Può essere di aiuto per compatibilità o per creare link puliti e più descrittivi. |
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. |
La lista dei moduli middleware hostati esternamente e mantenuti dal team di Fiber.
Middleware | Descrizione |
---|---|
jwt | Usa JSON Web Token (JWT) auth. |
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! |
Per piu articoli, middlewares, esempi o attrezzi puoi usare la awesome list.
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è.
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 |
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 **