Verwendung des Heartbeats-Musters in Golang

Implementierung von Heartbeats in Go zur Anwendungsüberwachung

Während meiner Abenteuer, Daten- und Software-Ingenieur in Einklang zu bringen, suche ich immer nach etwas, das etwas anders in GoLang ist, um es zu studieren, zu verstehen, wie es funktioniert, und es auf komplexere Dinge anzuwenden als einige grundlegende traditionelle Kurse und Artikel, die ich im Internet finde . In diesem kurzen Artikel werde ich berichten und demonstrieren, wie ich durch Go Routines das Zeitpaket mithilfe von Ticker implementiert habe, um den Herzschlag („Ich lebe“) der Anwendung zu simulieren, zusätzlich zur Verwendung von Kanälen usw.

Für viele ist es keine Neuigkeit, dass es äußerst wichtig ist, sicherzustellen, dass jeder, der eine bestimmte Funktion aufruft, weiß, ob die Funktion Zeit benötigt, verarbeitet oder gesperrt ist. Allerdings sind mehrere andere Terminologien entstanden, wie etwa Trace, Metriken, Konnektivität usw., die in Überwachungsanwendungen eingeführt wurden, die in den meisten Fällen auf den Anwendungsservern installierte Agenten verwenden, die Metriken sammeln und sie an Schnittstellen senden, die alles visualisieren (bzw (fast) den Status Ihrer Bewerbung. Zu diesen Tools gehören DataDog, NewRelic, Slack, Grafana, Jaeger usw.

Was werden wir hier haben?

Während ich studiere und darüber nachdenke, etwas Schnelles und Einfaches zu erstellen, das einige fortgeschrittenere Go-Konzepte berücksichtigt, habe ich eine relativ einfache Anwendung erstellt, die das Heartbeats-Muster nutzt. Wer mich anruft, erhält das Ergebnis und gleichzeitig die Information, ob ich noch aktiv bin oder nicht. In einem fortgeschritteneren Szenario kann es interessant sein, eine tatsächlich aktive Anwendung im Hinblick auf einige geschäftliche Besonderheiten anzupassen, da eine einfache Implementierung eines Prometheus diesen Fall löst (ist die Anwendung aktiv? CPU, Speicher, offene Goroutinen), aber nicht mit gleichzeitigem und anpassbarem Feedback.

Stunde des Codes!

In Bezug auf die Struktur habe ich mit go mod nur drei Dateien in meinem Paket erstellt:

• dictionary.go: Enthält ein Wörterbuch mit Namen für die zu durchsuchende Funktion.
• task.go: Aufgabe, die die Funktion enthält, Namen aus dem Wörterbuch zu scannen und gleichzeitig über den Kanalbeat von team.Ticker mitzuteilen, ob sie aktiv ist oder nicht.
• task_test.go: Führt einen Komponententest der in task.go vorhandenen Funktion durch, um sowohl die Antwort aus den Wörterbuchdaten als auch Rückmeldung darüber zu sehen, ob die Anwendung noch aktiv ist!

dictionary.go

Dieser Teil des Go-Codes definiert eine Variable namens „Wörterbuch“, bei der es sich um eine Karte handelt, die runenartige Zeichen mit Zeichenfolgen verknüpft.

Jeder Karteneintrag ist ein Schlüssel (Rune) und ein Wert (String). Im folgenden Beispiel sind die Schlüssel Kleinbuchstaben des Alphabets und die Werte sind Namen, die jedem Buchstaben zugeordnet sind. Beispielsweise ist der Buchstabe „a“ mit dem Namen „airton“ verbunden, der Buchstabe „b“ mit dem Namen „bruno“ und so weiter:

package heartbeat

var dicionario = map[rune]string{
    'a': "airton",
    'b': "bruno",
    'c': "carlos",
    'd': "daniel",
    'e': "eduardo",
    'f': "felipe",
    'g': "gustavo",
}

task.go

Ich erkläre unten nach dem vollständigen Code jeden Teil des Codes besser:

package heartbeat

import (
    "context"
    "fmt"
    "time"
)

func ProcessingTask(
    ctx context.Context, letras chan rune, interval time.Duration,
) (<-chan struct{}, <-chan string) {

    heartbeats := make(chan struct{}, 1)
    names := make(chan string)

    go func() {
        defer close(heartbeats)
        defer close(names)

        beat := time.NewTicker(interval)
        defer beat.Stop()

        for letra := range letras {
            select {
            case <-ctx.Done():
                return
            case <-beat.C:
                select {
                case heartbeats <- struct{}{}:
                default:
                }
            case names <- dicionario[letra]:
                lether := dicionario[letra]
                fmt.Printf("Letra: %s \n", lether)

                time.Sleep(3 * time.Second) // Simula um tempo de espera para vermos o hearbeats
            }
        }
    }()

    return heartbeats, names
}

Abhängigkeiten importieren

package heartbeat

import (
    "context"
    "fmt"
    "time"
)

Hier habe ich mein Heartbeat-Paket, das für die Implementierung einer Funktionalität verantwortlich ist, die während der Verarbeitung von Aufgaben in einem bestimmten Zeitintervall „Heartbeats“ sendet. Dafür benötige ich context (Context Management), fmt (für String-Formatierung) und time für die Zeitsteuerung.

Anfängliche Funktionsdefinition

func ProcessingTask (
    ctx context.Context, letras chan rune, interval time.Duration,
) (<-chan struct{}, <-chan string) {

Dies ist die Definition der ProcessingTask-Funktion, die einen ctx-Kontext, einen Buchstabenkanal (ein Kanal, der Unicode-Zeichen empfängt) und ein Zeitintervall als Argumente verwendet. Die Funktion gibt zwei Kanäle zurück: einen Heartbeats-Kanal, der für jeden „Heartbeat“ eine leere Struktur sendet, und einen Namenskanal, der den Namen des Buchstabens sendet, der jedem empfangenen Zeichen entspricht.

Kanäle

heartbeats := make(chan struct{}, 1)
names := make(chan string)

Diese beiden Zeilen erstellen zwei Kanäle: Heartbeats ist ein Pufferkanal mit einer Kapazität von einem Element und Names ist ein ungepufferter Kanal.

Gehen Sie zur Routine über, die Ihnen die schwere Arbeit abnimmt

go func() 
    defer close(heartbeats)
    defer close(names)

    beat := time.NewTicker(interval)
    defer beat.Stop()

    for letra := range letras {
        select {
        case <-ctx.Done():
            return
        case <-beat.C:
            select {
            case heartbeats <- struct{}{}:
            default:
            }
        case names <- dicionario[letra]:
            lether := dicionario[letra]
            fmt.Printf("Letra: %s \n", lether)

            time.Sleep(3 * time.Second) // Simula um tempo de espera para vermos o hearbeats
        }
    }
}()

return heartbeats, names

Dies ist eine anonyme Goroutine (oder anonyme Funktion, die in einem neuen Thread ausgeführt wird), die die Hauptlogik der ProcessingTask-Funktion ausführt. Es verwendet eine for-range-Schleife, um Zeichen aus dem Buchstabenkanal zu lesen. Verwenden Sie innerhalb der Schleife eine Auswahl, um aus den verfügbaren Optionen eine auszuführende Aktion auszuwählen:

• case <-ctx.Done(): Wenn der Kontext abgebrochen wird, wird die Funktion sofort mit der return.
-Anweisung beendet
• case <-beat.C: Wenn der Beat-Ticker einen Wert sendet, versucht die Goroutine, mithilfe einer Auswahl mit einem leeren Standardwert eine leere Struktur an den Heartbeats-Kanal zu senden.
• Fallnamen <- Wörterbuch[Buchstabe]: Wenn ein Buchstabe empfangen wird, ruft die Goroutine den Namen des entsprechenden Buchstabens aus dem Wörterbuch ab, sendet ihn an den Namenskanal, druckt den Buchstaben mithilfe des FMT-Pakets auf dem Bildschirm aus und wartet darauf drei Sekunden, bevor mit dem nächsten Zeichen fortgefahren wird. Diese simulierte Wartezeit dient dazu, dass wir die gesendeten „Heartbeats“ sehen können.

Schließlich gibt die Funktion die Herzschläge zurück und benennt Kanäle.

Testen der Anwendung

task_test.go

package heartbeat

var dicionario = map[rune]string{
    'a': "airton",
    'b': "bruno",
    'c': "carlos",
    'd': "daniel",
    'e': "eduardo",
    'f': "felipe",
    'g': "gustavo",
}

Hier habe ich einen Go-Komponententest für die zuvor erläuterte ProcessingTask-Funktion erstellt. Die Testfunktion TestProcessingTask erstellt einen Kontext mit einem Timeout von 20 Sekunden und einer Pipe aus Unicode-Zeichen (Buchstaben). Die anonyme Goroutine sendet dann Liedtexte an den Liedtextkanal. Anschließend wird die Funktion ProcessingTask mit dem Kontext, dem Unicode-Zeichenkanal und einem Zeitintervall aufgerufen. Es werden zwei Kanäle zurückgegeben, ein Herzschlagkanal und ein Wortkanal.

Dann führt die Testfunktion eine Endlosschleife mit einer Auswahl aus, die aus drei Kanälen liest: dem Kontext, dem Heartbeat-Kanal und dem Wortkanal.

Wenn der Kontext abgebrochen wird, wird die Testschleife beendet. Wenn ein Heartbeat empfangen wird, wird die Meldung „Application Up!“ angezeigt. wird auf der Standardausgabe gedruckt. Wird ein Wort empfangen, prüft der Test, ob das Wort im Buchstabenwörterbuch vorhanden ist. Wenn es nicht vorhanden ist, schlägt der Test fehl und es wird eine Fehlermeldung angezeigt.

Daher testet dieser Komponententest unsere ProcessingTask-Funktion, die Zeichen von einem Kanal empfängt, Buchstabennamen an einen anderen Kanal sendet und die „Heartbeats“ aussendet, während sie in einem Kontext ausgeführt wird, in dem ich ein Zeitlimit verwendet habe. Ahhh... und es prüft auch, ob die Namen der an den Wortkanal gesendeten Buchstaben im Wörterbuch vorhanden sind.

Meine Schlussfolgerungen

Dieser Go-Code veranschaulicht einige wichtige Konzepte der Go-Sprache und Unit-Tests:

• Kontext
• Goroutinen
• Kanäle
• Unit-Tests (mit Select zur Überwachung mehrerer Kanäle)

Vollständiges Projekt auf meinem GitHub: https://github.com/AirtonLira/heartbeatsGolang

LinkedIn - Airton Lira Junior

Das obige ist der detaillierte Inhalt vonVerwendung des Heartbeats-Musters in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!