Panduan Langkah demi Langkah untuk Melaksanakan Pengesahan JWT dalam Go (Golang)

Apabila membuat bahagian belakang tapak web, satu istilah yang sangat penting yang kita dapat dengar ialah pengesahan JWT. Pengesahan JWT ialah salah satu cara paling popular untuk mendapatkan API. JWT bermaksud JSON Web Token dan ia adalah standard terbuka yang mentakrifkan cara untuk menghantar maklumat antara pihak sebagai objek JSON dan itu terlalu selamat. Dalam artikel ini, kami akan membincangkan pengesahan JWT dan yang paling penting kami akan membuat keseluruhan projek untuk pengesahan JWT yang Pantas dan Cekap menggunakan Gin-Gonic, ini akan menjadi tutorial projek langkah demi langkah yang akan membantu anda mencipta yang sangat pantas dan industri API pengesahan peringkat untuk tapak web atau bahagian belakang aplikasi anda.

Jadual Kandungan:

• Apakah itu pengesahan JWT?
• Struktur Projek
• Prasyarat
• Tutorial Langkah demi Langkah
• Keputusan Akhir
• Output
• Kesimpulan

Apakah pengesahan JWT?

JWT adalah singkatan kepada JSON Web Token dan ia adalah standard terbuka yang mentakrifkan cara untuk menghantar maklumat antara pihak sebagai objek JSON dan itu terlalu selamat.

Mari kita cuba memahaminya dengan bantuan contoh. Pertimbangkan situasi apabila kami muncul di sebuah hotel dan kami berjalan ke meja depan dan penyambut tetamu berkata "hey, apa yang boleh saya lakukan untuk anda?". Saya akan berkata "Hai, nama saya Shubham, saya di sini untuk persidangan, penaja membayar untuk hotel saya". Penyambut tetamu berkata "okay hebat! baik saya perlu melihat beberapa perkara". Biasanya mereka perlu melihat pengenalan saya supaya untuk membuktikan siapa saya dan sebaik sahaja mereka mengesahkan bahawa saya adalah orang yang betul, mereka akan mengeluarkan kunci kepada saya. Dan pengesahan berfungsi dengan cara yang hampir serupa dengan contoh ini.

Dengan pengesahan JWT, kami membuat permintaan kepada pelayan yang mengatakan "Hei! ini nama pengguna dan kata laluan saya atau token log masuk adalah ini" dan tapak web berkata "okay, biar saya semak." Jika nama pengguna dan kata laluan saya betul maka itu akan memberi saya token. Sekarang atas permintaan pelayan yang berikutnya, saya tidak perlu lagi memasukkan nama pengguna dan kata laluan saya. Saya hanya akan membawa token saya dan mendaftar masuk ke hotel (laman web), akses kepada Gim (data), saya akan mempunyai akses kepada kolam (maklumat) dan hanya ke bilik hotel saya (akaun), saya tidak mempunyai akses kepada mana-mana bilik hotel lain (akaun pengguna lain). Token ini hanya dibenarkan sepanjang tempoh negeri saya jadi dari masa daftar masuk hingga masa daftar keluar. Selepas itu ia tidak berguna. Kini hotel juga akan membenarkan orang ramai tanpa sebarang pengesahan untuk sekurang-kurangnya melihat hotel, untuk berkeliaran di kawasan awam di sekitar hotel sehingga anda masuk ke dalam hotel, Begitu juga sebagai pengguna tanpa nama anda boleh berinteraksi dengan halaman utama tapak web, halaman pendaratan , dsb.

Berikut ialah contoh JWT :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Struktur Projek

Berikut ialah struktur projek. Pastikan anda membuat struktur folder yang serupa dalam ruang kerja anda juga. Dalam struktur ini kami mempunyai 6 folder:

1. pengawal
2. pangkalan data
3. pembantu
4. perisian tengah
5. model
6. laluan

dan buat fail masing-masing di dalam folder ini.

Prasyarat

1. Go - Versi 1.18
2. Mongo DB
3. Tutorial Langkah demi Langkah

Langkah 1. Mari mulakan projek dengan mencipta modul, nama modul saya ialah "jwt" dan nama pengguna saya ialah "1shubham7", oleh itu saya akan memulakan modul saya dengan memasukkan:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Ini akan mencipta fail go.mod.

Langkah 2. Cipta fail main.go dan mari buat pelayan web dalam main.go. Untuk itu, tambahkan kod berikut dalam fail:

