Go Kit en 2026: cómo crear una API de microservicios paso a paso

~
package service

import "context"

// Service define la interfaz para nuestro servicio de saludo.
type Service interface {
  Saludar(ctx context.Context, nombre string) (string, error)
}

// Implementación simple del servicio.
type simpleService struct{}

// NewService crea una nueva instancia del servicio.
func NewService() Service {
  return simpleService{}
}

// Saludar implementa la lógica de negocio.
func (s simpleService) Saludar(ctx context.Context, nombre string) (string, error) {
  if nombre == "" {
      return "Hola!", nil // Saludo genérico si no hay nombre
  }
  return "Hola, " + nombre + "!", nil
}

~
package endpoint

import (
  "context"
  "github.com/go-kit/kit/endpoint"
  "your_module_path/pkg/service" // Reemplaza con tu ruta de módulo
)

// SaludarRequest define la estructura de la petición para el endpoint Saludar.
type SaludarRequest struct {
  Nombre string json:"nombre"
}

// SaludarResponse define la estructura de la respuesta para el endpoint Saludar.
type SaludarResponse struct {
  Saludo string json:"saludo"
  Err    string json:"err,omitempty" // Los errores no se devuelven directamente en JSON usualmente
}

// MakeSaludarEndpoint crea un endpoint para el método Saludar del servicio.
func MakeSaludarEndpoint(svc service.Service) endpoint.Endpoint {
  return func(ctx context.Context, request interface{}) (interface{}, error) {
      req := request.(SaludarRequest) // Type assertion
      saludo, err := svc.Saludar(ctx, req.Nombre)
      if err != nil {
          // En una app real, manejarías el error de forma más robusta
          return SaludarResponse{Saludo: saludo, Err: err.Error()}, nil
      }
      return SaludarResponse{Saludo: saludo, Err: ""}, nil
  }
}

~
package transport

import (
  "context"
  "encoding/json"
  "net/http"

  "github.com/go-kit/kit/endpoint"
  httptransport "github.com/go-kit/kit/transport/http"
  "your_module_path/pkg/endpoint" // Reemplaza con tu ruta de módulo
)

// NewHTTPHandler crea un manejador HTTP para los endpoints del servicio.
func NewHTTPHandler(ep endpoint.Endpoint) http.Handler {
  mux := http.NewServeMux()
  mux.Handle("/saludar", httptransport.NewServer(
      ep,
      decodeSaludarRequest,
      encodeResponse,
  ))
  // Puedes añadir más rutas aquí para otros endpoints
  return mux
}

// decodeSaludarRequest decodifica la petición HTTP a SaludarRequest.
func decodeSaludarRequest(_ context.Context, r *http.Request) (interface{}, error) {
  var request endpoint.SaludarRequest
  // Intentamos decodificar el nombre desde query param o JSON body
  if name := r.URL.Query().Get("nombre"); name != "" {
       request.Nombre = name
  } else if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
      // Si no hay nombre en query y falla el decode del body (o está vacío)
      // Devolvemos un request con nombre vacío para el saludo genérico.
      // En una API real, podrías devolver un error BadRequest aquí.
      request.Nombre = ""
  }
  return request, nil
}

// encodeResponse codifica la respuesta del endpoint a formato JSON para HTTP.
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
  w.Header().Set("Content-Type", "application/json; charset=utf-8")
  // Aquí puedes manejar códigos de status basados en la respuesta si es necesario
  // Por ejemplo, si response contiene un error.
  // if e, ok := response.(endpoint.Failer); ok && e.Failed() != nil {
  //     encodeErrorResponse(ctx, e.Failed(), w) // Función separada para errores
  //     return nil
  // }
  return json.NewEncoder(w).Encode(response)
}

~
package main

import (
  "log"
  "net/http"

  "your_module_path/pkg/service"    // Reemplaza con tu ruta de módulo
  "your_module_path/pkg/endpoint"   // Reemplaza con tu ruta de módulo
  "your_module_path/pkg/transport"  // Reemplaza con tu ruta de módulo
)

func main() {
  // 1. Crear el servicio
  svc := service.NewService()

  // 2. Crear el endpoint
  saludarEndpoint := endpoint.MakeSaludarEndpoint(svc)

  // 3. Crear el manejador HTTP
  httpHandler := transport.NewHTTPHandler(saludarEndpoint)

  // 4. Iniciar el servidor HTTP
  port := ":8080"
  log.Printf("Servidor escuchando en puerto %s", port)
  log.Fatal(http.ListenAndServe(port, httpHandler))
}