Erstellen Sie mit Go einen OTP-basierten Authentifizierungsserver: Teil 3

Diese Folge beschreibt die Implementierung der OTP-Zustellung über Twilio, die Optimierung des asynchronen OTP-Versands mithilfe von Goroutinen und die Einrichtung eines robusten tokenbasierten Authentifizierungssystems.

OTPs mit Twilio senden

Die Kernfunktion zum Senden von OTPs mithilfe der Messaging-API von Twilio wird unten vorgestellt:

func (app *application) sendOTPViaTwilio(otp, phoneNumber string) error {
    client := twilio.NewRestClientWithParams(twilio.ClientParams{
        Username: os.Getenv("TWILIO_SID"),
        Password: os.Getenv("TWILIO_API_KEY"),
    })

    params := &api.CreateMessageParams{}
    params.SetBody(fmt.Sprintf(
        "Thank you for choosing Cheershare! Your one-time password is %v.",
        otp,
    ))
    params.SetFrom(os.Getenv("TWILIO_PHONE_NUMBER"))
    params.SetTo(fmt.Sprintf("+91%v", phoneNumber))

    const maxRetries = 3
    var lastErr error

    for attempt := 1; attempt <= maxRetries; attempt++ {
        resp, err := client.SendSms(params)
        if err == nil {
            app.logger.Printf("Message SID: %s", resp.Sid)
            return nil
        }
        lastErr = err
        time.Sleep(time.Duration(attempt) * 100 * time.Millisecond)
    }

    return fmt.Errorf("failed to send OTP after %d retries: %w", maxRetries, lastErr)
}

Diese Funktion nutzt das Go SDK von Twilio zum Senden von Nachrichten. Die from-Nummer ist eine vorkonfigurierte Twilio-Nummer. Aus Gründen der Zuverlässigkeit ist ein Wiederholungsmechanismus enthalten.

Asynchrones OTP-Versenden mit Goroutinen

Sequentielles OTP-Versenden beeinträchtigt die Serverleistung. Die Lösung besteht darin, Goroutinen zu verwenden, um die OTP-Zustellung gleichzeitig abzuwickeln. Die application-Struktur wird aktualisiert:

type application struct {
    wg     sync.WaitGroup
    config config
    models data.Models
    logger *log.Logger
    cache  *redis.Client
}

Eine Hilfsfunktion erleichtert die Ausführung von Hintergrundaufgaben:

func (app *application) background(fn func()) {
    app.wg.Add(1)
    go func() {
        defer app.wg.Done()
        defer func() {
            if err := recover(); err != nil {
                app.logger.Printf("Error in background function: %v\n", err)
            }
        }()
        fn()
    }()
}

Hierbei werden sync.WaitGroup zur Verwaltung von Goroutinen verwendet, um sicherzustellen, dass sie vor dem Herunterfahren abgeschlossen werden.

Datenbank-Token-Tabelle

Eine neue Datenbanktabelle wird erstellt, um Benutzertokens zu speichern:

-- 000002_create-token.up.sql
CREATE TABLE IF NOT EXISTS tokens (
    hash bytea PRIMARY KEY,
    user_id bigint NOT NULL REFERENCES users ON DELETE CASCADE,
    expiry timestamp(0) with time zone NOT NULL,
    scope text NOT NULL
);

-- 000002_create-token.down.sql
DROP TABLE IF EXISTS tokens;

In dieser Tabelle werden gehashte Token, Benutzer-IDs, Ablaufzeiten und Token-Bereiche gespeichert. Die Datenbankmigration wird mit migrate.

durchgeführt

Token-Modell und Funktionen

Die data/models.go-Datei enthält Funktionen zum Generieren, Einfügen und Abrufen von Token:

// ... (other imports) ...

package data

// ... (other code) ...

func generateToken(userId int64, ttl time.Duration, scope string) (*Token, error) {
    // ... (token generation logic) ...
}

func (m TokenModel) Insert(token *Token) error {
    // ... (database insertion logic) ...
}

func (m TokenModel) DeleteAllForUser(scope string, userID int64) error {
    // ... (database deletion logic) ...
}

func (m TokenModel) New(userId int64, ttl time.Duration, scope string) (*Token, error) {
    // ... (token creation and insertion logic) ...
}

Dieser Code übernimmt die Token-Erstellung, das Hashing und die Datenbankinteraktion. Die Funktion New erstellt und speichert neue Token.

Aktualisierungen des Anmelde-Handlers

Der Anmelde-Handler der cmd/api/user.go-Datei wird so geändert, dass er bei erfolgreicher OTP-Verifizierung Token ausgibt:

// ... (other functions) ...

func (app *application) handleUserSignupAndVerification(w http.ResponseWriter, r *http.Request) {
    // ... (input parsing and validation) ...

    // ... (OTP generation and sending logic) ...

    // ... (OTP verification logic) ...

    // ... (user creation or retrieval) ...

    token, err := app.generateTokenForUser(user.ID)
    if err != nil {
        // ... (error handling) ...
    }

    // ... (success response with token) ...
}

Dadurch wird die Token-Generierung in den Anmeldeablauf integriert.

Middleware-Schichten

Drei Middleware-Ebenen verbessern die Sicherheit und die Anforderungsbearbeitung: recoverPanic, authenticate und requireAuthenticatedUser. Diese werden wie im Originaltext dargestellt implementiert und auf Routen angewendet. Kontextverwaltungsfunktionen (contextSetUser und contextGetUser) werden zum Speichern und Abrufen von Benutzerdaten innerhalb des Anforderungskontexts verwendet.

Die Serverkonfiguration integriert diese Middlewares und das Beispiel zeigt, wie Routen mithilfe von requireAuthenticatedUser geschützt werden. Zukünftige Verbesserungen umfassen das Hochladen von Dateien, das ordnungsgemäße Herunterfahren und die Integration von Metriken. Der vollständige Code ist auf GitHub verfügbar.

Das obige ist der detaillierte Inhalt vonErstellen Sie mit Go einen OTP-basierten Authentifizierungsserver: Teil 3. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!