Ereignisgesteuertes Design mit Log Events und RabbitMQ in Golang

Die Einführung ereignisgesteuerter Architektur nimmt zu, da Teams nach anpassungsfähigeren, skalierbareren und agileren Lösungen suchen, um den Anforderungen moderner Anwendungen gerecht zu werden. Ereignisgesteuerte Architekturen unterstützen Aktualisierungen in Echtzeit und optimieren die Integration verschiedener Systeme, indem sie die Kommunikation über standardisierte und strukturierte Ereignisse ermöglichen.

In einem früheren Blogbeitrag habe ich besprochen, wie Webhooks in Auth0 Ereignisse übertragen und diese Ereignisse so nutzen können, um die Logikausführung zu initiieren. In diesem Artikel werde ich mich mit den technischen Aspekten dieser Architektur befassen und zeigen, wie Go (Golang) zum Aufbau eines solchen Systems verwendet werden kann.

Hauptbestandteile:

Werfen wir zunächst einen Blick auf die Hauptkomponenten, die dieses System antreiben.

Protokollereignisse:

Auth0 verfügt über Protokollereignisse, die jeder Aktivität auf Mandantenebene zugeordnet sind. Diese Ereignisse können zu Überwachungs- oder Prüfzwecken verwendet werden. Die Codes für jede Veranstaltung können hier eingesehen werden

Webhooks:

Wir verwenden Auth0-Webhooks, um gefilterte Ereignisse an unseren Produzenten zu übermitteln. Wir filtern diese Ereignisse, da wir nur an einer Handvoll interessiert sind.

RabbitMQ

RabbitMQ unterstützt mehrere Messaging-Protokolle, und das Protokoll, das wir zum Weiterleiten von Nachrichten verwenden, ist das Advanced Messaging Queuing Protocol (AMQP). AMQP hat drei Haupteinheiten – Warteschlangen, Austausch und Bindungen.

Hinter den Kulissen

Wenn ein Ereignis in Auth0 ausgelöst wird, wird es sofort per Webhook an unseren Publisher gesendet, der es dann basierend auf dem Ereignistyp veröffentlicht. Nach der Veröffentlichung geht die Veranstaltung an eine Börse. Der Austausch leitet die Nachricht an verbundene Warteschlangen weiter, wo Verbraucher sie empfangen. Um diesen Prozess zu ermöglichen, richten wir einen Kanal ein. Über diesen Kanal können wir Nachrichten zum Austausch veröffentlichen und Warteschlangen für Abonnements anmelden.

Um eine neue Warteschlange zu erstellen, verwenden wir die QueueDeclare-Funktion, die vom Paket auf dem Kanal bereitgestellt wird, und geben unsere gewünschten Warteschlangeneigenschaften an. Nachdem die Warteschlange erstellt wurde, können wir die Veröffentlichungsfunktion des Kanals verwenden, um eine Nachricht zu senden.

Als nächstes erstellen wir einen Verbraucher, der sich mit unserem RabbitMQ verbindet und einen Kommunikationskanal einrichtet. Über diesen Kanal können wir Nachrichten mithilfe der dafür definierten Consume-Methode konsumieren.

Grundlage

Wir verwenden das Verwaltungspaket golang-auth0, um an den Protokollereignissen zu arbeiten, und für die Warteschlangenaktionen verwenden wir github.com/rabbitmq/amqp091-go.

Nachstehend finden Sie die Ausschnitte:

Veröffentlichung:

Eine detaillierte Struktur des Protokolls finden Sie hier

    for _, auth0log := range payload.Logs {

        switch auth0log.Data.Type {
        case "slo":
            _, err = c.Publish(ctx, PublishRequest{
                ---your logic---
            })

        case "ss":
            _, err = c.Publish(ctx,PublishRequest{
                    -- your logic -----
                })

        }
    }

Austausch:

    if consumeOptions.BindingExchange != "" {
        for _, routingKey := range routingKeys {
            err = consumer.chManager.channel.QueueBind(
                queue,
                routingKey,
                consumeOptions.BindingExchange,
                consumeOptions.BindingNoWait,
                tableToAMQPTable(consumeOptions.BindingArgs),
            )
            if err != nil {
                return err
            }
        }
    }

Konsumieren:

func (c *Client) Consume() {
    err := c.consumer.StartConsuming(
        func(ctx context.Context, d queue.Delivery) bool {
            err := c.processMessages(ctx, d.Body, d.Exchange)
            if err != nil {
                c.log.Error().Ctx(ctx).Err(err).Str("exchange", d.Exchange).Msg("failed publishing")
                return nack // send to dlx
            }
            return ack // message acknowledged
        },
        c.queueName,
        []string{c.queueRoutingKey},
        func(opts *queue.ConsumeOptions) {
            opts.BindingExchange = c.queueBidingExchange
            opts.QueueDurable = true
            opts.QueueArgs = map[string]interface{}{
                "x-dead-letter-exchange": c.queueBidingExchangeDlx,
            }
        },
    )
    if err != nil {
        c.log.Fatal().Err(err).Msg("consumer: Failed to StartConsuming")
    }

    // block main thread so consumers run forever
    forever := make(chan struct{})
    <-forever
}   

Durch die Nutzung von Webhooks in Auth0 zum Auslösen von Ereignissen und den Einsatz von RabbitMQ für die zuverlässige Nachrichtenwarteschlange und -zustellung können wir skalierbare und reaktionsfähige Anwendungen erstellen. Dieser Ansatz erhöht nicht nur die Flexibilität, sondern unterstützt auch eine nahtlose Ereignisverarbeitung und ermöglicht so eine effiziente Abwicklung asynchroner Vorgänge.

Ich hoffe, dieser Artikel war hilfreich und kann sich bei Ihrer ereignisgesteuerten Reise als nützlich erweisen.

Viel Spaß beim Codieren :)

Das obige ist der detaillierte Inhalt vonEreignisgesteuertes Design mit Log Events und RabbitMQ in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!