Implémentation de l'authentification JWT dans l'API Go

JWT (JSON Web Token) est une méthode très efficace pour sécuriser les API via une authentification basée sur des jetons, garantissant que seuls les utilisateurs authentifiés peuvent accéder aux points de terminaison de votre API. Contrairement aux approches traditionnelles basées sur les sessions, JWT est sans état, éliminant ainsi le besoin de stockage de session côté serveur, ce qui le rend idéal pour les applications évolutives et performantes. Dans ce guide, nous vous guiderons dans la mise en œuvre de l'authentification JWT dans une API Go, depuis la génération de jetons lors de la connexion de l'utilisateur jusqu'à la sécurisation de vos points de terminaison en validant ces jetons, améliorant ainsi la sécurité et la robustesse des données et des ressources de votre application.

Conditions préalables

• Allez 1.21

Projet d'installation

go mod init app
go get github.com/gin-gonic/gin@v1.5.0
go get github.com/golang-jwt/jwt
go get github.com/joho/godotenv 

Structure du projet

├─ .env
├─ main.go
├─ middleware
│  └─ authenticate.go
└─ public
   ├─ index.html
   └─ login.html

Fichiers de projet

.env

jwt_secret = b0WciedNJvFCqFRbB2A1QhZoCDnutAOen5g1FEDO0HsLTwGINp04GXh2OXVpTqQL

Ce fichier .env contient une seule variable d'environnement jwt_secret, qui contient une clé secrète utilisée pour signer et vérifier les jetons JWT dans l'application.

authentifier.go

package middleware

import (
    "net/http"
    "os"
    "strings"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt"
)

type Claims struct {
    Id int `json:"id"`
    Name string `json:"name"`
    jwt.StandardClaims
}

func Authenticate() gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.Request.URL.Path == "/" || c.Request.URL.Path == "/login" {
            c.Next()
            return
        }
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
        token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
            return []byte(os.Getenv("jwt_secret")), nil
        })
        if err != nil || !token.Valid {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        if claims, ok := token.Claims.(*Claims); ok {
            c.Set("user", claims)
        } else {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        c.Next()
    }
}

Le middleware Authenticate.go définit une fonction d'authentification JWT dans une API Go utilisant le framework Gin. Il vérifie si la demande concerne les chemins / ou /login, auquel cas aucune authentification n'est nécessaire. Pour les autres routes, il récupère l’en-tête Authorization, en attendant un jeton Bearer. Le jeton est analysé et validé à l'aide du package jwt et d'une clé secrète issue des variables d'environnement. Si le jeton est invalide ou manquant, la demande est abandonnée avec un statut 401 non autorisé. Si elles sont valides, les revendications de l'utilisateur (telles que l'identifiant et le nom) sont extraites et ajoutées au contexte Gin, permettant l'accès aux routes protégées.

main.go

package main

import (
    "app/middleware"
    "net/http"
    "os"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt"
    "github.com/joho/godotenv"
)

func main() {
    godotenv.Load()
    router := gin.Default()
    router.Use(middleware.Authenticate())
    router.LoadHTMLFiles("public/index.html", "public/login.html")

    router.GET("/", func(c *gin.Context) {
        c.HTML(http.StatusOK, "index.html", nil)
    })

    router.GET("/login", func(c *gin.Context) {
        c.HTML(http.StatusOK, "login.html", nil)
    })

    router.GET("/user", func(c *gin.Context) {
        user, _ := c.Get("user")
        claims := user.(*middleware.Claims)
        c.JSON(http.StatusOK, gin.H{"name": claims.Name})
    })

    router.POST("/login", func(c *gin.Context) {
        var login map[string]string
        c.BindJSON(&login)
        if login["name"] == "admin" && login["password"] == "1234" {
            token := jwt.NewWithClaims(jwt.SigningMethodHS256, &middleware.Claims{
                Id: 1,
                Name: login["name"],
                StandardClaims: jwt.StandardClaims{
                    IssuedAt: time.Now().Unix(),
                    ExpiresAt: time.Now().Add(24 * time.Hour).Unix(),
                },
            })
            tokenString, _ := token.SignedString([]byte(os.Getenv("jwt_secret")))
            c.JSON(http.StatusOK, gin.H{"token": tokenString})
        } else {
            c.Status(http.StatusBadRequest)
        }
    })
    router.Run()
}

Le fichier main.go configure un serveur Web Go à l'aide du framework Gin pour gérer les routes avec une authentification basée sur JWT. Il utilise un middleware pour l'authentification, qui vérifie les jetons JWT valides dans les requêtes. Le serveur dessert deux pages HTML : index.html et login.html, qui sont accessibles via les routes / et /login.

Pour la route /user, le serveur récupère le nom de l'utilisateur authentifié à partir des revendications JWT et le renvoie dans la réponse. Pour la route POST /login, le serveur valide les informations d'identification de l'utilisateur (nom et mot de passe) et, s'il est valide, génère un jeton JWT, le signe avec une clé secrète et le renvoie au client. Le serveur est configuré pour écouter les requêtes et s'exécuter sur le port par défaut.

index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/css/bootstrap.min.css" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" rel="stylesheet">
</head>
<body>
    <div>



<p>The index.html is a simple web page that provides a user interface for displaying the login status of a user. It uses Bootstrap for styling and Font Awesome for icons. On page load, it checks the user's authentication status by sending a request to the server with a JWT token stored in localStorage. If the user is logged in, it shows a success message with the user's name and a logout button. If not logged in, it shows a message indicating the user is not logged in and redirects them to the login page after a few seconds.</p>

<h3>
  
  
  login.html
</h3>



<pre class="brush:php;toolbar:false"><!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/css/bootstrap.min.css" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" rel="stylesheet">
</head>
<body>
    <div>



<p>The login.html page provides a simple login form where users can input their username and password. It uses Bootstrap for styling and Font Awesome for icons. When the user submits the form, a JavaScript function login() sends a POST request to the /login endpoint with the entered credentials. If the login is successful, the server returns a JWT token, which is stored in localStorage. The page then redirects the user to the home page (/). If the login fails, an error message is displayed.</p>

<h2>
  
  
  Run project
</h2>



<pre class="brush:php;toolbar:false">go run main.go

Ouvrez le navigateur Web et accédez à http://localhost:8080

Vous trouverez cette page de test.

Essai

Après quelques secondes, vous serez redirigé vers la page de connexion.

Appuyez sur le bouton de connexion et vous serez connecté à la page d'accueil, qui affichera le nom de l'utilisateur connecté.

Essayez d'actualiser le navigateur et vous verrez que vous êtes toujours connecté. Ensuite, appuyez sur le bouton de déconnexion, le jeton JWT sera supprimé et vous serez à nouveau redirigé vers la page de connexion.

Conclusion

En conclusion, la mise en œuvre de l'authentification JWT dans une API Go fournit une approche sécurisée et évolutive pour gérer l'authentification des utilisateurs. En utilisant le framework Gin avec le package golang-jwt/jwt, nous pouvons facilement intégrer l'authentification basée sur des jetons dans notre application. Les jetons JWT sont générés lors de la connexion, validant en toute sécurité les informations d'identification de l'utilisateur et accordant l'accès aux routes protégées. Le middleware garantit que seuls les utilisateurs authentifiés peuvent accéder à ces routes en vérifiant la validité du jeton. Ce mécanisme d'authentification sans état offre des performances et une flexibilité améliorées, ce qui en fait un choix idéal pour les architectures API modernes.

Code source : https://github.com/stackpuz/Example-JWT-Go

Créez une application Web CRUD en quelques minutes : https://stackpuz.com

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!