Infraestructura de base de código escalable

Golang brilla en el desarrollo backend, operaciones concurrentes y es una suite perfecta para crear aplicaciones backend escalables y de alto rendimiento. Debido a la falta de publicaciones sobre su arquitectura de microservicio con espacios de trabajo go, que es una herramienta increíble para compartir código modular a través de diferentes servicios, decidí compartir mi implementación.

Configuración del proyecto

mkdir docker

touch docker/Dockerfile.authentication

touch docker/Dockerfile.users

mkdir -p services/authentication

mkdir -p services/users

mkdir -p shared/utils

touch docker-compose.yml

Los siguientes comandos de shell producirán la siguiente estructura de árbol de carpetas

Configurar el espacio de trabajo Go

En la raíz del proyecto, cree un espacio de trabajo go simplemente usando un comando simple go work init, esto producirá el archivo go.work

A continuación, inicialice todos los diferentes proyectos de go que podrán mantener dependencias y ejecutar bases de código.

cd services/authentication && go mod init github.com/LegationPro/ms/services/authentication

cd ../.. && cd services/users && go mod init github.com/LegationPro/ms/services/users

cd ../.. && cd shared && go mod init github.com/LegationPro/ms/shared

Después de ejecutar los siguientes comandos, su proyecto debería verse así

A continuación, completaremos el espacio de trabajo go y le diremos qué es parte del espacio de trabajo ejecutando el siguiente comando

ir a trabajar usar ./services/authentication ./services/users ./shared

Esto completará el archivo go.work

go 1.23.1

use (
    ./services/authentication
    ./services/users
    ./shared
)

Configurarlo con Docker

Repasemos primero docker-compose.yml.

Tu archivo docker-compose.yml debería verse así

services:
  authentication:
    build:
      context: .
      dockerfile: docker/Dockerfile.authentication
    volumes:
      - ./services/authentication:/app/authentication
      - ./shared:/app/shared
    ports:
      - "8081:8081"

  users:
    build:
      context: .
      dockerfile: docker/Dockerfile.users
    volumes:
      - ./services/users:/app/users
      - ./shared:/app/shared
    ports:
      - "8082:8082"

Le decimos a Docker-compose que utilice los siguientes servicios, que son autenticación y usuarios.

Damos el contexto raíz, para que podamos acceder a los archivos y carpetas en el nivel raíz.

Proporcione la ubicación del archivo acoplable.

Defina el volumen dado para el contenedor y al final exponga un puerto para que se ejecute el contenedor.

Configurar archivos Docker

Configurar Dockerfile es bastante sencillo y directo.

Obtenemos la última imagen de golang alpine, asignamos un directorio de trabajo, movemos parte del código, lo ajustamos para que funcione con la estructura del espacio de trabajo de go y simplemente lo ejecutamos.

docker/Dockerfile.autenticación

# Pull golang image
FROM golang:1.23-alpine

# Switch to /app as the working directory
WORKDIR /app

# Copy the authentication codebase over to our container
COPY ./services/authentication /app/authentication/

# Copy the shared codebase and libraries that are shared across our apps inside the container
COPY ./shared /app/shared

# Initialize go workspace inside of our container
RUN go work init

# Assign different codebases to go workspaces
RUN go work use ./authentication ./shared

# Simply run our service with this simple command
CMD ["go", "run", "./authentication"]

Dockerfile.usuarios

# Pull golang image
FROM golang:1.23-alpine

# Switch to /app as the working directory
WORKDIR /app

# Copy the authentication codebase over to our container
COPY ./services/users /app/users/

# Copy the shared codebase and libraries that are shared across our apps inside the container
COPY ./shared /app/shared

# Initialize go workspace inside of our container
RUN go work init

# Assign different codebases to go workspaces
RUN go work use ./users ./shared

# Simply run our service with this simple command
CMD ["go", "run", "./users"]

Escribiendo nuestro código de servicio

servicios/autenticación/main.go

package main

import (
    "fmt"

    "github.com/LegationPro/ms/shared/utils"
)

func main() {
    fmt.Println(utils.SomeAuthFunc())
}

servicios/usuarios/main.go

package main

import (
    "fmt"

    "github.com/LegationPro/ms/shared/utils"
)

func main() {
    fmt.Println(utils.SomeUserFunc())
}

compartido/utils/utils.go

package utils

func SomeAuthFunc() string {
    return "Some auth func"
}

func SomeUserFunc() string {
    return "Some user func"
}

La estructura debería verse así ahora

Ejecute la aplicación dentro de un contenedor acoplable

docker-componer --compilar

Para asegurarse de que todo funcione, el resultado debe ser el siguiente:

Eso es todo, ¡tiene una configuración de arquitectura de microservicio modular go workspace completamente funcional! ??

Código fuente: https://github.com/LegationPro/go-microservice-modular-docker-setup

Gracias

¡Gracias por leer la publicación de mi blog, espero que esto ayude ❤️!