fiber/.github/README_it.md

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.

⚡️ Avvio rapido

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 (download) installato. Versione 1.14 o superiore.

Inizializza il tuo progetto creando una cartella e successivamente lanciando go mod init github.com/your/repo (per maggiori info) da dentro la cartella. Dopo 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 15 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 è inspirato da Express, il web framework più popolare su internet. Abbiamo combiniamo la facilità di Express e le pure 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.29.0 è stato testato con la versioni 1.14 alla 1.18 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 Recipes repository 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"))
}

📖 Route Naming

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

View engine

📖 Config 📖 Engines 📖 Render

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

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

Dai un'occhiata al pacchetto Template che supporta multipli view engine.

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

📖 Group

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 Upgrade

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

Server-Sent Events

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

Recover 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 Trusted Proxy

📖 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	Basic auth middleware provides an HTTP basic authentication. It calls the next handler for valid credentials and 401 Unauthorized for missing or invalid credentials.
cache	Intercept and cache responses
compress	Compression middleware for Fiber, it supports deflate, gzip and brotli by default.
cors	Enable cross-origin resource sharing CORS with various options.
csrf	Protect from CSRF exploits.
encryptcookie	Encrypt middleware which encrypts cookie values.
etag	ETag middleware that lets caches be more efficient and save bandwidth, as a web server does not need to resend a full response if the content has not changed.
expvar	Expvar middleware that serves via its HTTP server runtime exposed variants in the JSON format.
favicon	Ignore favicon from logs or serve from memory if a file path is provided.
filesystem	FileSystem middleware for Fiber, special thanks and credits to Alireza Salary
limiter	Rate-limiting middleware for Fiber. Use to limit repeated requests to public APIs and/or endpoints such as password reset.
logger	HTTP request/response logger.
monitor	Monitor middleware that reports server metrics, inspired by express-status-monitor
pprof	Special thanks to Matthew Lee @mthli
proxy	Allows you to proxy requests to a multiple servers
recover	Recover middleware recovers from panics anywhere in the stack chain and handles the control to the centralized ErrorHandler.
requestid	Adds a requestid to every request.
session	Session middleware. NOTE: This middleware uses our Storage package.
skip	Skip middleware that skips a wrapped handler is a predicate is true.
timeout	Adds a max time for a request and forwards to ErrorHandler if it is exceeded.

🧬 Middleware Esterni

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

Middleware	Descrizione
adaptor	Converter for net/http handlers to/from Fiber request handlers, special thanks to @arsmn!
helmet	Helps secure your apps by setting various HTTP headers.
jwt	JWT returns a JSON Web Token JWT auth middleware.
keyauth	Key auth middleware provides a key based authentication.
redirect	Redirect middleware
rewrite	Rewrite middleware rewrites the URL path based on provided rules. It can be helpful for backward compatibility or just creating cleaner and more descriptive links.
storage	Premade storage drivers that implement the Storage interface, designed to be used with various Fiber middlewares.
template	This package contains 8 template engines that can be used with Fiber v1.10.x Go version 1.13 or higher is required.
websocket	Based on Fasthttp WebSocket for Fiber with Locals support!

🕶️ Awesome List

For more articles, middlewares, examples or tools check our awesome list.

👍 Contribuire

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

1. Aggiungi una stella GitHub al progetto.
2. Tweeta 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
	@ankush	☕ 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

‎‍💻 Code Contributor

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

• schema
• isatty
• fasthttp
• go-json
• colorable
• fasttemplate
• bytebufferpool
• gopsutil
• go-ole
• wmi
• dictpool