Schritt-für-Schritt-Anleitung zur Implementierung der JWT-Authentifizierung in Go (Golang)

Beim Erstellen des Backends einer Website hören wir einen sehr wichtigen Begriff: JWT-Authentifizierung. Die JWT-Authentifizierung ist eine der beliebtesten Methoden zur Sicherung von APIs. JWT steht für JSON Web Token und ist ein offener Standard, der eine Möglichkeit zur sicheren Übertragung von Informationen zwischen Parteien als JSON-Objekt definiert. In diesem Artikel werden wir die JWT-Authentifizierung besprechen und vor allem ein komplettes Projekt für eine schnelle und effiziente JWT-Authentifizierung mit Gin-Gonic erstellen. Dabei handelt es sich um eine Schritt-für-Schritt-Projektanleitung, die Ihnen dabei hilft, ein sehr schnelles und branchenführendes Projekt zu erstellen -Level-Authentifizierungs-API für das Backend Ihrer Website oder Anwendung.

Inhaltsverzeichnis:

• Was ist JWT-Authentifizierung?
• Projektstruktur
• Voraussetzungen
• Schritt-für-Schritt-Anleitung
• Endgültige Ergebnisse
• Ausgabe
• Fazit

Was ist JWT-Authentifizierung?

JWT steht für JSON Web Token und ist ein offener Standard, der eine Möglichkeit zur sicheren Übertragung von Informationen zwischen Parteien als JSON-Objekt definiert.

Versuchen wir, das anhand eines Beispiels zu verstehen. Stellen Sie sich eine Situation vor, in der wir in einem Hotel ankommen und zur Rezeption gehen und die Rezeptionistin sagt: „Hey, was kann ich für Sie tun?“. Ich würde sagen: „Hallo, mein Name ist Shubham, ich bin wegen einer Konferenz hier, die Sponsoren zahlen für mein Hotel.“ Die Rezeptionistin sagt: „Okay, großartig! Nun, ich muss mir noch ein paar Dinge ansehen.“ Normalerweise müssen sie meinen Ausweis vorlegen, um zu beweisen, wer ich bin. Sobald sie bestätigt haben, dass ich die richtige Person bin, stellen sie mir einen Schlüssel aus. Und die Authentifizierung funktioniert ganz ähnlich wie in diesem Beispiel.

Bei der JWT-Authentifizierung senden wir eine Anfrage an einen Server mit der Aufschrift „Hey! Hier ist mein Benutzername und mein Passwort oder mein Anmeldetoken“ und die Website sagt „Okay, lass mich das überprüfen.“ Wenn mein Benutzername und mein Passwort korrekt sind, erhalte ich ein Token. Bei späteren Anfragen des Servers muss ich nun meinen Benutzernamen und mein Passwort nicht mehr angeben. Ich würde einfach meinen Token mitnehmen und im Hotel einchecken (Website), Zugang zum Fitnessstudio (Daten), ich hätte Zugang zum Pool (Informationen) und nur zu meinem Hotelzimmer (Konto), zu dem ich keinen Zugang habe alle anderen Hotelzimmer (Konto eines anderen Benutzers). Dieser Token ist nur während der Dauer meines Staates autorisiert, also vom Check-in-Zeitpunkt bis zum Check-out-Zeitpunkt. Danach nützt es nichts mehr. Jetzt ermöglicht das Hotel auch Personen ohne Nachweis, das Hotel zumindest zu sehen und sich im öffentlichen Bereich rund um das Hotel zu bewegen, bis Sie das Hotel betreten. Ebenso können Sie als anonymer Benutzer mit der Homepage und der Landingpage der Website interagieren usw.

Hier ist ein Beispiel für ein JWT:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Projektstruktur

Hier ist die Struktur des Projekts. Stellen Sie sicher, dass Sie auch in Ihrem Arbeitsbereich eine ähnliche Ordnerstruktur erstellen. In dieser Struktur haben wir 6 Ordner:

1. Controller
2. Datenbank
3. Helfer
4. Middleware
5. Modelle
6. Routen

und erstellen Sie die entsprechenden Dateien in diesen Ordnern.

Voraussetzungen

1. Go – Version 1.18
2. Mongo DB
3. Schritt-für-Schritt-Anleitung

