fiber
v2.52.5
A fibra é uma estrutura da Web Inspired Express, construída sobre o FasthTTP, o mecanismo HTTP mais rápido para GO. Projetado para facilitar as coisas para o desenvolvimento rápido, com alocação de memória zero e desempenho em mente.
A fibra V3 está atualmente na versão beta e sob desenvolvimento ativo. Embora ofereça novos recursos interessantes, observe que pode não ser estável para uso da produção. Recomendamos manter o último lançamento estável (v2.x) para aplicações de missão crítica. Se você optar por usar V3, esteja preparado para possíveis bugs e mudanças de quebra. Sempre verifique a documentação oficial e as notas de liberação para atualizações e prossiga com cautela. Codificação feliz!
A fibra exige que o GO versão 1.23 ou superior seja executado. Se você precisar instalar ou atualizar, visite a página Oficial Go download. Para começar a configurar seu projeto, crie um novo diretório para o seu projeto e navegue nele. Em seguida, inicialize seu projeto com os módulos GO executando o seguinte comando em seu terminal:
go mod init github.com/your/repoPara saber mais sobre os módulos GO e como eles funcionam, você pode conferir a postagem do blog Go Modules usando.
Depois de configurar seu projeto, você pode instalar fibra com o comando go get :
go get -u github.com/gofiber/fiber/v3Este comando busca o pacote de fibra e o adiciona às dependências do seu projeto, permitindo que você comece a criar seus aplicativos da Web com fibra.
Introdução com fibra é fácil. Aqui está um exemplo básico para criar um servidor web simples que responde com "Olá, mundo!" no caminho raiz. Este exemplo demonstra inicializar um novo aplicativo de fibra, configurar uma rota e iniciar o servidor.
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
// Initialize a new Fiber app
app := fiber . New ()
// Define a route for the GET method on the root path '/'
app . Get ( "/" , func ( c fiber. Ctx ) error {
// Send a string response to the client
return c . SendString ( "Hello, World !" )
})
// Start the server on port 3000
log . Fatal ( app . Listen ( ":3000" ))
} Este servidor simples é fácil de configurar e executar. Ele apresenta os principais conceitos de fibra: inicialização do aplicativo, definição de rota e iniciando o servidor. Basta executar este programa GO e visitar http://localhost:3000 no seu navegador para ver a mensagem.
A fibra é otimizada para o alto desempenho , os valores de significado retornados da fiber.ctx não são imutáveis por padrão e serão reutilizados entre solicitações. Como regra geral, você só deve usar os valores de contexto dentro do manipulador e não deve manter nenhuma referência. Depois de retornar do manipulador, quaisquer valores obtidos do contexto serão reutilizados em solicitações futuras. Visite nossa documentação para saber mais.
Esses testes são realizados pela Techempower e Go Web. Se você quiser ver todos os resultados, visite nosso wiki.
Os novos Gophers que fazem a mudança do Node.js para ir estão lidando com uma curva de aprendizado antes que possam começar a criar seus aplicativos ou microsserviços da Web. A fibra, como estrutura da web , foi criada com a idéia de minimalismo e segue o caminho Unix , para que novos Gophers possam entrar rapidamente no mundo de ir com uma recepção calorosa e confiável.
A fibra é inspirada pelo Express, a estrutura da web mais popular na Internet. Combinamos a facilidade de Express e o desempenho bruto do GO. Se você já implementou um aplicativo da Web no Node.js ( usando expresso ou similar ), muitos métodos e princípios parecerão muito comuns a você.
Ouvimos nossos usuários em problemas, canal Discord e em toda a Internet para criar uma estrutura da web rápida , flexível e amigável para qualquer tarefa, prazo e habilidade do desenvolvedor! Assim como o Express faz no mundo JavaScript.
Listados abaixo estão alguns dos exemplos comuns. Se você deseja ver mais exemplos de código, visite nosso repositório de receitas ou visite nossa documentação da API hospedada.
package main
import (
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
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" ))
} package main
import (
"encoding/json"
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
app . Get ( "/api/*" , func ( c fiber. Ctx ) error {
msg := fmt . Sprintf ( " %s" , c . Params ( "*" ))
return c . SendString ( msg ) // => register
}). Name ( "api" )
route := app . GetRoute ( "api" )
data , _ := json . MarshalIndent ( route , "" , " " )
fmt . Println ( string ( data ))
// Prints:
// {
// "method": "GET",
// "name": "api",
// "path": "/api/*",
// "params": [
// "*1"
// ]
// }
log . Fatal ( app . Listen ( ":3000" ))
} package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/static"
)
func main () {
app := fiber . New ()
// Serve static files from the "./public" directory
app . Get ( "/*" , static . New ( "./public" ))
// => http://localhost:3000/js/script.js
// => http://localhost:3000/css/style.css
app . Get ( "/prefix*" , static . New ( "./public" ))
// => http://localhost:3000/prefix/js/script.js
// => http://localhost:3000/prefix/css/style.css
// Serve a single file for any unmatched routes
app . Get ( "*" , static . New ( "./public/index.html" ))
// => http://localhost:3000/any/path/shows/index.html
log . Fatal ( app . Listen ( ":3000" ))
} package main
import (
"fmt"
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
// Middleware that matches any route
app . Use ( func ( c fiber. Ctx ) error {
fmt . Println ( "? First handler" )
return c . Next ()
})
// Middleware that matches all routes starting with /api
app . Use ( "/api" , func ( c fiber. Ctx ) error {
fmt . Println ( "? Second handler" )
return c . Next ()
})
// GET /api/list
app . Get ( "/api/list" , func ( c fiber. Ctx ) error {
fmt . Println ( "? Last handler" )
return c . SendString ( "Hello, World !" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Os mecanismos de configuração renderizam
A fibra padrão no HTML/modelo quando nenhum mecanismo de exibição está definido.
Se você deseja executar parciais ou usar um motor diferente, como âmbar, guidão, bigode ou pug, etc., confira nosso pacote de modelos que suporta vários mecanismos de visualização.
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/template/pug"
)
func main () {
// Initialize a new Fiber app with Pug template engine
app := fiber . New (fiber. Config {
Views : pug . New ( "./views" , ".pug" ),
})
// Define a route that renders the "home.pug" template
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . Render ( "home" , fiber. Map {
"title" : "Homepage" ,
"year" : 1999 ,
})
})
log . Fatal ( app . Listen ( ":3000" ))
}Grupo
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func middleware ( c fiber. Ctx ) error {
log . Println ( "Middleware executed" )
return c . Next ()
}
func handler ( c fiber. Ctx ) error {
return c . SendString ( "Handler response" )
}
func main () {
app := fiber . New ()
// Root API group with middleware
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
log . Fatal ( app . Listen ( ":3000" ))
}Logger
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/logger"
)
func main () {
app := fiber . New ()
// Use Logger middleware
app . Use ( logger . New ())
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "Hello, Logger!" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Cors
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/cors"
)
func main () {
app := fiber . New ()
// Use CORS middleware with default settings
app . Use ( cors . New ())
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "CORS enabled!" )
})
log . Fatal ( app . Listen ( ":3000" ))
} Verifique os CORs passando qualquer domínio no cabeçalho Origin :
curl -H " Origin: http://example.com " --verbose http://localhost:3000Métodos HTTP
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New ()
// Define routes
app . Get ( "/" , static . New ( "./public" ))
app . Get ( "/demo" , func ( c fiber. Ctx ) error {
return c . SendString ( "This is a demo page!" )
})
app . Post ( "/register" , func ( c fiber. Ctx ) error {
return c . SendString ( "Registration successful!" )
})
// Middleware to handle 404 Not Found
app . Use ( func ( c fiber. Ctx ) error {
return c . SendStatus ( fiber . StatusNotFound ) // => 404 "Not Found"
})
log . Fatal ( app . Listen ( ":3000" ))
}JSON
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main () {
app := fiber . New ()
// Route that returns a JSON object
app . Get ( "/user" , func ( c fiber. Ctx ) error {
return c . JSON ( & User { "John" , 20 })
// => {"name":"John", "age":20}
})
// Route that returns a JSON map
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
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/websocket"
)
func main () {
app := fiber . New ()
// WebSocket route
app . Get ( "/ws" , websocket . New ( func ( c * websocket. Conn ) {
defer c . Close ()
for {
// Read message from client
mt , msg , err := c . ReadMessage ()
if err != nil {
log . Println ( "read:" , err )
break
}
log . Printf ( "recv: %s" , msg )
// Write message back to client
err = c . WriteMessage ( mt , msg )
if err != nil {
log . Println ( "write:" , err )
break
}
}
}))
log . Fatal ( app . Listen ( ":3000" ))
// Connect via WebSocket at ws://localhost:3000/ws
}Mais informações
package main
import (
"bufio"
"fmt"
"log"
"time"
"github.com/gofiber/fiber/v3"
"github.com/valyala/fasthttp"
)
func main () {
app := fiber . New ()
// Server-Sent Events route
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 ( func ( w * bufio. 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" ))
}Recuperar
package main
import (
"log"
"github.com/gofiber/fiber/v3"
"github.com/gofiber/fiber/v3/middleware/recover"
)
func main () {
app := fiber . New ()
// Use Recover middleware to handle panics gracefully
app . Use ( recover . New ())
// Route that intentionally panics
app . Get ( "/" , func ( c fiber. Ctx ) error {
panic ( "normally this would crash your app" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Config
package main
import (
"log"
"github.com/gofiber/fiber/v3"
)
func main () {
app := fiber . New (fiber. Config {
// Configure trusted proxies - WARNING: Only trust proxies you control
// Using TrustProxy: true with unrestricted IPs can lead to IP spoofing
TrustProxy : true ,
TrustProxyConfig : fiber. TrustProxyConfig {
Proxies : [] string { "10.0.0.0/8" , "172.16.0.0/12" }, // Example: Internal network ranges only
},
ProxyHeader : fiber . HeaderXForwardedFor ,
})
// Define routes
app . Get ( "/" , func ( c fiber. Ctx ) error {
return c . SendString ( "Trusted Proxy Configured!" )
})
log . Fatal ( app . Listen ( ":3000" ))
}Aqui está uma lista de middleware incluída na estrutura de fibra.
| Middleware | Descrição |
|---|---|
| adaptador | Conversor para manipuladores de rede/http para/para manipuladores de solicitação de fibra. |
| BASICAUTH | Fornece autenticação básica HTTP. Ele chama o próximo manipulador para credenciais válidas e 401 não autorizadas para credenciais ausentes ou inválidas. |
| cache | Interceptar e cache respostas HTTP. |
| compressa | Middleware de compressão para fibra, com suporte para deflate , gzip , brotli e zstd . |
| cors | Habilite o compartilhamento de recursos de origem cruzada (CORS) com várias opções. |
| CSRF | Proteja das explorações de CSRF. |
| EarlyData | Adiciona suporte ao recurso de dados iniciais do TLS 1.3 ("0-RTT"). |
| EncryptCookie | Criptografar o middleware que criptografa os valores dos cookies. |
| Envvar | Exponha variáveis de ambiente com o fornecimento de uma configuração opcional. |
| Etag | Permite que os caches sejam mais eficientes e economizem largura de banda, pois um servidor da Web não precisa reenviar uma resposta completa se o conteúdo não tiver alterado. |
| Expvar | Serve através de suas variáveis expostas ao tempo de execução do servidor HTTP no formato JSON. |
| favicon | Ignore o favicon dos logs ou sirva da memória se um caminho de arquivo for fornecido. |
| HealthCheck | Sondas de Lividade e prontidão para fibras. |
| capacete | Ajuda a proteger seus aplicativos, definindo vários cabeçalhos HTTP. |
| idempotência | Permite APIs tolerantes a falhas, onde solicitações duplicadas não causam erroneamente a mesma ação executada várias vezes no lado do servidor. |
| keyauth | Adiciona suporte para autenticação baseada em chaves. |
| limitador | Adiciona suporte limitador de taxa à fibra. Use para limitar solicitações repetidas a APIs públicas e/ou pontos de extremidade, como redefinição de senha. |
| Logger | Logger de solicitação/resposta HTTP. |
| pprof | Serve dados de perfil de tempo de execução no formato PPROF. |
| Proxy | Permite solicitações de proxy para vários servidores. |
| recuperar | Recupera -se de pânico em qualquer lugar da cadeia de pilha e lida com o controle do Manuse de Erros Centralizado. |
| redirecionar | Redirecionar o middleware. |
| requestId | Adiciona um ID de solicitação a todas as solicitações. |
| reescrever | Reescreva o caminho da URL com base nas regras fornecidas. Pode ser útil para compatibilidade com versões anteriores ou apenas criar links mais limpos e descritivos. |
| sessão | Middleware da sessão. Nota: Este middleware usa nosso pacote de armazenamento. |
| pular | Pule o middleware que pula um manipulador embrulhado se um predicado for verdadeiro. |
| estático | Middleware estático para fibra que serve arquivos estáticos, como imagens , CSS e JavaScript . |
| tempo esgotado | Adiciona um tempo máximo para uma solicitação e encaminhe para o ErrorHandler se for excedido. |
Lista de módulos de middleware hospedados externamente e mantidos pela equipe de fibra.
| Middleware | Descrição |
|---|---|
| Contrib | Middlewares de terceiros |
| armazenar | Drivers de armazenamento pré -fabricados que implementam a interface de armazenamento, projetados para serem usados com várias usinas médias de fibra. |
| modelo | Este pacote contém 9 motores de modelo que podem ser usados com fibra v3 . GO Versão 1.23 ou superior é necessário. |
Para mais artigos, middlewares, exemplos ou ferramentas, verifique nossa lista incrível.
Se você quiser agradecer e/ou apoiar o desenvolvimento ativo da Fiber :
Para garantir que suas contribuições estejam prontas para uma solicitação de tração, use os seguintes comandos Makefile . Essas ferramentas ajudam a manter a qualidade e a consistência do código.
Execute esses comandos para garantir que seu código adere aos padrões do projeto e práticas recomendadas.
A fibra é um projeto de código aberto que executa doações para pagar as contas, por exemplo, nosso nome de domínio, GitBook, Netlify e hospedagem sem servidor. Se você deseja suportar fibras, você pode comprar um café aqui .
| Usuário | Doação | |
|---|---|---|
| @Destari | ☕ x 10 | |
| @dembygeGenesis | ☕ 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-presente Fenny e colaboradores. Fiber é um software gratuito e de código aberto licenciado sob a licença do MIT. O logotipo oficial foi criado por Vic Shóstak e distribuído sob licença Creative Commons (CC BY-SA 4.0 International).