go mod init github.com/1shubham7/jwt

pakej 'os' untuk mendapatkan semula pembolehubah persekitaran.
kami menggunakan pakej gin-gonic untuk mencipta pelayan web.
Nanti kita buat pakej route.
AuthRoutes(), UserRoutes() ialah fungsi di dalam fail daripada pakej route, kami akan menciptanya kemudian.

Langkah 3. Muat turun pakej gin-gonic:

package main
import(
    "github.com/gin-gonic/gin"
    "os"
    routes "github.com/1shubham7/jwt/routes"
    "github.com/joho/godotenv"
    "log"
)
func main() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    port := os.Getenv("PORT")
    if port == "" {
        port = "1111"
    }
    router := gin.New()
    router.Use(gin.Logger())
    routes.AuthRoutes(router)
    routes.UserRoutes(router)
    // creating two APIs
    router.GET("/api-1", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-1"})
    })
    router.GET("api-2", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-2"})
    })
    router.Run(":" + port)
}

Langkah 4. Cipta folder model dan di dalamnya buat fail userModel.go. Masukkan kod berikut di dalam userModel.go:

go get github.com/gin-gonic/gin

Kami telah mencipta struct dipanggil Pengguna dan telah menambah medan yang diperlukan pada struct.

json:"first_name" validate:"required, min=2, max=100" ini dipanggil teg medan, ini digunakan semasa penyahkodan dan pengekodan kod go kepada JSON dan JSON untuk pergi.
Di sini sahkan:"diperlukan, min=2, max=100" ini digunakan untuk mengesahkan bahawa medan tertentu mesti mempunyai minimum 2 aksara dan maksimum 100 aksara.

Langkah 5. Cipta folder pangkalan data dan di dalamnya buat fail databaseConnection.go, masukkan kod berikut di dalamnya:

package models
import (
    "go.mongodb.org/mongo-driver/bson/primitive"
    "time"
)
type User struct {
    ID            primitive.ObjectID `bson:"id"`
    First_name    *string            `json:"first_name" validate:"required, min=2, max=100"`
    Last_name     *string            `json:"last_name" validate:"required, min=2, max=100"`
    Password      *string            `json:"password" validate:"required, min=6"`
    Email         *string            `json:"email" validate:"email, required"` //validate email means it should have an @
    Phone         *string            `json:"phone" validate:"required"`
    Token         *string            `json:"token"`
    User_type     *string            `json:"user_type" validate:"required, eq=ADMIN|eq=USER"`
    Refresh_token *string            `json:"refresh_token"`
    Created_at    time.Time          `json:"created_at"`
    Updated_at    time.Time          `json:"updated_at"`
    User_id       string             `json:"user_id"`
}

juga pastikan anda memuat turun pakej 'mongo':

package database
import (
    "fmt"
    "log"
    "os"
    "time"
    "context"
    "github.com/joho/godotenv"
    "go.mongodb.org/mongo-driver/mongo"
    "go/mongodb.org/mongo-driver/mongo/options"
)
func DBinstance() *mongo.Client{
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    MongoDb := os.Getenv("THE_MONGODB_URL")
    client, err := mongo.NewClient(options.Client().ApplyURI(MongoDb))
    if err != nil {
        log.Fatal(err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    err = client.Connect(ctx)
    if err!=nil{
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!!")
    return client
}
var Client *mongo.Client = DBinstance()
func OpenCollection(client *mongo.Client, collectionName string) *mongo.Collection {
    var collection *mongo.Collection = client.Database("cluster0").Collection(collectionName)
    return collection
}

Di sini kami menyambungkan pangkalan data mongo anda dengan aplikasi.

kami menggunakan 'godotenv' untuk memuatkan pembolehubah persekitaran yang akan kami tetapkan dalam fail .env dalam direktori utama.
Fungsi DInstance, kami mengambil nilai "THE_MONGODB_URL" daripada fail .env (kami akan menciptanya dalam langkah yang akan datang) dan mencipta klien mongoDB baharu menggunakan nilai tersebut.
'konteks' digunakan untuk mempunyai tamat masa selama 10 saat.
OpenCollection Function() mengambil klien dan collectionName sebagai input dan mencipta koleksi untuknya.

Langkah 6. Untuk laluan, kami akan mencipta dua fail berbeza, authRouter dan userRouter. authRouter termasuk '/signup' dan '/login' . Ini akan terbuka kepada semua orang supaya mereka boleh membenarkan diri mereka sendiri. userRouter tidak akan terbuka kepada semua orang. Ia akan termasuk '/users' dan '/users/:user_id'.

Buat folder yang dipanggil laluan dan tambah dua fail ke dalamnya:

• userRouter.go
• authRouter.go

masukkan kod berikut ke dalam userRouter.go:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Langkah 7. masukkan kod berikut ke dalam authRouter.go:

go mod init github.com/1shubham7/jwt

Langkah 8. buat folder yang dipanggil pengawal dan tambahkan fail yang dipanggil 'userController.go' padanya. masukkan kod berikut di dalamnya.

package main
import(
    "github.com/gin-gonic/gin"
    "os"
    routes "github.com/1shubham7/jwt/routes"
    "github.com/joho/godotenv"
    "log"
)
func main() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    port := os.Getenv("PORT")
    if port == "" {
        port = "1111"
    }
    router := gin.New()
    router.Use(gin.Logger())
    routes.AuthRoutes(router)
    routes.UserRoutes(router)
    // creating two APIs
    router.GET("/api-1", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-1"})
    })
    router.GET("api-2", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-2"})
    })
    router.Run(":" + port)
}