Schritt 1. Beginnen wir das Projekt mit der Erstellung eines Moduls. Der Name meines Moduls ist „jwt“ und mein Benutzername ist „1shubham7“, daher werde ich mein Modul initialisieren, indem ich Folgendes eingebe:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Dadurch wird eine go.mod-Datei erstellt.

Schritt 2. Erstellen Sie eine main.go-Datei und erstellen Sie einen Webserver in main.go. Fügen Sie dazu den folgenden Code in die Datei ein:

go mod init github.com/1shubham7/jwt

'os'-Paket zum Abrufen von Umgebungsvariablen.
Wir verwenden das Gin-Gonic-Paket, um einen Webserver zu erstellen.
Später werden wir ein Routenpaket erstellen.
AuthRoutes(), UserRoutes() sind Funktionen innerhalb einer Datei aus dem Routenpaket, wir werden sie später erstellen.

Schritt 3. Laden Sie das Gin-Gonic-Paket herunter:

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

Schritt 4. Erstellen Sie einen Modellordner und darin eine userModel.go-Datei. Geben Sie den folgenden Code in userModel.go ein:

go get github.com/gin-gonic/gin

Wir haben eine Struktur namens „Benutzer“ erstellt und der Struktur die erforderlichen Felder hinzugefügt.

json:"Vorname" validieren:"erforderlich, min=2, max=100" Dies werden Feld-Tags genannt, die beim Dekodieren und Kodieren von Go-Code in JSON und JSON to go verwendet werden.
Hier validieren: „erforderlich, min=2, max=100“ Dies wird verwendet, um zu validieren, dass das jeweilige Feld mindestens 2 Zeichen und maximal 100 Zeichen haben muss.

Schritt 5. Erstellen Sie einen Datenbankordner und erstellen Sie darin eine Datei „databaseConnection.go“. Geben Sie darin den folgenden Code ein:

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"`
}

Stellen Sie außerdem sicher, dass Sie das „Mongo“-Paket herunterladen:

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
}

Hier verbinden wir Ihre Mongo-Datenbank mit der Anwendung.

Wir verwenden „godotenv“ zum Laden von Umgebungsvariablen, die wir in der .env-Datei im Hauptverzeichnis festlegen.
Mit der DBinstance-Funktion nehmen wir den Wert „THE_MONGODB_URL“ aus der .env-Datei (wir werden ihn in den nächsten Schritten erstellen) und erstellen einen neuen MongoDB-Client mit dem Wert.
„context“ wird verwendet, um ein Timeout von 10 Sekunden zu haben.
OpenCollection Function() nimmt client und collectionName als Eingabe und erstellt eine Sammlung dafür.

Schritt 6. Für die Routen erstellen wir zwei verschiedene Dateien, authRouter und userRouter. authRouter enthält „/signup“ und „/login“. Diese werden jedem zugänglich gemacht, damit er sich selbst autorisieren kann. userRouter wird nicht für alle öffentlich sein. Es enthält „/users“ und „/users/:user_id“.

Erstellen Sie einen Ordner namens „Routen“ und fügen Sie zwei Dateien hinzu:

• userRouter.go
• authRouter.go

Geben Sie den folgenden Code in userRouter.go ein:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Schritt 7.Geben Sie den folgenden Code in authRouter.go ein:

go mod init github.com/1shubham7/jwt

Schritt 8. Erstellen Sie einen Ordner namens „controllers“ und fügen Sie eine Datei namens „userController.go“ hinzu. Geben Sie darin den folgenden Code ein.

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

Diese beiden Variablen wurden bereits in unserem vorherigen Code verwendet.

Schritt 10. Erstellen wir zunächst die Funktion GetUserById(). Geben Sie den folgenden Code in die Funktion GetUserById() ein:

go get github.com/gin-gonic/gin

Schritt 11. Erstellen wir einen Ordner namens „helpers“ und fügen darin eine Datei namens „authHelper.go“ hinzu. Geben Sie den folgenden Code in authHelper.go ein:

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"`
}

