Implementieren Sie die grundlegende API-Authentifizierung und -Autorisierung mit Go

Mit der kontinuierlichen Entwicklung von Webanwendungen, da Anwendungen immer größer werden, müssen API-Schnittstellen geschützt werden, um zufälligen Zugriff zu verhindern, sodass API-Authentifizierungs- und Autorisierungsmechanismen immer wichtiger werden. In diesem Artikel stellen wir vor, wie Sie mit Go die grundlegende API-Authentifizierung und -Autorisierung implementieren.

Lassen Sie uns zunächst die Grundkonzepte der Authentifizierung und Autorisierung verstehen:

Authentifizierung: Die Authentifizierung ist ein Mechanismus zur Identitätsüberprüfung, mit dem überprüft wird, ob die vom Benutzer angeforderte Identität legitim ist. In Webanwendungen kann die Authentifizierung über Benutzername und Passwort oder über Token wie JWT erfolgen.

Autorisierung: Bei der Autorisierung handelt es sich um einen Berechtigungsüberprüfungsmechanismus, der verwendet wird, um festzustellen, ob der Benutzer das Recht hat, auf die angeforderte Ressource zuzugreifen. In Webanwendungen kann die Autorisierung durch rollenbasierte Zugriffskontrolle oder Zugriffstoken erfolgen.

Die Implementierung der grundlegenden API-Authentifizierung und -Autorisierung in Go kann in die folgenden Schritte unterteilt werden:

Schritt 1: Installieren und konfigurieren Sie das Gin-Framework

Bevor Sie das Gin-Framework verwenden, müssen Sie es zuerst installieren. Wir können es mit dem folgenden Befehl installieren:

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

Nachdem die Installation abgeschlossen ist, können wir den folgenden Code verwenden, um das Gin-Framework zu initialisieren:

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

router := gin.Default()

Schritt 2: Routing hinzufügen

Bevor wir mit dem Hinzufügen von Routen beginnen, müssen wir sie definieren Eine Middleware-Funktion, die verwendet, um zu überprüfen, ob der Benutzer legitim ist. Die Middleware-Funktion prüft die eingehenden Anforderungsheader und gibt einen Statuscode und eine Fehlermeldung an den Handler zurück.

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

Wir können der Routing-Funktion Middleware-Funktionen hinzufügen, um sicherzustellen, dass nur authentifizierte Benutzer auf die erforderlichen Ressourcen zugreifen können.

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

Im obigen Code wird die GET-Anfrage an den /secured-Endpunkt weitergeleitet, aber nur authentifizierte Benutzer können erfolgreich darauf zugreifen.

Schritt 3: JWT-Authentifizierung implementieren

Jetzt haben wir eine Route hinzugefügt und Middleware verwendet, um sicherzustellen, dass der Benutzer für den Zugriff auf die Route authentifiziert ist. Als Nächstes schauen wir uns an, wie Benutzer mithilfe von JWT authentifiziert werden.

JWT ist ein JSON-basierter Web-Token, der eine sichere Möglichkeit zur Übertragung von Informationen zwischen Clients und Servern bietet. JWT besteht normalerweise aus drei Teilen: Header, Payload und Signatur. Der Header enthält den Token-Typ und den Signaturalgorithmus, die Nutzlast enthält die Token-Daten und die Signatur wird zur Überprüfung der Integrität des Tokens verwendet.

Wir können die JWT-Authentifizierung in Go mithilfe des folgenden Codes implementieren:

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
}

Im obigen Code erstellen wir zunächst ein JWT-Token und fügen dann einen Benutzeranspruch zusammen mit der Ablaufzeit hinzu. Abschließend wird der Token signiert und das Ergebnis zurückgegeben.

Schritt 4: Rollenbasierte Autorisierung implementieren

Im letzten Schritt erfahren Sie, wie Sie mithilfe der rollenbasierten Autorisierung den Benutzerzugriff auf Ressourcen steuern.

Bei der rollenbasierten Zugriffskontrolle werden Benutzer einer oder mehreren Rollen zugewiesen und jeder Rolle wird eine Reihe von Berechtigungen gewährt. Beim Zugriff auf Ressourcen bestimmt das Autorisierungscenter anhand seiner Rolle, auf welche Ressourcen der Benutzer Zugriff hat.

Wir können eine einfache rollenbasierte Autorisierung mit dem folgenden Code implementieren:

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

Im obigen Code definieren wir eine AuthzMiddleware-Middleware-Funktion, die eine Liste von Rollen als Parameter akzeptiert und prüft, ob die Benutzerrolle enthalten ist. Wenn der Benutzer über die erforderliche Rolle verfügt, übergeben Sie die Middleware und fahren Sie mit dem nächsten Handler fort. Andernfalls geben Sie einen Statuscode „Verboten“ zurück.

Schließlich können wir der Route die Funktion AuthzMiddleware hinzufügen, um sicherzustellen, dass nur Benutzer mit bestimmten Rollen Zugriff auf die erforderlichen Ressourcen haben.

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

Die oben genannten Schritte sind die grundlegenden Schritte zur Implementierung der grundlegenden API-Authentifizierung und -Autorisierung mit Go. Diese grundlegenden Implementierungen können als Grundlage für eine Anwendung dienen und bei Bedarf weiter angepasst und erweitert werden.

Das obige ist der detaillierte Inhalt vonImplementieren Sie die grundlegende API-Authentifizierung und -Autorisierung mit Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!