Dua pembolehubah ini telah pun digunakan dalam kod kami sebelum ini.

Langkah 10. Mari buat fungsi GetUserById() dahulu. Masukkan kod berikut dalam fungsi GetUserById():

go get github.com/gin-gonic/gin

Langkah 11. Mari buat folder yang dipanggil helpers dan tambahkan fail bernama authHelper.go ke dalamnya. Masukkan kod berikut ke dalam authHelper.go :

package models
import (
    "go.mongodb.org/mongo-driver/bson/primitive"
    "time"
)
type User struct {
    ID            primitive.ObjectID `bson:"id"`
    First_name    *string            `json:"first_name" validate:"required, min=2, max=100"`
    Last_name     *string            `json:"last_name" validate:"required, min=2, max=100"`
    Password      *string            `json:"password" validate:"required, min=6"`
    Email         *string            `json:"email" validate:"email, required"` //validate email means it should have an @
    Phone         *string            `json:"phone" validate:"required"`
    Token         *string            `json:"token"`
    User_type     *string            `json:"user_type" validate:"required, eq=ADMIN|eq=USER"`
    Refresh_token *string            `json:"refresh_token"`
    Created_at    time.Time          `json:"created_at"`
    Updated_at    time.Time          `json:"updated_at"`
    User_id       string             `json:"user_id"`
}

