Guide étape par étape pour implémenter l'authentification JWT dans Go (Golang)

Lors de la création du backend d'un site Web, un terme très important que nous entendons est l'authentification JWT. L'authentification JWT est l'un des moyens les plus populaires de sécuriser les API. JWT signifie JSON Web Token et c'est un standard ouvert qui définit un moyen de transmettre des informations entre les parties en tant qu'objet JSON et cela de manière trop sécurisée. Dans cet article, nous discuterons de l'authentification JWT et, plus important encore, nous créerons un projet complet pour une authentification JWT rapide et efficace à l'aide de Gin-Gonic. Il s'agira d'un didacticiel de projet étape par étape qui vous aidera à créer un projet très rapide et industriel. API d'authentification de niveau supérieur pour le backend de votre site Web ou de votre application.

Table des matières :

• Qu'est-ce que l'authentification JWT ?
• Structure du projet
• Prérequis
• Tutoriel étape par étape
• Résultats finaux
• Sortie
• Conclusion

Qu'est-ce que l'authentification JWT ?

JWT signifie JSON Web Token et c'est un standard ouvert qui définit un moyen de transmettre des informations entre les parties en tant qu'objet JSON et cela de manière trop sécurisée.

Essayons de comprendre cela à l'aide d'un exemple. Prenons l'exemple d'une situation où nous nous présentons dans un hôtel, où nous nous dirigeons vers la réception et où le réceptionniste nous dit « hé, que puis-je faire pour vous ? ». Je dirais "Bonjour, je m'appelle Shubham, je suis ici pour une conférence, les sponsors paient mon hôtel". Le réceptionniste dit "d'accord, super ! eh bien, je vais avoir besoin de voir quelques choses". Habituellement, ils auront besoin de voir ma pièce d'identité afin de prouver qui je suis et une fois qu'ils auront vérifié que je suis la bonne personne, ils me remettront une clé. Et l'authentification fonctionne d'une manière très similaire à cet exemple.

Avec l'authentification JWT, nous envoyons une requête à un serveur disant "Hé ! Voici mon nom d'utilisateur et mon mot de passe ou mon jeton de connexion, c'est ça" et le site Web dit "d'accord, laissez-moi vérifier". Si mon nom d'utilisateur et mon mot de passe sont corrects, cela me donnera un jeton. Désormais, lors des requêtes ultérieures du serveur, je n'ai plus besoin d'inclure mon nom d'utilisateur et mon mot de passe. Je porterais simplement mon token et m'enregistrerais à l'hôtel (site web), j'aurais accès à la salle de sport (données), j'aurais accès à la piscine (informations) et uniquement à ma chambre d'hôtel (compte), je n'ai pas accès à toute autre chambre d'hôtel (compte d'un autre utilisateur). Ce token n'est autorisé que pendant la durée de mon état donc depuis l'heure d'arrivée jusqu'à l'heure de départ. Après cela ne sert à rien. Désormais, l'hôtel permettra également aux personnes sans aucune vérification de voir au moins l'hôtel, de se déplacer dans les zones publiques autour de l'hôtel jusqu'à ce que vous entriez à l'intérieur de l'hôtel. De même, en tant qu'utilisateur anonyme, vous pouvez interagir avec la page d'accueil du site Web et la page de destination. , etc.

Voici un exemple de JWT :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Structure du projet

Voici la structure du projet. Assurez-vous également de créer une structure de dossiers similaire dans votre espace de travail. Dans cette structure nous avons 6 dossiers :

1. contrôleurs
2. base de données
3. aides
4. intergiciel
5. modèles
6. itinéraires

et créez les fichiers respectifs dans ces dossiers.

Conditions préalables

1. Go - Version 1.18
2. Mongo DB
3. Tutoriel étape par étape

Étape 1. Commençons le projet en créant un module, le nom de mon module est "jwt" et mon nom d'utilisateur est "1shubham7", je vais donc parapher mon module en saisissant :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Cela créera un fichier go.mod.

Étape 2. Créez un fichier main.go et créons un serveur Web dans main.go. Pour cela, ajoutez le code suivant dans le fichier :

go mod init github.com/1shubham7/jwt

Package 'os' pour récupérer les variables d'environnement.
nous utilisons le package gin-gonic pour créer un serveur Web.
Plus tard, nous créerons un package d'itinéraires.
AuthRoutes(), UserRoutes() sont des fonctions à l'intérieur d'un fichier du package routes, nous le créerons plus tard.

