Infrastructure de base de code évolutive

Golang brille dans le développement back-end et les opérations simultanées et constitue une suite parfaite pour créer des applications back-end évolutives et performantes. En raison du manque d'articles traitant de son architecture de microservices avec des espaces de travail Go, qui est un outil incroyable pour partager du code modulaire via différents services, j'ai décidé de partager mon implémentation.

Configuration du projet

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

Les commandes shell suivantes produiront l'arborescence de dossiers suivante

Configuration de l'espace de travail Go

À la racine du projet, créez un espace de travail go simplement en utilisant une simple commande go work init cela produira le fichier go.work

Ensuite, initialisez tous les différents projets go qui pourront contenir des dépendances et exécuter des bases de code.

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

Après avoir exécuté les commandes suivantes, votre projet devrait ressembler à ceci

Ensuite, nous remplirons l'espace de travail go et lui indiquerons ce qui fait partie de l'espace de travail en exécutant la commande suivante

aller travailler, utiliser ./services/authentication ./services/users ./shared

Cela remplira le fichier go.work

go 1.23.1

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

Le configurer avec Docker

Parcourons d'abord le fichier docker-compose.yml.

Votre fichier docker-compose.yml devrait ressembler à ceci

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"

Nous demandons à docker-compose d'utiliser les services suivants qui sont l'authentification et les utilisateurs.

Nous donnons le contexte racine, afin que nous puissions accéder aux fichiers et dossiers au niveau racine.

Fournissez l'emplacement du fichier docker.

Définissez le volume donné pour le conteneur et, à la fin, exposez un port sur lequel le conteneur doit s'exécuter.

Configuration des fichiers Docker

La configuration du Dockerfile est assez simple et directe.

Nous extrayons la dernière image golang alpine, attribuons un répertoire de travail, déplaçons une partie du code, l'ajustons pour qu'il fonctionne avec la structure de l'espace de travail go et l'exécutons simplement.

docker/Dockerfile.authentication

# 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.users

# 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"]

Écrire notre code de service

services/authentification/main.go

package main

import (
    "fmt"

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

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

services/utilisateurs/main.go

package main

import (
    "fmt"

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

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

shared/utils/utils.go

package utils

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

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

La structure devrait ressembler à ceci maintenant

Exécutez l'application dans un conteneur Docker

docker-compose up --build

Pour vous assurer que tout fonctionne, le résultat doit être le suivant :

Ça y est, vous disposez d'une configuration d'architecture de microservices modulaires pour espace de travail Go entièrement fonctionnelle ! ??

Code source : https://github.com/LegationPro/go-microservice-modular-docker-setup

Merci

Merci d'avoir lu mon article de blog, j'espère que cela vous aidera ❤️ !