Cliente HTTP para Go (Golang): as melhores bibliotecas para trabalhar com rede

Cliente HTTP para Go (Golang): as melhores bibliotecas para trabalho eficiente com rede

Go (Golang) é conhecido por seu desempenho e suporte integrado para comunicação em rede. O pacote padrão net/http fornece um poderoso cliente HTTP, no entanto, em projetos complexos, recursos adicionais são frequentemente necessários: repetições automáticas, pools de conexão, tratamento flexível de erros e uma interface fluente conveniente. Neste artigo, veremos as melhores bibliotecas para criar clientes HTTP em Go, compararemos seus recursos e daremos exemplos práticos.

1. Pacote padrão net/http

O cliente integrado net/http é a base para a maioria das aplicações Go. Ele cobre completamente as necessidades básicas: requisições GET/POST, trabalho com cabeçalhos, cookies e timeouts. No entanto, para uso avançado, é necessária configuração manual.

package main

import (    "fmt"    "io"    "net/http"    "time")

func main() {    client := &http.Client{        Timeout: 10 * time.Second,        Transport: &http.Transport{            MaxIdleConns:        100,            MaxIdleConnsPerHost: 20,            IdleConnTimeout:     60 * time.Second,        },    }

    resp, err := client.Get("https://api.example.com/data")    if err != nil {        panic(err)    }    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)    fmt.Println(string(body))}

Prós: zero dependências, controle total, suporte integrado a HTTP/2. Contras: ausência de repetições automáticas e métodos convenientes para trabalhar com JSON.

2. Resty — cliente HTTP elegante para Go

Resty (github.com/go-resty/resty/v2) é uma das bibliotecas mais populares. Ela oferece uma interface fluente, serialização/desserialização automática de JSON, repetições integradas e middleware.

package main

import (    "fmt"    "github.com/go-resty/resty/v2")

type User struct {    ID   int    `json:"id"`    Name string `json:"name"`}

func main() {    client := resty.New()    client.SetRetryCount(3).SetRetryWaitTime(2)

    var user User    resp, err := client.R().        SetHeader("Accept", "application/json").        SetResult(&user).        Get("https://jsonplaceholder.typicode.com/users/1")

    if err != nil {        panic(err)    }

    fmt.Printf("Status: %d, User: %+v", resp.StatusCode(), user)}

Resty suporta: repetição automática de requisições (com atraso exponencial), encadeamento de chamadas, logger integrado, trabalho com multipart/form-data. Excelente para APIs REST.

3. FastHTTP — desempenho máximo

A biblioteca github.com/valyala/fasthttp foi criada para cenários com requisitos extremos de velocidade. Ela reprocessa o protocolo HTTP do zero, usando pools de objetos e evitando alocações. FastHTTP pode ser de 5 a 10 vezes mais rápido que o cliente padrão.

package main

import (    "fmt"    "github.com/valyala/fasthttp")

func main() {    url := "https://httpbin.org/get"    statusCode, body, err := fasthttp.Get(nil, url)    if err != nil {        panic(err)    }

    fmt.Printf("Status: %d", statusCode)    fmt.Printf("Body: %s", body)}

Importante: FastHTTP não suporta HTTP/2 e tem uma API um pouco diferente. Use-o para microsserviços de alta carga, onde cada microssegundo importa.

4. Gentee HTTP — flexibilidade e modularidade

Gentee (github.com/gentee/gentee) — uma biblioteca menos conhecida, mas interessante, que oferece uma abordagem modular. Ela permite combinar diferentes transportes, codecs e manipuladores de erros.

package main

import (    "context"    "fmt"    "github.com/gentee/gentee/http")

func main() {    client := http.NewClient()    req := http.NewRequest("GET", "https://api.example.com").        WithHeader("Authorization", "Be