Étape 3. Téléchargez le package 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)
}

Étape 4. Créez un dossier de modèles et à l'intérieur, créez un fichier userModel.go. Entrez le code suivant dans userModel.go :

go get github.com/gin-gonic/gin

Nous avons créé une structure appelée User et avons ajouté les champs nécessaires à la structure.

json:"first_name" validate:"required, min=2, max=100" ce sont ce qu'on appelle des balises de champ, elles sont utilisées lors du décodage et de l'encodage du code go en JSON et JSON to go.
Validez ici : "obligatoire, min=2, max=100" ceci est utilisé pour valider que le champ particulier doit avoir au minimum 2 caractères et au maximum 100 caractères.

Étape 5. Créez un dossier de base de données et à l'intérieur, créez un fichier databaseConnection.go, entrez le code suivant à l'intérieur :

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

assurez-vous également de télécharger le package '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
}

Ici, nous connectons votre base de données mongo à l'application.

nous utilisons 'godotenv' pour charger les variables d'environnement que nous définirons dans le fichier .env du répertoire principal.
La fonction DBinstance, nous prenons la valeur de "THE_MONGODB_URL" du fichier .env (nous le créerons dans les étapes à venir) et créons un nouveau client mongoDB en utilisant la valeur.
'context' est utilisé pour avoir un délai d'attente de 10 secondes.
OpenCollection Function() prend le client et collectionName en entrée et crée une collection pour cela.

Étape 6. Pour les routes, nous allons créer deux fichiers différents, authRouter et userRouter. authRouter inclut '/signup' et '/login' . Ceux-ci seront publics pour que chacun puisse s'autoriser. userRouter ne sera pas public pour tout le monde. Il comprendra '/users' et '/users/:user_id'.

Créez un dossier appelé routes et ajoutez-y deux fichiers :

• userRouter.go
• authRouter.go

entrez le code suivant dans userRouter.go :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Étape 7. entrez le code suivant dans authRouter.go :

go mod init github.com/1shubham7/jwt

Étape 8. créez un dossier appelé contrôleurs et ajoutez-y un fichier appelé « userController.go ». entrez le code suivant à l'intérieur.

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

Ces deux variables ont déjà été utilisées dans notre code précédent.

Étape 10. Créons d'abord la fonction GetUserById(). Entrez le code suivant dans la fonction GetUserById() :

go get github.com/gin-gonic/gin

Étape 11. Créons un dossier appelé helpers et ajoutons-y un fichier appelé authHelper.go. Entrez le code suivant dans 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"`
}

La fonction MatchUserTypeToUserId() correspond uniquement si l'utilisateur est un administrateur ou simplement un utilisateur.
Nous utilisons la fonction CheckUserType() dans MatchUserTypeToUserId(), il s'agit simplement de vérifier si tout va bien (si le type d'utilisateur que nous obtenons de l'utilisateur est le même que la variable userType.

Étape 12. Nous pouvons maintenant travailler sur la fonction SignUp() de 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
}

• Nous avons créé un utilisateur variable de type Utilisateur.

• validationErr est utilisé pour valider les balises struct, nous en avons déjà parlé.

• Nous utilisons également la variable count pour valider. Comme si nous trouvions déjà des documents avec l'e-mail de l'utilisateur, le nombre serait supérieur à 0, et nous pouvons alors gérer cette erreur (err)

• Ensuite, nous utilisons 'time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))' pour définir l'heure des champs de structure Created_at, Updated_at. Lorsque l'utilisateur essaie de s'inscrire, la fonction SignUp() s'exécutera et cette heure particulière sera stockée dans les champs de structure Created_at, Updated_at.

• Ensuite, nous créons des jetons à l'aide de la fonction GenerateAllTokens() que nous créerons dans le fichier tokenHelper.go dans le même package à l'étape suivante.

• Nous avons également une fonction HashPassword() qui ne fait rien d'autre que hacher le user.password et remplacer le user.password par le mot de passe haché. Nous créerons également cette chose plus tard.

• Et puis nous insérons simplement les données et les jetons, etc. dans la userCollection

• Si tout se passe bien, nous vous rendrons StatusOK.

Étape 13. créez un fichier dans le dossier helpers appelé « tokenHelper.go » et entrez le code suivant à l'intérieur.

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

Assurez-vous également de télécharger le package 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())
}