Die Funktion MatchUserTypeToUserId() gleicht nur ab, ob der Benutzer ein Administrator oder nur ein Benutzer ist.
Wir verwenden die CheckUserType()-Funktion innerhalb von MatchUserTypeToUserId(). Dies prüft nur, ob alles in Ordnung ist (ob der Benutzertyp, den wir vom Benutzer erhalten, mit der Benutzertyp-Variablen übereinstimmt.

Schritt 12. Wir können jetzt an der SignUp()-Funktion von userController.go arbeiten:

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
}

• Wir haben einen variablen Benutzer vom Typ Benutzer erstellt.

• validationErr wird verwendet, um die Struktur-Tags zu validieren, wir haben dies bereits besprochen.

• Wir verwenden zur Validierung auch die Zählvariable. Wenn wir beispielsweise bereits Dokumente mit der E-Mail-Adresse des Benutzers finden würden, wäre die Anzahl größer als 0 und wir können diesen Fehler (err) behandeln

• Dann verwenden wir „time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))“, um die Zeit für die Strukturfelder „Created_at“ und „Updated_at“ festzulegen. Wenn der Benutzer versucht, sich anzumelden, wird die Funktion SignUp() ausgeführt und dieser bestimmte Zeitpunkt wird in den Strukturfeldern Created_at und Updated_at gespeichert.

• Dann erstellen wir Token mit der Funktion GenerateAllTokens(), die wir im nächsten Schritt in der Datei tokenHelper.go im selben Paket erstellen werden.

• Wir haben auch eine HashPassword()-Funktion, die nichts anderes tut, als das user.password zu hashen und das user.password durch das gehashte Passwort zu ersetzen. Wir werden das Ding auch später erstellen.

• Und dann fügen wir einfach die Daten und die Token usw. in die userCollection ein

• Wenn alles gut geht, geben wir StatusOK zurück.

Schritt 13. Erstellen Sie eine Datei im Hilfsordner mit dem Namen „tokenHelper.go“ und geben Sie darin den folgenden Code ein.

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

Stellen Sie außerdem sicher, dass Sie das Paket github.com/dgrijalva/jwt-go herunterladen:

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

• Hier verwenden wir github.com/dgrijalva/jwt-go zum Generieren von Token.

• Wir erstellen eine Struktur namens SignedDetails mit Feldnamen, die zum Generieren von Token erforderlich sind.

• Wir verwenden NewWithClaims, um neue Token zu generieren, und geben den Wert an die Strukturen „claims“ und „refreshClaims“ weiter. „claims“ verfügt über ein Token für Benutzer, die es zum ersten Mal verwenden, und „refreshClaims“ hat es, wenn der Benutzer das Token aktualisieren muss. das heißt, sie hatten zuvor einen Token, der jetzt abgelaufen ist.

• time.Now().Local().Add(time.Hour *time.Duration(120)).Unix() wird zum Festlegen des Ablaufs des Tokens verwendet.

• Wir geben dann einfach drei Dinge zurück – Token, RefreshToken und Err, die wir in der SignUp()-Funktion verwenden.

Schritt 14. Erstellen wir in derselben Datei wie die Funktion SignUp() die Funktion HashPassword(), über die wir in Schritt 9 gesprochen haben.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

• Wir verwenden einfach die GenerateFromPassword()-Methode aus dem bcrypt-Paket, die verwendet wird, um gehashte Passwörter aus dem tatsächlichen Passwort zu generieren.

• Dies ist wichtig, da wir nicht möchten, dass ein Hacker in unsere Systeme eindringt und alle Passwörter stiehlt, auch aus Gründen der Privatsphäre der Benutzer.

• []Byte (Array von Bytes) ist einfach eine Zeichenfolge.

Schritt 15. Erstellen wir die Funktion Login() in „userController.go“ und in späteren Schritten können wir die Funktionen erstellen, die Login() verwendet:

go mod init github.com/1shubham7/jwt

• Wir erstellen zwei Variablen vom Typ „Benutzer“, nämlich „user“ und „Founduser“. und Weitergabe der Daten von der Anfrage an den Benutzer.

• Mit Hilfe von „userCollection.FindOne(ctx, bson.M{"email": user.Email}).Decode(&foundUser)“ finden wir den Benutzer über seine E-Mail-Adresse und wenn er gefunden wird, Speichern Sie es in der Variable „foundUser“.

