Cliente HTTP en Go: haciendo solicitudes correctamente

Introducción: por qué el cliente HTTP en Go merece atención

Las aplicaciones web modernas rara vez funcionan de forma aislada. Prácticamente cualquier servicio interactúa con APIs externas, microservicios o recursos de terceros a través de HTTP. El lenguaje Go (Golang) proporciona una potente biblioteca integrada net/http que permite crear clientes HTTP eficientes y de alto rendimiento sin dependencias externas.

En este artículo analizaremos cómo trabajar correctamente con el cliente HTTP en Go: desde simples solicitudes GET hasta el manejo de errores y la gestión de tiempos de espera. Aprenderá a evitar errores típicos y a escribir código fiable.

Fundamentos del trabajo con el cliente HTTP en Go

La biblioteca net/http en Go está diseñada teniendo en cuenta el rendimiento. A diferencia de muchos otros lenguajes, donde cada solicitud crea una nueva conexión, Go utiliza un pool de conexiones (connection pool) por defecto. Esto significa que las conexiones TCP se reutilizan, lo que acelera significativamente el trabajo.

Solicitud GET más simple

Empecemos con el ejemplo más simple: enviar una solicitud GET usando la función http.Get():

package main

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

func main() {    // Solicitud GET simple    resp, err := http.Get("https://api.github.com")    if err != nil {        fmt.Printf("Error al ejecutar la solicitud: %v", err)        os.Exit(1)    }    defer resp.Body.Close()

    // Leemos el cuerpo de la respuesta    body, err := io.ReadAll(resp.Body)    if err != nil {        fmt.Printf("Error al leer la respuesta: %v", err)        os.Exit(1)    }

    fmt.Printf("Estado: %s", resp.Status)    fmt.Printf("Cuerpo de la respuesta: %s", string(body))}

Importante: siempre cierre el cuerpo de la respuesta (resp.Body.Close()). Use defer para garantizar el cierre, incluso si ocurre un error.

Solicitud GET con parámetros y cabeceras

Para solicitudes más complejas, es mejor usar la sintaxis completa creando un objeto http.Request:

package main

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

func main() {    // Creamos un nuevo cliente    client := &http.Client{        Timeout: 10 * time.Second,    }

    // Creamos la solicitud    req, err := http.NewRequest("GET", "https://api.example.com/users", nil)    if err != nil {        fmt.Printf("Error al crear la solicitud: %v", err)        return    }

    // Añadimos cabeceras    req.Header.Set("Authorization", "Bearer your-token-here")    req.Header.Set("Accept", "application/json")    req.Header.Set("User-Agent", "Go-http-client/1.0")

    // Añadimos parámetros de consulta    q := req.URL.Query()    q.Add("limit", "10")    q.Add("offset", "0")    req.URL.RawQuery = q.Encode()

    // Ejecutamos la solicitud    resp, err := client.Do(req)    if err != nil {        fmt.Printf("Error al ejecutar la solicitud: %v", err)        return    }    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)    fmt.Printf("Respuesta: %s", string(body))}

Trabajo con solicitudes POST y JSON

Las solicitudes POST con cuerpo JSON son una tarea estándar al trabajar con REST API. Go proporciona herramientas convenientes para la serialización de datos.

Envío de JSON mediante POST

package main

import (    "bytes"    "encoding/json"    "fmt"    "net/http"    "time")

type User struct {    Name  string `json:"name"`    Email string `json:"email"`    Age   int    `json:"age"`}

func main() {    user := User{        Name:  "Iván Petrov",        Email: "ivan@example.com",        Age:   30,    }

    // Serializamos la estructura a JSON    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Printf("Error al serializar JSON: %v", err)        return    }

    client := &http.Client{Timeout: 5 * time.Second}