Welche Abfolge von Schritten ist erforderlich, um die Anwendung korrekt zu stoppen, ohne Daten zu verlieren oder Fehler zu verursachen?

Um eine Go-Anwendung korrekt zu stoppen, ohne Daten zu verlieren oder Fehler zu verursachen, werden in der Regel folgende Schritte befolgt:

1. Signalbehandlung des Betriebssystems — Erfassen von Beendigungssignalen (SIGINT, SIGTERM) mittels eines Kanals und signal.Notify.

2. Start eines sanften Herunterfahrens (graceful shutdown) — Starten eines Prozesses für ein sanftes Herunterfahren, der neue Anfragen stoppt und laufende Anfragen abschließen lässt.

3. Abbruch des Kontexts — Verwendung von context.Context mit Abbruch, um das Stoppsignal an alle Goroutinen zu übermitteln.

4. Schließen der Ressourcen — Schließen offener Verbindungen zu Datenbanken, Dateien, Netzwerken.

5. Warten auf das Beenden der Goroutinen — Verwendung von sync.WaitGroup oder anderen Mechanismen, um auf das Ende aller Operationen zu warten.

Beispiel für Signalbehandlung und sanftes Herunterfahren:

import (
    "context"
    "os"
    "os/signal"
    "sync"
    "syscall"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup

    // Start der Anwendung
    wg.Add(1)
    go func() {
        defer wg.Done()
        runApp(ctx) // Funktion mit der Hauptlogik
    }()

    // Signalbehandlung
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)

    <-sigs // Warten auf Signal
    cancel() // Kontext abbrechen, um Goroutinen zu signalisieren

    // Warten auf Abschluss
    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    select {
    case <-done:
        // Alles beendet
    case <-time.After(10 * time.Second):
        // Timeout
    }
}

Dieser Ansatz hilft, Datenverluste und inkorrekte Abschlüsse zu vermeiden.