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

Erste Schritte

Erstellen Sie zunächst einen neuen Ordner für Ihr Projekt und initialisieren Sie ein Go-Modul mit dem folgenden Befehl:

gehen Sie mod init github.com/vishaaxl/cheershare

Richten Sie die Projektstruktur ein

Beginnen Sie mit der Einrichtung eines neuen Go-Projekts mit der folgenden Ordnerstruktur:

my-otp-auth-server/
├── cmd/
│   └── api/
│       └── main.go
│       └── user.go
│       └── token.go
├── internal/
│   └── data/
│       ├── models.go
│       └── user.go
│       └── token.go
├── docker-compose.yml
├── go.mod
└── Makefile

Als nächstes richten Sie Ihre docker-compose.yml-Datei ein. Diese Konfiguration definiert die Dienste – PostgreSQL und Redis –, mit denen Sie in diesem Tutorial arbeiten werden.

Dienste mit Docker Compose einrichten

Wir beginnen mit der Konfiguration der für unser Projekt erforderlichen Dienste. Für das Backend benötigen wir Folgendes:

• Redis: Wir verwenden das Redis:6-Image. Dieser Dienst konfiguriert ein Passwort für den sicheren Zugriff, stellt Port 6379 bereit und erzwingt die Passwortauthentifizierung mithilfe des Flags --requirepass, um den Redis-Zugriff zu sichern.

• PostgreSQL: Wir verwenden das Bild postgres:13. Der Dienst definiert einen Standardbenutzer, ein Standardkennwort und eine Standarddatenbank, stellt Port 5432 für die Kommunikation bereit und speichert Daten auf einem benannten Volume (postgres_data), um die Haltbarkeit sicherzustellen.

Optional:

• Haupt-Backend-Dienst: Sie können hier auch den Haupt-Backend-Dienst definieren, der sowohl mit PostgreSQL als auch Redis interagiert.

// docker-compose.yml
services:
  postgres:
    image: postgres:13
    container_name: postgres
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: mysecretpassword
      POSTGRES_DB: cheershare
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:6
    container_name: redis
    environment:
      REDIS_PASSWORD: mysecretpassword
    ports:
      - "6379:6379"
    command: ["redis-server", "--requirepass", "mysecretpassword"]

volumes:
  postgres_data:

Haupt-Backend-Dienst

Für die Weiterleitung und Bearbeitung von HTTP-Anfragen verwenden wir das Paket github.com/julienschmidt/httprouter. Um die Abhängigkeit zu installieren, führen Sie den folgenden Befehl aus:

go get github.com/julienschmidt/httprouter

Als nächstes erstellen Sie eine Datei unter cmd/api/main.go und fügen den folgenden Code ein. Eine Erklärung zu jeder Zeile finden Sie in den Kommentaren:

//  main.go
package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "github.com/julienschmidt/httprouter"
)

/*
config struct:
- Holds application-wide configuration settings such as:
  - `port`: The port number on which the server will listen.
  - `env`: The current environment (e.g., "development", "production").
*/
type config struct {
    port int
    env  string
}

/*
applications struct:
- Encapsulates the application's dependencies, including:
  - `config`: The application's configuration settings.
  - `logger`: A logger instance to handle log messages.
*/
type applications struct {
    config config
    logger *log.Logger
}

func main() {
    cfg := &config{
        port: 4000,
        env:  "development",
    }

    logger := log.New(os.Stdout, "INFO\t", log.Ldate|log.Ltime)

    app := &applications{
        config: *cfg,
        logger: logger,
    }

    router := httprouter.New()

    router.GET("/", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprintln(w, "Welcome to the Go application!")
    })

    /*
        Initialize the HTTP server
        - Set the server's address to listen on the specified port.
        - Assign the router as the handler.
        - Configure timeouts for idle, read, and write operations.
        - Set up an error logger to capture server errors.
    */
    srv := &http.Server{
        Addr:         fmt.Sprintf(":%d", app.config.port),
        Handler:      router,
        IdleTimeout:  time.Minute,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 30 * time.Second,
    }

    app.logger.Printf("Starting server on port %d in %s mode", app.config.port, app.config.env)

    err := srv.ListenAndServe()
    if err != nil {
        app.logger.Fatalf("Could not start server: %s", err)
    }
}

Im Moment können Sie Ihr Setup testen, indem Sie den Server mit go run ./cmd/api starten und eine Anfrage an http://localhost:4000 senden, die eine Willkommensnachricht zurückgibt. Als Nächstes definieren wir drei zusätzliche Routen zur Implementierung unserer Kernfunktionalität:

1. /send-otp: Diese Route übernimmt das Senden von OTPs an Benutzer. Es wird ein eindeutiges OTP generiert, in Redis gespeichert und an den Benutzer übermittelt.

2. /verify-otp: Diese Route überprüft das vom Benutzer bereitgestellte OTP. Es wird mit dem in Redis gespeicherten Wert verglichen, um die Identität des Benutzers zu bestätigen.

3. /login: Diese Route übernimmt die Benutzeranmeldefunktion, sobald das OTP überprüft und der Benutzer erfolgreich erstellt wurde.

Aber bevor wir fortfahren, benötigen wir eine Möglichkeit, Benutzerinformationen wie Telefonnummer und ihr Einmalpasswort zu speichern, für die wir eine Verbindung zu den Diensten herstellen müssen, die wir zuvor in der Datei docker-compose.yml definiert haben.

Hilfsfunktionen definieren

Bevor wir die Routen implementieren, definieren wir zwei wesentliche Hilfsfunktionen. Diese Funktionen verwalten Verbindungen zu den Redis- und PostgreSQL-Servern und stellen so sicher, dass unser Backend mit diesen Diensten interagieren kann.

Ändern Sie die Struktur „config“, um Informationen über die Dienste zu speichern. Diese Funktionen sind ziemlich selbsterklärend.

my-otp-auth-server/
├── cmd/
│   └── api/
│       └── main.go
│       └── user.go
│       └── token.go
├── internal/
│   └── data/
│       ├── models.go
│       └── user.go
│       └── token.go
├── docker-compose.yml
├── go.mod
└── Makefile

Mit diesen Funktionen können Sie eine Verbindung zur PostgreSQL-Datenbank und zum Redis-Server herstellen, nachdem Sie die Dienste mit dem Befehl docker-compose up -d gestartet haben.

Im nächsten Teil beginnen wir mit der Arbeit an den Routen, über die wir zuvor gesprochen haben. So sollte Ihre main.go-Datei jetzt aussehen.

// docker-compose.yml
services:
  postgres:
    image: postgres:13
    container_name: postgres
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: mysecretpassword
      POSTGRES_DB: cheershare
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:6
    container_name: redis
    environment:
      REDIS_PASSWORD: mysecretpassword
    ports:
      - "6379:6379"
    command: ["redis-server", "--requirepass", "mysecretpassword"]

volumes:
  postgres_data:

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