Microservicios en Go: arquitectura y práctica de la A a la Z

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción a los microservicios en Go

La arquitectura de microservicios se ha convertido en el estándar de facto para construir sistemas distribuidos modernos. El lenguaje Go (Golang) con sus gorutinas ligeras, alto rendimiento y simplicidad de despliegue es ideal para implementar microservicios. En este artículo analizaremos la arquitectura de microservicios en Go desde el concepto hasta la implementación práctica con ejemplos de código.

Go ofrece soporte integrado para concurrencia, inicio rápido y tamaño pequeño de archivos binarios — todo esto es críticamente importante para microservicios. Veremos cómo diseñar un servicio, implementar una REST API, agregar middleware y preparar la aplicación para contenerización.

Arquitectura de microservicio en Go

1. Estructura del proyecto

La organización correcta del código es la base de un microservicio mantenible. Estructura recomendada:

myservice/├── cmd/│   └── server/│       └── main.go          # Punto de entrada├── internal/│   ├── handler/             # Manejadores HTTP│   ├── service/             # Lógica de negocio│   ├── repository/          # Trabajo con datos│   └── middleware/          # Manejadores intermedios├── pkg/│   └── models/              # Modelos de datos comunes├── config/│   └── config.go            # Configuración├── go.mod└── Dockerfile

Esta estructura corresponde a los principios de Clean Architecture: handler → service → repository. Esto permite probar fácilmente cada capa de forma independiente.

2. Configuración e inicio

Empecemos con un servidor HTTP simple usando la biblioteca estándar net/http:

// cmd/server/main.gopackage main

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

func main() {    port := os.Getenv("PORT")    if port == "" {        port = "8080"    }

    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {        w.WriteHeader(http.StatusOK)        fmt.Fprintf(w, `{"status": "ok"}`)    })

    log.Printf("Server starting on :%s", port)    log.Fatal(http.ListenAndServe(":"+port, nil))}

Este es un microservicio mínimo. Para producción use un router con soporte de middleware, por ejemplo gorilla/mux o chi.

Implementación práctica del microservicio

3. REST API con gorilla/mux

Instalemos gorilla/mux e implementemos CRUD para la entidad "Usuario":

// go.modmodule github.com/youruser/userservice

go 1.21

require github.com/gorilla/mux v1.8.1

// internal/handler/user.gopackage handler

import (    "encoding/json"    "net/http"    "github.com/gorilla/mux")

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

var users = []User{    {ID: "1", Name: "Alice", Age: 30},}

func GetUsers(w http.ResponseWriter, r *http.Request) {    w.Header().Set("Content-Type", "application/json")    json.NewEncoder(w).Encode(users)}

func CreateUser(w http.ResponseWriter, r *http.Request) {    var newUser User    if err := json.NewDecoder(r.Body).Decode(&newUser); err != nil {        http.Error(w, err.Error(), http.StatusBadRequest)        return    }    users = append(users, newUser)    w.WriteHeader(http.StatusCreated)    json.NewEncoder(w).Encode(newUser)}

// cmd/server/main.go (continuación)package main

import (    "log"    "net/http"    "github.com/gorilla/mux"    "yourproject/internal/handler")

func main() {    r := mux.NewRouter()    r.HandleFunc("/users", handler.GetUsers).Methods("GET")    r.HandleFunc("/users", handler.CreateUser).Methods("POST")

    log.Println("Server started on :8080")    log.Fatal(http.ListenAndServe(":8080", r))}