Microservicios en Go: arquitectura y práctica para desarrolladores

Introducción a los microservicios en Go

La arquitectura de microservicios se ha convertido en un estándar para construir aplicaciones escalables y tolerantes a fallos. El lenguaje Go (Golang) es ideal para el desarrollo de microservicios gracias a su rendimiento, soporte integrado de concurrencia y facilidad de despliegue. En este artículo, exploraremos los principios fundamentales para construir microservicios en Go, crearemos un servicio simple con REST API, conectaremos una base de datos y mostraremos cómo contenerizar la aplicación con Docker.

Fundamentos de la arquitectura de microservicios

Los microservicios son un enfoque en el que la aplicación se divide en servicios pequeños e independientemente desplegables. Cada servicio se encarga de su propia lógica de negocio y se comunica con otros mediante protocolos ligeros (generalmente HTTP/REST o gRPC).

Ventajas de los microservicios en Go

• Rendimiento: Go se compila a código máquina, lo que proporciona una alta velocidad de ejecución.
• Concurrencia: las goroutines y los canales permiten manejar eficientemente miles de solicitudes.
• Facilidad de despliegue: el archivo binario no requiere dependencias externas.
• Biblioteca estándar integrada: los paquetes net/http, encoding/json y otros cubren la mayoría de las tareas.

Principios clave de diseño

• Responsabilidad única: cada servicio resuelve una sola tarea.
• Independencia: los servicios se pueden desarrollar, probar y desplegar por separado.
• Bajo acoplamiento: los cambios en un servicio no deben romper otros.
• Tolerancia a fallos: la falla de un servicio no debe derrumbar todo el sistema.

Práctica: creando un microservicio en Go

Vamos a crear un microservicio simple para la gestión de usuarios. Proporcionará una REST API para crear, leer, actualizar y eliminar usuarios (CRUD).

Paso 1: Inicialización del proyecto

Cree un directorio para el proyecto e inicialice el módulo Go:

mkdir user-servicecd user-servicego mod init github.com/yourusername/user-service

Paso 2: Estructura del proyecto

Organicemos el código por paquetes:

user-service/├── cmd/│   └── main.go├── internal/│   ├── handler/│   │   └── user.go│   ├── model/│   │   └── user.go│   └── repository/│       └── user.go├── go.mod└── go.sum

Paso 3: Definimos el modelo de datos

Crearemos la estructura del usuario en el archivo internal/model/user.go:

package model

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

Paso 4: Implementamos el almacenamiento (repositorio)

Para simplificar, usaremos un almacenamiento en memoria. Crearemos internal/repository/user.go:

package repository

import (    "sync"    "user-service/internal/model")

type UserRepository struct {    mu     sync.RWMutex    users  map[int]model.User    nextID int}

func NewUserRepository() *UserRepository {    return &UserRepository{        users:  make(map[int]model.User),        nextID: 1,    }}

func (r *UserRepository) Create(user model.User) model.User {    r.mu.Lock()    defer r.mu.Unlock()    user.ID = r.nextID    r.nextID++    r.users[user.ID] = user    return user}

func (r *UserRepository) GetByID(id int) (model.User, bool) {    r.mu.RLock()    defer r.mu.RUnlock()    user, ok := r.users[id]    return user, ok}

func (r *UserRepository) GetAll() []model.User {    r.mu.RLock()    defer r.mu.RUnlock()    result := make([]model.User, 0, len(r.users))    for _, user := range r.users {        result = append(result, user)    }    return result}

func (r *UserRepository) Update(id int, user model.Us