Créer un serveur d'authentification basé sur OTP avec Go : partie 1

Commencer

Commencez par créer un nouveau dossier pour votre projet et initialisez un module Go avec la commande suivante :

aller mod init github.com/vishaaxl/cheershare

Configurer la structure du projet

Commencez par configurer un nouveau projet Go avec la structure de dossiers suivante :

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

Ensuite, configurez votre fichier docker-compose.yml. Cette configuration définira les services (PostgreSQL et Redis) avec lesquels vous travaillerez tout au long de ce didacticiel.

Configuration des services avec Docker Compose

Nous commencerons par configurer les services requis pour notre projet. Pour le backend, nous avons besoin des éléments suivants :

• Redis : Nous utiliserons l'image redis:6. Ce service configurera un mot de passe pour un accès sécurisé, exposera le port 6379 et appliquera l'authentification par mot de passe à l'aide de l'indicateur --requirepass pour sécuriser l'accès Redis.

• PostgreSQL : Nous utiliserons l'image postgres:13. Le service définira un utilisateur, un mot de passe et une base de données par défaut, exposera le port 5432 pour la communication et conservera les données avec un volume nommé (postgres_data) pour garantir la durabilité.

Facultatif :

• Service backend principal : Vous pouvez également définir ici le service backend principal, qui interagira avec PostgreSQL et Redis.

// 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:

Service back-end principal

Pour le routage et la gestion des requêtes HTTP, nous utiliserons le package github.com/julienschmidt/httprouter. Pour installer la dépendance, exécutez la commande suivante :

go get github.com/julienschmidt/httprouter

Ensuite, créez un fichier sur cmd/api/main.go et collez le code suivant. Une explication pour chaque ligne est fournie dans les commentaires :

//  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)
    }
}

À l'heure actuelle, vous pouvez tester votre configuration en démarrant le serveur en utilisant go run ./cmd/api et en envoyant une requête à http://localhost:4000, qui renverra un message de bienvenue. Ensuite, nous définirons trois itinéraires supplémentaires pour implémenter notre fonctionnalité de base :

1. /send-otp : Cette route gérera l'envoi des OTP aux utilisateurs. Il générera un OTP unique, le stockera dans Redis et le livrera à l'utilisateur.

2. /verify-otp : Cette route vérifiera l'OTP fourni par l'utilisateur. Il vérifiera la valeur stockée dans Redis pour confirmer l'identité de l'utilisateur.

3. /login : Cette route gérera la fonctionnalité de connexion de l'utilisateur une fois l'OTP vérifié et l'utilisateur créé avec succès.

Mais avant de continuer, nous avons besoin d'un moyen de stocker les informations utilisateur telles que le numéro de téléphone et leur mot de passe à usage unique pour lesquels nous devons nous connecter aux services que nous avons définis précédemment dans le fichier docker-compose.yml.

Définir les fonctions d'assistance

Avant d'implémenter les routes, définissons deux fonctions d'assistance essentielles. Ces fonctions géreront les connexions aux serveurs Redis et PostgreSQL, garantissant que notre backend puisse interagir avec ces services.

Modifiez la structure 'config' pour stocker des informations sur les services. Ces fonctions sont assez explicites.

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

Vous pouvez utiliser ces fonctions pour établir une connexion à la base de données PostgreSQL et au serveur Redis après avoir démarré les services avec la commande docker-compose up -d.

Dans la partie suivante, nous commencerons à travailler sur les itinéraires dont nous avons parlé plus tôt. Voici à quoi devrait ressembler votre fichier main.go maintenant.

// 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:

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!