Mikroservices mit Go: Architektur und Praxis von A bis Z

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung in Microservices mit Go

Die Microservice-Architektur ist zum De-facto-Standard für den Aufbau moderner verteilter Systeme geworden. Die Sprache Go (Golang) mit ihren leichtgewichtigen Goroutinen, hoher Leistung und einfacher Bereitstellung ist ideal für die Implementierung von Microservices. In diesem Artikel analysieren wir die Microservice-Architektur mit Go vom Konzept bis zur praktischen Umsetzung mit Codebeispielen.

Go bietet integrierte Unterstützung für Nebenläufigkeit, schnellen Start und kleine Binärdateigrößen – all dies ist für Microservices entscheidend. Wir betrachten, wie man einen Service entwirft, eine REST-API implementiert, Middleware hinzufügt und die Anwendung für die Containerisierung vorbereitet.

Microservice-Architektur mit Go

1. Projektstruktur

Die richtige Code-Organisation ist die Grundlage eines wartbaren Microservices. Empfohlene Struktur:

myservice/├── cmd/│   └── server/│       └── main.go          # Einstiegspunkt├── internal/│   ├── handler/             # HTTP-Handler│   ├── service/             # Geschäftslogik│   ├── repository/          # Datenzugriff│   └── middleware/          # Zwischenhandler├── pkg/│   └── models/              # Gemeinsame Datenmodelle├── config/│   └── config.go            # Konfiguration├── go.mod└── Dockerfile

Diese Struktur folgt den Prinzipien der Clean Architecture: handler → service → repository. Dies ermöglicht es, jede Schicht unabhängig zu testen.

2. Konfiguration und Start

Beginnen wir mit einem einfachen HTTP-Server unter Verwendung der Standardbibliothek 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))}

Dies ist ein minimaler Microservice. Verwenden Sie für die Produktion einen Router mit Middleware-Unterstützung, z. B. gorilla/mux oder chi.

Praktische Implementierung eines Microservices

3. REST-API mit gorilla/mux

Installieren wir gorilla/mux und implementieren CRUD für die Entität "Benutzer":

// 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 (Fortsetzung)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))}