Fungsi MatchUserTypeToUserId() hanya sepadan jika pengguna ialah Pentadbir atau hanya pengguna.
Kami menggunakan fungsi CheckUserType() di dalam MatchUserTypeToUserId(), ini hanya menyemak sama ada semuanya baik-baik saja (jika user_type yang kami dapat daripada pengguna adalah sama dengan pembolehubah jenis pengguna.

Langkah 12. Kini kami boleh mengusahakan fungsi SignUp() userController.go:

package database
import (
    "fmt"
    "log"
    "os"
    "time"
    "context"
    "github.com/joho/godotenv"
    "go.mongodb.org/mongo-driver/mongo"
    "go/mongodb.org/mongo-driver/mongo/options"
)
func DBinstance() *mongo.Client{
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    MongoDb := os.Getenv("THE_MONGODB_URL")
    client, err := mongo.NewClient(options.Client().ApplyURI(MongoDb))
    if err != nil {
        log.Fatal(err)
    }
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    err = client.Connect(ctx)
    if err!=nil{
        log.Fatal(err)
    }
    fmt.Println("Connected to MongoDB!!")
    return client
}
var Client *mongo.Client = DBinstance()
func OpenCollection(client *mongo.Client, collectionName string) *mongo.Collection {
    var collection *mongo.Collection = client.Database("cluster0").Collection(collectionName)
    return collection
}

• Kami mencipta pengguna boleh ubah jenis Pengguna.

• validationErr digunakan untuk mengesahkan tag struct, kami telah membincangkan perkara ini.

• Kami juga menggunakan pembolehubah kiraan untuk mengesahkan. Seperti jika kita menjumpai dokumen dengan e-mel pengguna sudah pun, maka kiraan akan menjadi lebih daripada 0, dan kita boleh menangani ralat itu (err)

• Kemudian kami menggunakan 'time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))' untuk menetapkan masa untuk Created_at, Updated_at struct fields. Apabila pengguna cuba mendaftar, fungsi SignUp() akan dijalankan dan masa tertentu akan disimpan dalam medan struct Created_at, Updated_at.

• Kemudian kami mencipta token menggunakan fungsi GenerateAllTokens() yang akan kami cipta dalam fail tokenHelper.go dalam pakej yang sama dalam langkah seterusnya.

• Kami juga mempunyai fungsi HashPassword() yang tidak melakukan apa-apa selain pencincangan pengguna.kata laluan dan menggantikan pengguna.kata laluan dengan kata laluan yang dicincang. Kami juga akan membuat perkara itu nanti.

• Dan kemudian kami hanya memasukkan data dan token dsb. ke userCollection

• Jika semuanya berjalan lancar, kami akan mengembalikan StatusOK.

Langkah 13. buat fail dalam folder helpers yang dipanggil 'tokenHelper.go' dan masukkan kod berikut di dalamnya.

go get go.mongodb.org/mongo-driver/mongo

Juga pastikan anda memuat turun pakej github.com/dgrijalva/jwt-go:

package routes
import (
    "github.com/gin-gonic/gin"
    controllers "github.com/1shubham7/jwt/controllers"
    middleware "github.com/1shubham7/jwt/middleware"
)
// user should not be able to use userRoute without the token
func UserRoutes (incomingRoutes *gin.Engine) {
    incomingRoutes.Use(middleware.Authenticate())
    // user routes are public routes but these must be authenticated, that
    // is why we have Authenticate() before these
    incomingRoutes.GET("/users", controllers.GetUsers())
    incomingRoutes.GET("users/:user_id", controllers.GetUserById())
}

• Di sini kami menggunakan github.com/dgrijalva/jwt-go untuk menjana token.

• Kami sedang mencipta struct yang dipanggil SignedDetails dengan nama medan yang diperlukan untuk menjana token.

• kami menggunakan NewWithClaims untuk menjana token baharu dan memberikan nilai kepada tuntutan dan menyegarkan semula struktur Tuntutan. claims mempunyai token buat kali pertama pengguna dan refreshClaims memilikinya apabila pengguna perlu memuat semula token. iaitu, mereka sebelum ini mempunyai token yang kini tamat tempoh.

• masa.Sekarang().Tempatan().Tambah(masa.Jam *masa.Tempoh(120)).Unix() sedang digunakan untuk menetapkan tamat tempoh token.

• kami kemudian hanya mengembalikan tiga perkara - token, refreshToken dan err yang kami gunakan dalam fungsi SignUp().

Langkah 14. Dalam fail yang sama dengan fungsi SignUp(), mari buat fungsi HashPassword() yang kita bincangkan dalam langkah 9.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

• Kami hanya menggunakan kaedah GenerateFromPassword() daripada pakej bcrypt yang digunakan untuk menjana kata laluan cincang daripada kata laluan sebenar.

• Ini penting kerana kami tidak mahu dan penggodam menggodam sistem kami dan mencuri semua kata laluan, juga untuk privasi pengguna.

• []bait (susun bait) hanyalah rentetan.

Langkah 15. Mari kita cipta fungsi Log Masuk() dalam 'userController.go' dan dalam langkah seterusnya kita boleh mencipta fungsi yang Log Masuk() gunakan:

go mod init github.com/1shubham7/jwt

• Kami sedang mencipta dua pembolehubah jenis Pengguna, ini ialah pengguna dan Pengasas. dan memberikan data daripada permintaan kepada pengguna.

• Dengan bantuan 'userCollection.FindOne(ctx, bson.M{"email": user.Email}).Decode(&foundUser)' kami mencari pengguna melalui e-melnya dan jika ditemui, menyimpannya dalam pembolehubah foundUser.

• Kemudian kami menggunakan fungsi VerifyPassword() untuk mengesahkan kata laluan dan menyimpannya, ingat bahawa kami mengambil penunjuk sebagai parameter dalam VerifyPassword(), jika tidak, ia akan mencipta contoh baharu bagi mereka dalam parameter dan bukannya sebenarnya mengubahnya.

• Kami akan membuat VerifyPassword() dalam langkah seterusnya.

• Kemudian kami hanya menggunakan GenerateAllTokens() dan UpdateAllTokens() untuk menjana dan mengemas kini token dan refreshToken (yang pada asasnya adalah token).

• Dan setiap langkah, kita semua mengendalikan ralat.

Langkah 16. Mari buat fungsi VerifyPassword() dalam fail yang sama dengan fungsi Log Masuk():

package main
import(
    "github.com/gin-gonic/gin"
    "os"
    routes "github.com/1shubham7/jwt/routes"
    "github.com/joho/godotenv"
    "log"
)
func main() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    port := os.Getenv("PORT")
    if port == "" {
        port = "1111"
    }
    router := gin.New()
    router.Use(gin.Logger())
    routes.AuthRoutes(router)
    routes.UserRoutes(router)
    // creating two APIs
    router.GET("/api-1", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-1"})
    })
    router.GET("api-2", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-2"})
    })
    router.Run(":" + port)
}

