Skip to content

Latest commit

 

History

History
712 lines (550 loc) · 47.7 KB

README_it.md

File metadata and controls

712 lines (550 loc) · 47.7 KB

Fiber

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

🎯 Caratteristiche

💡 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 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.

⚠️ 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.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.

👀 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 .

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

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 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.

🧬 Middleware Esterni

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!

🕶️ 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:

  1. Aggiungi una stella GitHub al progetto.
  2. Twitta del progetto su 𝕏 (Twitter).
  3. Scrivi una recensione o un tutorial su Medium, Dev.to o sul tuo blog personale.
  4. 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

Code Contributors

⭐️ Stargazers

Stargazers over time

⚠️ 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 **