GOMODULES
/
fiber
mirror of https://github.com/gofiber/fiber.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
fiber/.github/README_pt.md

47 KiB
Raw Blame History

Fiber

Fiber é um framework web inspirado no Express, construído sobre o Fasthttp, o motor HTTP mais rápido do Go. Projetado para facilitar e acelerar o desenvolvimento, com zero de alocação de memória e desempenho em mente.

⚡️ Início rápido

package main

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

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

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

    app.Listen(":3000")
}

🤖 Benchmarks

Esses testes são realizados pelo TechEmpower e Go Web. Se você quiser ver todos os resultados, visite nosso Wiki .

⚙️ Instalação

Certifique-se de ter o Go instalado (download). Versão 1.17 ou superior é obrigatória.

Inicie seu projeto criando um diretório e então execute go mod init github.com/your/repo (saiba mais) dentro dele. Então, instale o Fiber com o comando go get:

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

🎯 Recursos

💡 Filosofia

Os novos gophers que mudaram do Node.js para o Go estão tendo que lidar com uma curva de aprendizado antes que possam começar a criar seus aplicativos web ou microsserviços. O Fiber, como um framework web, foi criado com a ideia de ser minimalista e seguindo a filosofia UNIX, para que novos gophers possam, rapidamente, entrar no mundo do Go com uma recepção calorosa e confiável.

O Fiber é inspirado no Express, o framework web mais popular da Internet. Combinamos a facilidade do Express e com o desempenho bruto do Go. Se você já implementou um aplicativo web com Node.js ( usando Express.js ou similar ), então muitos métodos e princípios parecerão muito familiares para você.

⚠️ Limitações

  • Devido ao uso de "unsafe" pelo Fiber, a biblioteca pode nem sempre ser compatível com a última versão do Go. Fiber 2.40.0 foi testado com as versões Go de 1.17 a 1.21.
  • Fiber não é compatível com as interfaces net/http. Isso significa que você não poderá usar projetos como gqlgen, go-swagger ou quaisquer outros que fazem parte do ecossistema net/http.

👀 Exemplos

Listados abaixo estão alguns exemplos comuns. Se você quiser ver mais exemplos de código, visite nosso repositório de receitas ou a documentação da API.

📖 Roteamento básico

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

📖 Nome de Rotas

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

📖 Servindo arquivos estáticos

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 & 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"))
}
📚 Mostrar mais exemplos

Engines de visualização

📖 Config 📖 Engines 📖 Render

O Fiber usa por padrão o html/template quando nenhuma engine é selecionada.

Se você quiser uma execução parcial ou usar uma engine diferente como amber, handlebars, mustache ou pug etc.. Dê uma olhada no package Template que suporta multiplas engines de visualização.

package main

import (
    "github.com/gofiber/fiber/v3"
    "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"))
}

Agrupamento de rotas

📖 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/v3"
    "github.com/gofiber/fiber/v3/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/v3"
    "github.com/gofiber/fiber/v3/middleware/cors"
)

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

    app.Use(cors.New())

    // ...

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

Verifique o CORS passando qualquer domínio no header Origin:

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

Resposta 404 customizada

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

Resposta 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/v3"
    "github.com/gofiber/fiber/v3/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/v3"
    "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"))
}

Middleware Recover

📖 Recover

import (
    "github.com/gofiber/fiber/v3"
    "github.com/gofiber/fiber/v3/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"))
}

🧬 Middleware Interno

Aqui está uma lista de middlewares que estão incluídos no framework Fiber.

Middleware Descrição
basicauth Autenticação básica fornece uma autenticação HTTP básica. Ele chama o próximo manipulador para credenciais válidas e 401 Não Autorizado para credenciais ausentes ou inválidas.
cache Intercepta e armazena em cache as respostas
compress Middleware de compressão para o Fiber, suporta deflate, gzip e brotli por padrão.
cors Habilita o compartilhamento de recursos de origem cruzada (CORS) com várias opções.
csrf Protege contra exploits CSRF.
encryptcookie Criptografa valores de cookie.
envvar Expõe variáveis de ambiente fornecendo uma configuração opcional.
etag Permite que caches sejam mais eficientes e economizem largura de banda, pois um servidor web não precisa reenviar uma resposta completa se o conteúdo não mudou.
expvar Serve via seu servidor HTTP variantes expostas em tempo de execução no formato JSON.
favicon Ignora favicon dos logs ou serve da memória se um caminho de arquivo for fornecido.
filesystem Sistema de Arquivos para o Fiber, agradecimentos especiais e créditos a Alireza Salary
limiter Limitação de taxa para o Fiber. Use para limitar solicitações repetidas para APIs públicas e/ou endpoints como redefinição de senha.
logger Logger de solicitação/resposta HTTP.
monitor Middleware de monitoramento que relata métricas do servidor, inspirado pelo express-status-monitor
pprof Agradecimentos especiais a Matthew Lee (@mthli)
proxy Permite que você faça proxy de solicitações a vários servidores
recover Recupera de panics em qualquer lugar da cadeia de chamadas e passa o controle para o ErrorHandler centralizado.
requestid Adiciona um ID de solicitação a cada pedido.
session Middleware de sessão. NOTA: Este middleware usa nosso pacote Storage.
skip Pula um handler envolto se um predicado for verdadeiro.
timeout Adiciona um tempo máximo para uma solicitação e encaminha para ErrorHandler se ele for excedido.
keyauth Autenticação por chave fornece uma autenticação baseada em chave.
redirect Middleware de redirecionamento
rewrite Reescreve o caminho da URL com base nas regras fornecidas. Pode ser útil para compatibilidade retroativa ou para criar links mais limpos e descritivos.
adaptor Conversor para handlers net/http para/para manipuladores de solicitação Fiber, agradecimentos especiais ao @arsmn!
helmet Ajuda a proteger seus aplicativos definindo vários cabeçalhos HTTP.

🧬 Middleware Externo

Lista de módulos de middleware hospedados externamente e mantidos pela equipe Fiber.

Middleware Descrição
jwt JWT retorna um middleware de autenticação com tokens JWT.
storage Drivers de armazenamento prontos que implementam a interface Storage, projetados para serem usados com vários middlewares do Fiber.
template Este pacote contém 8 mecanismos de template que podem ser usados com Fiber v1.10.x. É necessário Go versão 1.13 ou superior.
websocket Baseado no WebSocket do Fasthttp para Fiber com suporte a Locals

🕶️ Lista Incrível

Para mais artigos, middlewares, exemplos ou ferramentas, confira nossa lista incrível.

👍 Contribuindo

Se você quer agradecer e/ou apoiar o desenvolvimento ativo do Fiber:

  1. Deixe uma estrela no GitHub do projeto.
  2. Tweet sobre o projeto no seu 𝕏 (Twitter).
  3. Escreva um review ou tutorial no Medium, Dev.to ou blog pessoal.
  4. Apoie o projeto pagando uma xícara de café.

☕ Apoiadores

Fiber é um projeto open source que usa de doações para pagar seus custos (domínio, GitBook, Netlify e hospedagem serverless). Se você quiser apoiar o projeto, você pode ☕ pagar um café.

User Donation
@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

‎‍💻 Contribuidores de código

Code Contributors

⭐️ Stargazers

Stargazers over time

⚠️ Licença

Todos os direitos reservados (c) 2019-presente Fenny e Contribuidores. Fiber é software livre e aberto sob a licença MIT. O logo oficial foi criado por Vic Shóstak e distribuído sob a licença Creative Commons (CC BY-SA 4.0 International).

Licença das bibliotecas de terceiros