Skalierbare Codebasis-Infrastruktur

Golang glänzt in der Backend-Entwicklung und im gleichzeitigen Betrieb und ist eine perfekte Suite für die Erstellung skalierbarer und leistungsstarker Backend-Anwendungen. Aufgrund des Mangels an Beiträgen, die sich mit der Microservice-Architektur mit Go-Workspaces befassen, die ein unglaubliches Tool zum Teilen von modularem Code über verschiedene Dienste darstellt, habe ich beschlossen, meine Implementierung zu teilen.

Projektaufbau

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

Die folgenden Shell-Befehle erzeugen die folgende Ordnerbaumstruktur

Go-Workspace einrichten

Erstellen Sie im Stammverzeichnis des Projekts einen Go-Arbeitsbereich, indem Sie einfach den einfachen Befehl go work init verwenden. Dadurch wird die Datei go.work erstellt.

Als nächstes initialisieren Sie alle verschiedenen Go-Projekte, die Abhängigkeiten enthalten und Codebasen ausführen können.

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

Nachdem Sie die folgenden Befehle ausgeführt haben, sollte Ihr Projekt so aussehen

Als nächstes füllen wir den Go-Arbeitsbereich und teilen ihm mit, was Teil des Arbeitsbereichs ist, indem wir den folgenden Befehl ausführen

geh zur Arbeit benutze ./services/authentication ./services/users ./shared

Dadurch wird die go.work-Datei gefüllt

go 1.23.1

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

Einrichten mit Docker

Lass uns zuerst die Datei docker-compose.yml durchgehen.

Ihre docker-compose.yml-Datei sollte so aussehen

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"

Wir weisen Docker-Compose an, die folgenden Dienste zu verwenden: Authentifizierung und Benutzer.

Wir geben den Root-Kontext an, damit wir auf der Root-Ebene auf die Dateien und Ordner zugreifen können.

Geben Sie den Speicherort der Docker-Datei an.

Definieren Sie das angegebene Volume für den Container und stellen Sie am Ende einen Port zur Verfügung, auf dem der Container ausgeführt werden soll.

Dockerfiles einrichten

Das Einrichten der Docker-Datei ist ziemlich einfach und unkompliziert.

Wir rufen das neueste Golang-Alpine-Image ab, weisen ein Arbeitsverzeichnis zu, verschieben einen Teil des Codes, passen ihn an die Go-Workspace-Struktur an und führen ihn einfach aus.

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

Schreiben unseres Servicecodes

services/authentication/main.go

package main

import (
    "fmt"

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

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

services/users/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"
}

Die Struktur sollte jetzt so aussehen

Führen Sie die Anwendung in einem Docker-Container aus

docker-compose up --build

Um sicherzustellen, dass alles funktioniert, sollte die Ausgabe wie folgt aussehen:

Das ist alles, Sie haben ein voll funktionsfähiges Go-Workspace-Setup mit modularer Microservice-Architektur! ??

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

Danke

Vielen Dank für das Lesen meines Blogbeitrags, ich hoffe, das hilft ❤️!