• Dann verwenden wir die Funktion VerifyPassword(), um das Passwort zu überprüfen und zu speichern. Denken Sie daran, dass wir in VerifyPassword() Zeiger als Parameter verwenden. Andernfalls würde eine neue Instanz dieser Zeiger in Parametern erstellt sie tatsächlich ändern.

• Wir werden im nächsten Schritt VerifyPassword() erstellen.

• Dann verwenden wir einfach GenerateAllTokens() und UpdateAllTokens(), um das Token und das RefreshToken (die im Grunde genommen Token sind) zu generieren und zu aktualisieren.

• Und bei jedem Schritt kümmern wir uns alle um die Fehler.

Schritt 16. Erstellen wir die VerifyPassword()-Funktion in derselben Datei wie die Login()-Funktion:

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

• Wir verwenden einfach die Methode CompareHashAndPassword() aus dem bcrypt-Paket, die zum Vergleichen gehashter Passwörter verwendet wird. und abhängig von den Ergebnissen einen booleschen Wert zurückgibt.

• []byte (Array von Bytes) ist einfach eine Zeichenfolge, aber []byte hilft beim Vergleich.

Schritt 17. Erstellen wir die Funktion UpdateAllTokens() in der Datei „tokenHelper.go“:

go get github.com/gin-gonic/gin

• Wir erstellen eine Variable namens updateObj vom Typ primitive.D. Der Typ primitive.D im Go-Treiber von MongoDB ist eine Darstellung eines BSON-Dokuments.

• Append() hängt bei jeder Ausführung ein Schlüssel-Wert-Paar an updateObj an.

• Dann wird „time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))“ verwendet, um die aktuelle Zeit (Zeit, zu der die Aktualisierung erfolgt und die Funktion ausgeführt wird) auf „Updated_at“ zu aktualisieren .

• Der Rest des Codeblocks führt die Aktualisierung mithilfe der UpdateOne-Methode der MongoDB-Sammlung durch.

• Im letzten Schritt behandeln wir auch den Fehler, falls ein Fehler auftritt.

Schritt 18. Bevor wir fortfahren, laden wir das Paket go.mongodb.org/mongo-driver herunter:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Schritt 19. Lassen Sie uns nun an der Funktion GetUserById() arbeiten. Denken Sie daran, dass GetUserById() den Benutzern den Zugriff auf ihre eigenen Informationen ermöglicht. Administratoren können auf alle Benutzerdaten zugreifen, Benutzer können nur auf ihre eigenen zugreifen.

go mod init github.com/1shubham7/jwt

• Die user_id wird aus der Anfrage übernommen und in der userId-Variablen gespeichert.

• Erstellen einer Variablen namens „Benutzer“ vom Typ „Benutzer“. Dann suchen Sie einfach den Benutzer in unserer Datenbank mithilfe der Benutzer-ID. Wenn die Benutzer-ID übereinstimmt, speichern wir die Informationen dieser Person in der Benutzervariablen.

• Wenn alles gut geht, StatusOk

• Wir kümmern uns auch um die Fehler bei jedem Schritt.

Schritt 20. Lassen Sie uns nun an der GetUsers()-Funktion arbeiten. Denken Sie daran, dass nur der Administrator auf die Funktion GetUsers() zugreifen kann, da diese die Daten aller Benutzer enthalten würde. Erstellen Sie eine GetUsers()-Funktion in derselben Datei wie die GetUserById()-, Login()- und SignUp()-Funktion:

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

• Zuerst prüfen wir, ob die Anfrage vom Administrator kommt oder nicht. Dies tun wir mithilfe von CheckUserType(), das wir in den vorherigen Schritten erstellt haben.

• Dann legen wir fest, wie viele Datensätze Sie pro Seite wünschen.

• Das können wir tun, indem wir die recodePerPage aus der Anfrage nehmen und in int konvertieren. Dies erfolgt durch srtconv.

• Wenn beim Festlegen von „recordPerPage“ ein Fehler auftritt oder „recordPerPage“ kleiner als 1 ist, haben wir standardmäßig 9 Datensätze pro Seite

• Ähnlich übernehmen wir die Seitenzahl in der Variablen „Seite“.

