Système d'authentification et d'autorisation d'identité de microservice construit à l'aide du langage Go

Système d'authentification et d'autorisation d'identité de microservice construit à l'aide du langage Go

Avec l'essor de l'architecture de microservices, les systèmes d'authentification et d'autorisation d'identité sont devenus un élément indispensable de la création d'applications distribuées. Dans cet article, nous présenterons comment utiliser le langage Go pour créer un système d'authentification et d'autorisation de microservices simple mais puissant, et joindrons des exemples de code.

Tout d'abord, nous devons déterminer la méthode d'authentification de l'identité. Dans l'architecture de microservices, les méthodes d'authentification d'identité courantes incluent l'authentification basée sur des jetons et l'authentification basée sur JWT (JSON Web Token). Dans cet exemple, nous utiliserons l'authentification basée sur JWT.

Pour générer et vérifier JWT, nous pouvons utiliser des bibliothèques tierces en langage Go. Ici, nous choisissons d'utiliser la bibliothèque github.com/dgrijalva/jwt-go.

Tout d'abord, nous devons importer cette bibliothèque dans notre programme Go :

import (
    "github.com/dgrijalva/jwt-go"
)

Ensuite, nous devons définir une clé pour signer JWT. Cette clé doit être une chaîne aléatoire utilisée pour assurer la sécurité du JWT. Dans des applications pratiques, nous pouvons stocker la clé dans une variable d'environnement pour améliorer la sécurité.

var signingKey = []byte("ThisIsASecretKey")

Ensuite, nous devons définir une structure pour représenter les informations d'identité de l'utilisateur. Dans cet exemple, nous enregistrons uniquement l'ID utilisateur et les informations sur le rôle. En fonction des besoins réels, nous pouvons ajouter d'autres champs si nécessaire.

type User struct {
    ID     int64  `json:"id"`
    Role   string `json:"role"`
}

Ensuite, nous devons implémenter une fonction pour générer JWT. Cette fonction reçoit un objet utilisateur en paramètre et renvoie une nouvelle chaîne JWT.

func GenerateToken(user User) (string, error) {
    claims := jwt.MapClaims{
        "id":   user.ID,
        "role": user.Role,
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString(signingKey)
}

Ensuite, nous devons implémenter une fonction pour vérifier le JWT. Cette fonction reçoit une chaîne JWT en paramètre et renvoie l'objet utilisateur analysé.

func ValidateToken(tokenString string) (User, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        return signingKey, nil
    })
    if err != nil {
        return User{}, err
    }
    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return User{
            ID:   int64(claims["id"].(float64)),
            Role: claims["role"].(string),
        }, nil
    }
    return User{}, errors.New("Invalid token")
}

Enfin, nous pouvons utiliser ces fonctions dans nos microservices pour l'authentification et l'autorisation. Lorsque l'utilisateur se connecte, nous pouvons générer un JWT et le renvoyer à l'utilisateur. Lorsqu'un utilisateur fait une demande, nous pouvons valider le JWT et vérifier les informations de rôle de l'utilisateur pour déterminer s'il y a accès.

func LoginHandler(w http.ResponseWriter, r *http.Request) {
    // 验证用户身份...
    // 生成JWT
    token, _ := GenerateToken(user)
    // 将JWT返回给用户
    w.Write([]byte(token))
}

func SecureHandler(w http.ResponseWriter, r *http.Request) {
    // 验证JWT
    tokenString := r.Header.Get("Authorization")
    user, err := ValidateToken(tokenString)
    if err != nil {
        w.WriteHeader(http.StatusUnauthorized)
        w.Write([]byte("Unauthorized"))
        return
    }
    // 检查用户角色...
    // 处理请求...
    w.Write([]byte("Authorized"))
}

Grâce à l'exemple ci-dessus, nous pouvons voir comment utiliser le langage Go pour créer un système d'authentification et d'autorisation de microservices simple mais puissant. Bien entendu, dans les applications réelles, nous devrons peut-être ajouter davantage de fonctionnalités, telles que des jetons d'actualisation, une authentification unique, etc. Mais qu'il s'agisse d'un scénario d'application simple ou complexe, les fonctions puissantes du langage Go et les riches bibliothèques tierces peuvent nous aider à créer un système d'authentification et d'autorisation d'identité sûr et fiable.

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!