Implémenter l'authentification et l'autorisation API de base à l'aide de Go

Avec le développement continu des applications Web, à mesure que les applications deviennent de plus en plus grandes, les interfaces API doivent être protégées pour empêcher tout accès aléatoire, de sorte que les mécanismes d'authentification et d'autorisation API deviennent de plus en plus importants. Dans cet article, nous expliquerons comment utiliser Go pour implémenter l'authentification et l'autorisation API de base.

Tout d'abord, comprenons les concepts de base de l'authentification et de l'autorisation :

Authentification : L'authentification est un mécanisme de vérification d'identité utilisé pour vérifier si l'identité demandée par l'utilisateur est légitime. Dans les applications Web, l'authentification peut se faire via un nom d'utilisateur et un mot de passe ou à l'aide de jetons tels que JWT.

Autorisation : l'autorisation est un mécanisme de vérification des autorisations utilisé pour déterminer si l'utilisateur a le droit d'accéder à la ressource demandée. Dans les applications Web, l'autorisation peut être effectuée via un contrôle d'accès basé sur les rôles ou des jetons d'accès.

La mise en œuvre de l'authentification et de l'autorisation API de base dans Go peut être divisée en les étapes suivantes :

Étape 1 : Installer et configurer le framework Gin

Avant d'utiliser le framework Gin, vous devez d'abord l'installer. Nous pouvons l'installer à l'aide de la commande suivante :

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

Une fois l'installation terminée, nous pouvons utiliser le code suivant pour initialiser le framework Gin :

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

router := gin.Default()

Étape 2 : Ajouter un routage

Avant de commencer à ajouter des routes, nous devons définir une fonction middleware, permettant de vérifier si l'utilisateur est légitime. La fonction middleware vérifie les en-têtes de requêtes entrantes et renvoie un code d'état et un message d'erreur au gestionnaire.

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

Nous pouvons ajouter des fonctions middleware dans la fonction de routage pour garantir que seuls les utilisateurs authentifiés peuvent accéder aux ressources requises.

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

Dans le code ci-dessus, la requête GET sera acheminée vers le point de terminaison /secured, mais seuls les utilisateurs authentifiés pourront y accéder avec succès.

Étape 3 : Implémenter l'authentification JWT

Maintenant, nous avons ajouté une route et utilisé un middleware pour garantir que l'utilisateur est authentifié pour accéder à la route. Nous verrons ensuite comment authentifier les utilisateurs à l'aide de JWT.

JWT est un jeton Web basé sur JSON qui fournit un moyen sécurisé de transférer des informations entre les clients et les serveurs. JWT se compose généralement de trois parties : en-tête, charge utile et signature. L'en-tête contient le type de jeton et l'algorithme de signature, la charge utile contient les données du jeton et la signature est utilisée pour vérifier l'intégrité du jeton.

Nous pouvons implémenter l'authentification JWT dans Go en utilisant le code suivant :

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
}

Dans le code ci-dessus, nous créons d'abord un jeton JWT, puis ajoutons une réclamation d'utilisateur ainsi que l'heure d'expiration. Enfin, le jeton est signé et le résultat est renvoyé.

Étape 4 : Implémenter l'autorisation basée sur les rôles

Dans la dernière étape, nous apprendrons comment utiliser l'autorisation basée sur les rôles pour contrôler l'accès des utilisateurs aux ressources.

Dans le contrôle d'accès basé sur les rôles, les utilisateurs sont attribués à un ou plusieurs rôles, et chaque rôle se voit accorder un ensemble d'autorisations. Lors de l'accès aux ressources, le centre d'autorisation détermine les ressources auxquelles l'utilisateur a accès en fonction de son rôle.

Nous pouvons implémenter une simple autorisation basée sur les rôles en utilisant le code suivant :

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

Dans le code ci-dessus, nous définissons une fonction middleware AuthzMiddleware qui accepte une liste de rôles en tant que paramètre et vérifie si le rôle utilisateur est inclus. Si l'utilisateur a le rôle requis, transmettez le middleware et passez au gestionnaire suivant ; sinon, renvoyez un code d'état Interdit.

Enfin, nous pouvons ajouter la fonction AuthzMiddleware à la route pour garantir que seuls les utilisateurs ayant des rôles spécifiques ont accès aux ressources requises.

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

Voici les étapes de base pour implémenter l'authentification et l'autorisation API de base à l'aide de Go. Ces implémentations de base peuvent servir de base à une application et peuvent être personnalisées et étendues selon les besoins.

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!