• Ici, nous utilisons github.com/dgrijalva/jwt-go pour générer des jetons.

• Nous créons une structure appelée SignedDetails avec les noms de champs requis pour générer des jetons.

• nous utilisons NewWithClaims pour générer de nouveaux jetons et donnons la valeur aux structures claims et rafraîchirClaims. Claims a un jeton pour la première fois et rafraîchitClaims l'a lorsque l'utilisateur doit actualiser le jeton. c'est-à-dire qu'ils avaient auparavant un jeton qui est maintenant expiré.

• time.Now().Local().Add(time.Hour *time.Duration(120)).Unix() est utilisé pour définir l'expiration du jeton.

• nous renvoyons alors simplement trois choses - token, rafraîchirToken et err que nous utilisons dans la fonction SignUp().

Étape 14. Dans le même fichier que la fonction SignUp(), créons la fonction HashPassword() dont nous avons parlé à l'étape 9.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

• Nous utilisons simplement la méthode GenerateFromPassword() du package bcrypt qui est utilisée pour générer des mots de passe hachés à partir du mot de passe réel.

• C'est important car nous ne voudrions pas qu'un pirate informatique pirate nos systèmes et vole tous les mots de passe, également pour la confidentialité des utilisateurs.

• []byte (tableau d'octets) est simplement une chaîne.

Étape 15. Créons la fonction Login() dans 'userController.go' et dans les étapes ultérieures, nous pourrons créer les fonctions utilisées par Login() :

go mod init github.com/1shubham7/jwt

• Nous créons deux variables de type User, ce sont user et Founduser. et donner les données de la demande à l'utilisateur.

• À l'aide de 'userCollection.FindOne(ctx, bson.M{"email": user.Email}).Decode(&foundUser)', nous trouvons l'utilisateur via son e-mail et s'il est trouvé, le stocker dans la variable foundUser.

• Ensuite, nous utilisons la fonction VerifyPassword() pour vérifier le mot de passe et le stocker, rappelez-vous que nous prenons des pointeurs comme paramètres dans VerifyPassword(), sinon, cela créerait une nouvelle instance de ceux dans les paramètres plutôt que en fait, les changer.

• Nous créerons VerifyPassword() à l'étape suivante.

• Ensuite, nous utilisons simplement GenerateAllTokens() et UpdateAllTokens() pour générer et mettre à jour le jeton et le rafraîchir (qui sont essentiellement des jetons).

• Et à chaque étape, nous gérons tous les erreurs.

Étape 16. Créons la fonction VerifyPassword() dans le même fichier que la fonction Login() :

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

• Nous utilisons simplement la méthode CompareHashAndPassword() du package bcrypt qui est utilisée pour comparer les mots de passe hachés. et renvoyer une valeur booléenne en fonction des résultats.

• []byte (tableau d'octets) est simplement une chaîne, mais []byte aide à comparer.

Étape 17. Créons la fonction UpdateAllTokens() dans le fichier 'tokenHelper.go' :

go get github.com/gin-gonic/gin

• Nous créons une variable appelée updateObj qui est de type primitive.D. Le type primitif.D dans le pilote Go de MongoDB est une représentation d'un document BSON.

• Append() ajoute une paire clé-valeur à updateObj à chaque fois qu'il est exécuté.

• Ensuite, 'time.Parse(time.RFC3339, time.Now().Format(time.RFC3339))' est utilisé pour mettre à jour l'heure actuelle (heure à laquelle la mise à jour se produit et la fonction s'exécute) vers Updated_at .

• Le reste du bloc de code effectue une mise à jour à l'aide de la méthode UpdateOne de la collection mongoDB.

• À la dernière étape, nous traitons également l'erreur au cas où une erreur se produirait.

Étape 18. Avant de continuer, téléchargeons le package go.mongodb.org/mongo-driver :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Étape 19. Travaillons maintenant sur la fonction GetUserById(). N'oubliez pas que GetUserById() permet aux utilisateurs d'accéder à leurs propres informations, les administrateurs peuvent accéder à toutes les données des utilisateurs, les utilisateurs ne peuvent accéder qu'aux leurs.

go mod init github.com/1shubham7/jwt

• Prendre le user_id de la requête et le stocker dans la variable userId.

• création d'une variable appelée user de type User. puis recherchez simplement l'utilisateur dans notre base de données à l'aide de user_id, si l'user_id correspond, nous stockerons les informations de cette personne dans la variable utilisateur.

• Si tout se passe bien, StatusOk

• nous traitons également les erreurs à chaque étape.

Étape 20. Travaillons maintenant sur la fonction GetUsers(). N'oubliez pas que seul l'administrateur peut accéder à la fonction GetUsers() car elle inclurait les données de tous les utilisateurs. Créez une fonction GetUsers() dans le même fichier que les fonctions GetUserById(), Login() et 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)
}