• Standardmäßig haben wir die Seitenzahl 1 und 9 recordPerPage.

• Dann haben wir drei Phasen erstellt (matchStage, groupStage, projectStage).

• Dann legen wir diese drei Stufen in unserer Mongo-Pipeline mithilfe der Aggregate()-Funktion fest

• Außerdem kümmern wir uns bei jedem Schritt um Fehler.

Schritt 21. Unser 'userController.go' ist nun fertig, so sieht die Datei 'userController.go' nach Fertigstellung aus:

go get github.com/gin-gonic/gin

Schritt 22. Jetzt können wir am Authentifizierungsteil arbeiten. Dafür erstellen wir eine Authentifizierungs-Middleware. Erstellen Sie einen Ordner mit dem Namen „Middleware“ und erstellen Sie darin eine Datei mit dem Namen „authMiddleware.go“. Geben Sie den folgenden Code in die Datei ein:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Schritt 23. Jetzt erstellen wir die Funktion ValidateToken(). Wir erstellen diese Funktion in „tokenHelper.go“:

go mod init github.com/1shubham7/jwt

• ValidateToken nimmt signiertesToken und gibt SignedDetails davon zusammen mit einer Fehlermeldung zurück. „“ wenn kein Fehler vorliegt.

• Die Funktion ParseWithClaims() wird verwendet, um uns das Token zu besorgen und es in einer Variablen namens token zu speichern.

• Dann prüfen wir, ob der Token korrekt ist oder nicht, indem wir die Claims-Methode für den Token verwenden. Und wir speichern das Ergebnis in der Claims-Variable.

• Dann prüfen wir mit der Funktion ExpiresAt(), ob das Token abgelaufen ist. Wenn die aktuelle Zeit größer als die ExpiresAt-Zeit ist, wäre es abgelaufen.

• Und dann geben Sie einfach die Claims-Variable sowie die Nachricht zurück.

Schritt 24. Wir sind jetzt größtenteils fertig, lasst uns „Go Mod Tidy“ ausführen. Dieser Befehl checkt Ihre go.mod-Datei ein und löscht alle Pakete/Abhängigkeiten, die wir installiert, aber nicht verwendet haben und lädt alle Abhängigkeiten herunter, die wir verwenden, aber noch nicht heruntergeladen haben.

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

Ausgabe

Damit ist unser JWT-Authentifizierungsprojekt fertig. Um die Anwendung endlich auszuführen, geben Sie den folgenden Befehl in das Terminal ein:

go get github.com/gin-gonic/gin

Sie erhalten eine ähnliche Ausgabe:

Dadurch wird der Server in Betrieb genommen und Sie können Curl oder die Postman-API zum Senden von Anfragen und Empfangen von Antworten verwenden. Oder Sie können diese API einfach in ein Frontend-Framework integrieren. Und damit ist unsere Authentifizierungs-API fertig, klopfen Sie sich selbst auf die Schulter!

Abschluss

In diesem Artikel haben wir eine der schnellsten Möglichkeiten zum Erstellen einer JWT-Authentifizierung besprochen. Für unser Projekt haben wir das Gin-Gonic-Framework verwendet. Dies ist nicht Ihre „nur eine weitere Authentifizierungs-API“. Gin ist 300 % schneller als NodeJS, was diese Authentifizierungs-API wirklich schnell und effizient macht. Die von uns verwendete Projektstruktur ist ebenfalls eine Projektstruktur auf Branchenebene. Sie können weitere Änderungen vornehmen, z. B. das Speichern des SECRET_KEY in der .env-Datei und vieles mehr, um diese API zu verbessern. Den Quellcode für dieses Projekt finden Sie auch hier – 1Shubham7/go-jwt-token.

Befolgen Sie unbedingt alle Schritte, um das Projekt zu erstellen und weitere Funktionen hinzuzufügen, und spielen Sie einfach mit dem Code, um ihn besser zu verstehen. Der beste Weg, die Authentifizierung zu erlernen, besteht darin, eigene Projekte zu erstellen.

Das obige ist der detaillierte Inhalt vonSchritt-für-Schritt-Anleitung zur Implementierung der JWT-Authentifizierung in Go (Golang). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!