• Kami hanya menggunakan kaedah CompareHashAndPassword() daripada pakej bcrypt yang digunakan untuk membandingkan kata laluan yang dicincang. dan mengembalikan nilai boolean bergantung pada keputusan.

• []bait (tatasusunan bait) hanyalah rentetan, tetapi []bait membantu dalam membandingkan.

Langkah 17. Mari buat fungsi UpdateAllTokens() dalam fail 'tokenHelper.go':

go get github.com/gin-gonic/gin

• Kami sedang mencipta pembolehubah yang dipanggil updateObj yang jenis primitif.D. jenis primitif.D dalam pemacu Go MongoDB ialah perwakilan dokumen BSON.

• Append() sedang menambahkan pasangan nilai kunci untuk mengemas kiniObj setiap kali ia dijalankan.

• Kemudian 'time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))' digunakan untuk mengemas kini masa semasa (masa apabila pengemaskinian berlaku dan fungsi berjalan) ke Updated_at .

• Selebihnya blok kod sedang melakukan kemas kini menggunakan kaedah UpdateOne koleksi mongoDB.

• Pada langkah terakhir kami juga mengendalikan ralat sekiranya sebarang ralat berlaku.

Langkah 18. Sebelum meneruskan, mari muat turun pakej go.mongodb.org/mongo-driver:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Langkah 19. Sekarang mari kita gunakan fungsi GetUserById(). Ingat bahawa GetUserById() adalah untuk pengguna mengakses maklumat sendiri di sana, Pentadbir boleh mengakses semua data pengguna, pengguna hanya boleh mengakses data mereka.

go mod init github.com/1shubham7/jwt

• Mengambil user_id daripada permintaan dan menyimpannya dalam pembolehubah userId.

• membuat pembolehubah yang dipanggil pengguna jenis Pengguna. kemudian hanya mencari pengguna dalam pangkalan data kami dengan bantuan user_id, jika user_id sepadan, kami akan menyimpan maklumat orang tersebut dalam pembolehubah pengguna.

• Jika semuanya berjalan lancar, StatusOk

• kami juga mengendalikan ralat pada setiap langkah.

Langkah 20. Sekarang mari kita gunakan fungsi GetUsers(). Ingat bahawa hanya pentadbir boleh mengakses fungsi GetUsers() kerana ia akan memasukkan data semua pengguna. Cipta fungsi GetUsers() dalam fail yang sama seperti fungsi GetUserById(), Login() dan SignUp():

package main
import(
    "github.com/gin-gonic/gin"
    "os"
    routes "github.com/1shubham7/jwt/routes"
    "github.com/joho/godotenv"
    "log"
)
func main() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    port := os.Getenv("PORT")
    if port == "" {
        port = "1111"
    }
    router := gin.New()
    router.Use(gin.Logger())
    routes.AuthRoutes(router)
    routes.UserRoutes(router)
    // creating two APIs
    router.GET("/api-1", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-1"})
    })
    router.GET("api-2", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-2"})
    })
    router.Run(":" + port)
}

• Pertama sekali, kami akan menyemak sama ada permintaan itu datang daripada pentadbir atau tidak, kami melakukannya dengan bantuan CheckUserType() yang kami buat dalam langkah sebelumnya.

• Kemudian kami menetapkan berapa banyak rekod yang anda mahukan setiap halaman.

• Kita boleh melakukannya dengan mengambil recodePerPage daripada permintaan dan menukarnya kepada int, ini dilakukan oleh srtconv.

• Jika sebarang ralat berlaku dalam menetapkan recordPerPage atau recordPerPage kurang daripada 1, secara lalai kami akan mempunyai 9 rekod setiap halaman

• Begitu juga kami mengambil nombor halaman dalam 'halaman' berubah-ubah.

• Secara lalai kami akan mempunyai nombor halaman sebagai 1 dan 9 recordPerPage.

• Kemudian kami mencipta tiga peringkat (matchStage, groupStage, projectStage).