• Tout d'abord, nous vérifierons si la demande provient de l'administrateur ou non, nous le faisons à l'aide de CheckUserType() que nous avons créé lors des étapes précédentes.

• Ensuite, nous définissons le nombre d'enregistrements que vous souhaitez par page.

• Nous pouvons le faire en prenant le recodePerPage de la requête et en le convertissant en int, cela se fait par srtconv.

• Si une erreur se produit lors du réglage de recordPerPage ou recordPerPage est inférieur à 1, par défaut nous aurons 9 enregistrements par page

• De même, nous prenons le numéro de page dans la variable 'page'.

• Par défaut, nous aurons le numéro de page comme 1 et 9 recordPerPage.

• Ensuite, nous avons créé trois étapes (matchStage, groupStage, projectStage).

• Ensuite, nous définissons ces trois étapes dans notre pipeline Mongo à l'aide de la fonction Aggregate()

• Nous traitons également les erreurs à chaque étape.

Étape 21. Notre 'userController.go' est maintenant prêt, voici à quoi ressemble le fichier 'userController.go' une fois terminé :

go get github.com/gin-gonic/gin

Étape 22. Nous pouvons maintenant travailler sur la partie authentification. Pour cela, nous allons créer un middleware d'authentification. Créez un dossier appelé « middleware » et créez-y un fichier appelé « authMiddleware.go ». Entrez le code suivant dans le fichier :

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ 
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Étape 23. Créons maintenant la fonction ValidateToken(), nous allons créer cette fonction dans 'tokenHelper.go' :

go mod init github.com/1shubham7/jwt

• ValidateToken prend signéToken et renvoie SignedDetails avec un message d'erreur. "" s'il n'y a pas d'erreur.

• La fonction ParseWithClaims() est utilisée pour nous obtenir le jeton et le stocker dans une variable appelée token.

• Ensuite, nous vérifions si le token est correct ou non en utilisant la méthode Claims on token. Et nous stockons le résultat dans la variable claims.

• Ensuite, nous vérifions si le jeton a expiré à l'aide de la fonction ExpiresAt(), si l'heure actuelle est supérieure à l'heure ExpiresAt, il aurait expiré.

• Et puis retournez simplement la variable claims ainsi que le message.

Étape 24. Nous avons presque terminé maintenant, faisons 'go mod spice', cette commande vérifie votre fichier go.mod, elle supprime tous les packages/dépendances que nous avons installés mais que nous n'utilisons pas et télécharge toutes les dépendances que nous utilisons mais que nous n'avons pas encore téléchargées.

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

Sortir

Votre projet d'authentification JWT est prêt, pour enfin exécuter l'application entrez la commande suivante dans le terminal :

go get github.com/gin-gonic/gin

Vous obtiendrez un résultat similaire :

Cela permettra au serveur d'être opérationnel et vous pourrez utiliser l'API curl ou Postman pour envoyer une demande et recevoir une réponse. Ou vous pouvez simplement intégrer cette API à un framework frontend. Et avec cela, notre API d’authentification est prête, félicitez-vous !

Conclusion

Dans cet article, nous avons discuté de l'un des moyens les plus rapides de créer une authentification JWT, nous avons utilisé le framework Gin-Gonic pour notre projet. Ce n'est pas votre "juste une autre API d'authentification". Gin est 300 % plus rapide que NodeJS, ce qui rend cette API d'authentification vraiment rapide et efficace. La structure de projet que nous utilisons est également une structure de projet au niveau de l'industrie. Vous pouvez apporter d'autres modifications, comme stocker le SECRET_KEY dans le fichier .env et bien plus encore pour améliorer cette API. Vous pouvez également trouver le code source de ce projet ici - 1Shubham7/go-jwt-token.

Assurez-vous de suivre toutes les étapes afin de créer le projet et d'ajouter des fonctionnalités supplémentaires et jouez simplement avec le code pour mieux le comprendre. La meilleure façon d'apprendre l'authentification est de créer vos propres projets.

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!