Laksanakan pengesahan dan kebenaran API asas menggunakan Go

Dengan pembangunan aplikasi web yang berterusan, apabila aplikasi secara beransur-ansur menjadi lebih besar dan lebih besar, antara muka API perlu dilindungi untuk menghalang akses rawak, jadi mekanisme pengesahan dan kebenaran API menjadi lebih penting. Dalam artikel ini, kami akan memperkenalkan cara menggunakan Go untuk melaksanakan pengesahan dan kebenaran API asas.

Pertama, mari kita fahami konsep asas pengesahan dan kebenaran:

Pengesahan: Pengesahan ialah mekanisme pengesahan identiti yang digunakan untuk mengesahkan sama ada identiti yang diminta oleh pengguna adalah sah. Dalam aplikasi web, pengesahan boleh melalui nama pengguna dan kata laluan atau menggunakan token seperti JWT.

Keizinan: Keizinan ialah mekanisme pengesahan kebenaran yang digunakan untuk menentukan sama ada pengguna mempunyai hak untuk mengakses sumber yang diminta. Dalam aplikasi web, kebenaran boleh dilakukan melalui kawalan akses berasaskan peranan atau token akses.

Melaksanakan pengesahan dan kebenaran API asas dalam Go boleh dibahagikan kepada langkah berikut:

Langkah 1: Pasang dan konfigurasikan rangka kerja Gin

Sebelum menggunakan rangka kerja Gin, anda perlu memasangnya terlebih dahulu. Kita boleh memasangnya menggunakan arahan berikut:

go get -u github.com/gin-gonic/gin

Selepas pemasangan selesai, kita boleh memulakan rangka kerja Gin menggunakan kod berikut:

import "github.com/gin-gonic/gin"

router := gin.Default()

Langkah 2: Tambah penghalaan

Sebelum kami mula menambah Sebelum penghalaan, anda perlu menentukan fungsi perisian tengah untuk mengesahkan sama ada pengguna itu sah. Fungsi middleware menyemak pengepala permintaan masuk dan mengembalikan kod status dan mesej ralat kepada pengendali.

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 验证用户是否合法
        if userValid {
            c.Set("user", "valid")
            c.Next()
        } else {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
        }
    }
}

Kami boleh menambah fungsi middleware dalam fungsi penghalaan untuk memastikan bahawa hanya pengguna yang disahkan boleh mengakses sumber yang diperlukan.

router.GET("/secured", AuthMiddleware(), func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "You are authorized to access this resource"})
})

Dalam kod di atas, permintaan GET akan dihalakan ke titik akhir /secured, tetapi hanya pengguna yang disahkan akan dapat mengaksesnya dengan jayanya.

Langkah 3: Laksanakan Pengesahan JWT

Kini kami telah menambah laluan dan menggunakan perisian tengah untuk memastikan pengguna disahkan untuk mengakses laluan. Seterusnya, kita akan melihat cara untuk mengesahkan pengguna menggunakan JWT.

JWT ialah token web berasaskan JSON yang menyediakan cara selamat untuk memindahkan maklumat antara pelanggan dan pelayan. JWT biasanya terdiri daripada tiga bahagian: pengepala, muatan dan tandatangan. Pengepala mengandungi jenis token dan algoritma tandatangan, muatan mengandungi data token dan tandatangan digunakan untuk mengesahkan integriti token.

Kami boleh melaksanakan pengesahan JWT dalam Go menggunakan kod berikut:

import (
    "time"

    "github.com/dgrijalva/jwt-go"
)

func CreateToken() (string, error) {
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)
    claims["user"] = "john@example.com"
    claims["exp"] = time.Now().Add(time.Hour * 24).Unix()

    tokenString, err := token.SignedString([]byte("secret"))
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

Dalam kod di atas, kami mula-mula mencipta token JWT dan kemudian menambah tuntutan pengguna bersama-sama dengan masa tamat tempoh. Akhirnya, token ditandatangani dan hasilnya dikembalikan.

Langkah 4: Laksanakan kebenaran berasaskan peranan

Dalam langkah terakhir, kita akan mempelajari cara menggunakan kebenaran berasaskan peranan untuk mengawal akses pengguna kepada sumber.

Dalam kawalan akses berasaskan peranan, pengguna diberikan kepada satu atau lebih peranan dan setiap peranan diberikan satu set kebenaran. Apabila mengakses sumber, pusat kebenaran menentukan sumber yang boleh diakses oleh pengguna berdasarkan peranan mereka.

Kami boleh melaksanakan kebenaran berasaskan peranan mudah menggunakan kod berikut:

func AuthzMiddleware(roles ...string) gin.HandlerFunc {
    return func(c *gin.Context) {
        userRole := "admin" // 从数据库或其他地方获取用户角色

        for _, role := range roles {
            if role == userRole {
                c.Next()
                return
            }
        }

        c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "Forbidden"})
    }
}

Dalam kod di atas, kami mentakrifkan fungsi middleware AuthzMiddleware yang menerima senarai peranan sebagai parameter dan semak sama ada peranan pengguna disertakan. Jika pengguna mempunyai peranan yang diperlukan, lulus perisian tengah dan teruskan ke pengendali seterusnya jika tidak, kembalikan kod status Terlarang.

Akhir sekali, kami boleh menambah fungsi AuthzMiddleware pada laluan untuk memastikan bahawa hanya pengguna dengan peranan tertentu mempunyai akses kepada sumber yang diperlukan.

router.GET("/admin", AuthMiddleware(), AuthzMiddleware("admin"), func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "You are authorized to access this resource"})
})

Di atas ialah langkah asas untuk melaksanakan pengesahan dan kebenaran API asas menggunakan Go. Pelaksanaan asas ini boleh berfungsi sebagai asas untuk aplikasi dan boleh disesuaikan dan diperluaskan lagi mengikut keperluan.

Atas ialah kandungan terperinci Laksanakan pengesahan dan kebenaran API asas menggunakan Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!