• Kemudian kami menetapkan tiga peringkat ini dalam saluran paip Mongo kami menggunakan fungsi Aggregate()

• Juga kami mengendalikan ralat setiap langkah.

Langkah 21. 'userController.go' kami kini sedia, beginilah rupa fail 'userController.go' selepas selesai:

go get github.com/gin-gonic/gin

Langkah 22. Kini kita boleh mengusahakan bahagian pengesahan. Untuk itu kami akan mencipta middleware yang sahih. Cipta folder bernama 'middleware' dan buat fail di dalamnya yang dipanggil 'authMiddleware.go'. Masukkan kod berikut dalam fail:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Langkah 23. Sekarang mari kita buat fungsi ValidateToken(), kita akan buat fungsi ini dalam 'tokenHelper.go':

go mod init github.com/1shubham7/jwt

• ValidateToken mengambil signedToken dan mengembalikan SignedDetails itu bersama-sama dengan mesej ralat. "" jika tiada ralat.

• Fungsi ParseWithClaims() sedang digunakan untuk mendapatkan kami token dan menyimpannya dalam pembolehubah yang dipanggil token.

• Kemudian kami menyemak sama ada token itu betul atau tidak menggunakan kaedah Tuntutan pada token. Dan kami menyimpan hasilnya dalam pembolehubah tuntutan.

• Kemudian kami menyemak sama ada token telah tamat tempoh menggunakan fungsi ExpiresAt(), jika masa semasa lebih besar daripada masa ExpiresAt, ia akan tamat tempoh.

• Dan kemudian hanya kembalikan pembolehubah tuntutan serta mesej.

Langkah 24. Kami hampir selesai sekarang, mari lakukan 'go mod tidy', arahan ini menyemak dalam fail go.mod anda, ia memadam semua pakej/pergantungan yang kami pasang tetapi tidak digunakan dan memuat turun sebarang kebergantungan yang kami gunakan tetapi belum dimuat turun.

package main
import(
    "github.com/gin-gonic/gin"
    "os"
    routes "github.com/1shubham7/jwt/routes"
    "github.com/joho/godotenv"
    "log"
)
func main() {
    err := godotenv.Load(".env")
    if err != nil {
        log.Fatal("Error locading the .env file")
    }
    port := os.Getenv("PORT")
    if port == "" {
        port = "1111"
    }
    router := gin.New()
    router.Use(gin.Logger())
    routes.AuthRoutes(router)
    routes.UserRoutes(router)
    // creating two APIs
    router.GET("/api-1", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-1"})
    })
    router.GET("api-2", func(c *gin.Context){
        c.JSON(200, gin.H{"success":"Access granted for api-2"})
    })
    router.Run(":" + port)
}

Output

Dengan itu projek pengesahan JWT kami sedia, untuk akhirnya menjalankan aplikasi masukkan arahan berikut dalam terminal:

go get github.com/gin-gonic/gin

Anda akan mendapat output yang serupa:

Ini akan membolehkan pelayan beroperasi dan berjalan, dan anda boleh menggunakan API curl atau Postman untuk menghantar permintaan dan menerima respons. Atau anda boleh menyepadukan API ini dengan rangka kerja bahagian hadapan. Dan dengan itu, API pengesahan kami sedia, tepuk belakang anda!

Kesimpulan

Dalam artikel ini kami membincangkan salah satu cara terpantas untuk mencipta pengesahan JWT, kami menggunakan rangka kerja Gin-Gonic untuk projek kami. Ini bukan "API pengesahan lain" anda. Gin adalah 300% lebih pantas daripada NodeJS, yang menjadikan API pengesahan ini sangat pantas dan cekap. Struktur projek yang kami gunakan juga merupakan struktur projek peringkat industri. Anda boleh membuat perubahan selanjutnya seperti menyimpan SECRET_KEY dalam fail .env dan banyak lagi untuk menjadikan API ini lebih baik. Anda juga boleh mencari kod sumber untuk projek ini di sini - 1Shubham7/go-jwt-token.

Pastikan anda mengikuti semua langkah untuk membuat projek dan menambah beberapa lagi fungsi dan hanya bermain dengan kod untuk memahaminya dengan lebih baik. Cara terbaik untuk mempelajari pengesahan adalah dengan mencipta projek anda sendiri.

Atas ialah kandungan terperinci Panduan Langkah demi Langkah untuk Melaksanakan Pengesahan JWT dalam Go (Golang). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!