Bina Pelayan Pengesahan Berasaskan OTP dengan Go: Bahagian 1

Bermula

Mulakan dengan mencipta folder baharu untuk projek anda dan mulakan modul Go dengan arahan berikut:

pergi mod init github.com/vishaaxl/cheershare

Sediakan Struktur Projek

Mulakan dengan menyediakan projek Go baharu dengan struktur folder berikut:

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

Seterusnya, sediakan fail docker-compose.yml anda. Konfigurasi ini akan menentukan perkhidmatan—PostgreSQL dan Redis—yang akan anda gunakan sepanjang tutorial ini.

Menyediakan Perkhidmatan dengan Docker Compose

Kami akan bermula dengan mengkonfigurasi perkhidmatan yang diperlukan untuk projek kami. Untuk bahagian belakang, kami memerlukan perkara berikut:

• Redis: Kami akan menggunakan imej redis:6. Perkhidmatan ini akan mengkonfigurasi kata laluan untuk akses selamat, mendedahkan port 6379 dan menguatkuasakan pengesahan kata laluan menggunakan bendera --requirepass untuk menjamin akses Redis.

• PostgreSQL: Kami akan menggunakan imej postgres:13. Perkhidmatan ini akan menentukan pengguna lalai, kata laluan dan pangkalan data, mendedahkan port 5432 untuk komunikasi dan data berterusan dengan volum bernama (postgres_data) untuk memastikan ketahanan.

Pilihan:

• Perkhidmatan Bahagian Belakang Utama: Anda boleh mentakrifkan perkhidmatan hujung belakang utama di sini juga, yang akan berinteraksi dengan PostgreSQL dan 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:

Perkhidmatan Bahagian Belakang Utama

Untuk penghalaan dan pengendalian permintaan HTTP, kami akan menggunakan pakej github.com/julienschmidt/httprouter. Untuk memasang kebergantungan, jalankan arahan berikut:

go get github.com/julienschmidt/httprouter

Seterusnya, buat fail di cmd/api/main.go dan tampal kod berikut. Penjelasan untuk setiap baris disediakan dalam ulasan:

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

Sekarang, anda boleh menguji persediaan anda dengan memulakan pelayan menggunakan go run ./cmd/api dan menghantar permintaan ke http://localhost:4000, yang akan mengembalikan mesej alu-aluan. Seterusnya, kami akan mentakrifkan tiga laluan tambahan untuk melaksanakan fungsi teras kami:

1. /send-otp: Laluan ini akan mengendalikan penghantaran OTP kepada pengguna. Ia akan menjana OTP unik, menyimpannya dalam Redis dan menghantarnya kepada pengguna.

2. /verify-otp: Laluan ini akan mengesahkan OTP yang disediakan oleh pengguna. Ia akan menyemak terhadap nilai yang disimpan dalam Redis untuk mengesahkan identiti pengguna.

3. /log masuk: Laluan ini akan mengendalikan fungsi log masuk pengguna setelah OTP disahkan dan pengguna berjaya dibuat.

Tetapi sebelum kami meneruskan, kami memerlukan cara untuk menyimpan maklumat pengguna seperti nombor telefon dan kata laluan sekali mereka yang perlu kami sambungkan ke perkhidmatan yang kami takrifkan sebelum ini dalam fail docker-compose.yml.

Mentakrifkan Fungsi Pembantu

Sebelum melaksanakan laluan, mari tentukan dua fungsi pembantu penting. Fungsi ini akan mengendalikan sambungan ke pelayan Redis dan PostgreSQL, memastikan bahagian belakang kami boleh berinteraksi dengan perkhidmatan ini.

Ubah suai struct 'config' untuk menyimpan maklumat tentang perkhidmatan. Fungsi ini cukup jelas.

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

Anda boleh menggunakan fungsi ini untuk mewujudkan sambungan ke pangkalan data PostgreSQL dan pelayan Redis selepas memulakan perkhidmatan dengan arahan docker-compose up -d.

Dalam bahagian seterusnya, kita akan mula bekerja pada laluan yang kita bincangkan tadi. Beginilah rupa fail main.go anda sekarang.

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

Atas ialah kandungan terperinci Bina Pelayan Pengesahan Berasaskan OTP dengan Go: Bahagian 1. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!