So implementieren Sie Authentifizierung und Autorisierung mit Golang

Mit der kontinuierlichen Weiterentwicklung von Internetanwendungen werden Benutzerauthentifizierung und -autorisierung immer wichtiger. Bei der Authentifizierung wird überprüft, ob ein Benutzer die Berechtigung zum Zugriff auf ein System hat, während bei der Autorisierung bestimmt wird, welche Aktionen ein Benutzer ausführen kann. In diesem Artikel besprechen wir, wie man Authentifizierung und Autorisierung mit Golang implementiert.

1. Authentifizierung mit JWT

JWT (JSON Web Tokens) ist eine kompakte und eigenständige Möglichkeit, die Identität eines Benutzers darzustellen. Es enthält Metadaten und Behauptungen, die überprüft und entschlüsselt werden können. Im Allgemeinen besteht JWT aus drei Teilen: Header, Nutzlast und Signatur.

Golang bietet viele nützliche Bibliotheken, die uns bei der Implementierung von JWT helfen, wie zum Beispiel: jwt-go. Generieren, dekodieren und verifizieren Sie JWT ganz einfach mit der jwt-go-Bibliothek. Hier ist ein Beispielcode, der die jwt-go-Bibliothek verwendet, um ein JWT zu generieren:

import (
    "time"
    "github.com/dgrijalva/jwt-go"
)
  
func CreateToken(userId string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": userId,
        "exp":     time.Now().Add(time.Hour * 24).Unix(),
    })
  
    return token.SignedString([]byte("your-secret"))
}

Im obigen Code erstellen wir ein JWT, das die ID des aktuellen Benutzers und die Ablaufzeit enthält. Signieren Sie dann das JWT mit der Methode jwt.SigningMethodHS256 und dem Schlüssel „your-secret“. Abschließend wird der JWT-String an den Aufrufer zurückgegeben.

Für jede HTTP-Anfrage können wir JWT zur Authentifizierung verwenden. Sobald sich der Benutzer erfolgreich angemeldet hat, können wir das generierte JWT an den Client zurückgeben. Der Client kann das JWT bei jeder weiteren Anfrage als Teil des „Authorization“-Headers an den Server senden. Der Server dekodiert das JWT und überprüft die Signatur, um sicherzustellen, dass sie legitim ist. Hier ist ein Beispielcode zur Validierung von JWT mithilfe der jwt-go-Bibliothek:

import (
    "net/http"
    "github.com/dgrijalva/jwt-go"
)
  
func ValidateTokenMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenHeader := r.Header.Get("Authorization")
        if tokenHeader == "" {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        token, err := jwt.Parse(tokenHeader, func(token *jwt.Token) (interface{}, error) {
            return []byte("your-secret"), nil
        })
  
        if err != nil || !token.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Im obigen Code haben wir eine Middleware namens ValidateTokenMiddleware definiert, die für die Validierung von JWT verantwortlich ist. ValidateTokenMiddleware prüft, ob der HTTP-Header ein Autorisierungstoken enthält und validiert es. Wenn das JWT ungültig ist, wird die Antwort HTTP 401 Unauthorized zurückgegeben. Andernfalls wird die Anfrage weiter bearbeitet.

Die Verwendung von JWT zur Authentifizierung stellt sicher, dass die Anfrage von einem legitimen Benutzer stammt und bietet eine höhere Sicherheit.

2. Rollen zur Autorisierung verwenden

In modernen Webanwendungen müssen Benutzer oft unterschiedliche Rollen und Berechtigungen haben. Beispielsweise kann ein Administrator über Berechtigungen zum Ausführen übergeordneter Vorgänge verfügen, über die normale Benutzer nicht verfügen. Daher müssen wir verschiedene Benutzerrollen separat autorisieren.

In Golang ist die Verwendung des rollenbasierten Zugriffskontrollmodells (RBAC) ein beliebter Ansatz. Im RBAC-Modell erhält jede Rolle unterschiedliche Berechtigungen und Benutzer werden einer oder mehreren Rollen zugewiesen. Bevor eine bestimmte Aktion ausgeführt wird, prüft das System dann, ob der Benutzer die Berechtigung zum Ausführen dieser Aktion hat.

Hier ist ein Beispielcode, der das rollenbasierte Zugriffskontrollmodell verwendet:

type Role string
  
const (
    AdminRole  Role = "admin"
    UserRole   Role = "user"
)
  
type User struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Role  Role   `json:"role"`
}
  
// Check if the user has permission to access the resource based on the specified role.
func HasPermission(user *User, requiredRole Role) bool {
    return user.Role == requiredRole || user.Role == AdminRole
}

Im obigen Code haben wir einen Aufzählungstyp namens Role definiert, der eine Liste von Rollen enthält, die wir in unserer Anwendung verwenden möchten. In der Benutzerstruktur weisen wir jedem Benutzer eine oder mehrere Rollen zu und prüfen mit der HasPermission-Funktion, ob der Benutzer die Berechtigung hat, einen bestimmten Vorgang auszuführen. In diesem Beispiel gibt die HasPermission-Funktion nur dann „true“ zurück, wenn die Rolle des Benutzers „AdminRole“ oder „requiredRole“ ist.

Wir können auch andere Methoden verwenden, z. B. die Verwendung von Middleware, um Benutzerrollen und Berechtigungen zu überprüfen. Hier ist ein Beispielcode, der auf Middleware basiert:

func AdminOnlyMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user, ok := r.Context().Value("user").(*User)
        if !ok || !HasPermission(user, AdminRole) {
            w.WriteHeader(http.StatusForbidden)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Im obigen Code definieren wir eine Middleware namens AdminOnlyMiddleware. Diese Middleware ruft die Benutzerrolle aus dem Kontext der HTTP-Anfrage ab und prüft, ob der Benutzer über die erforderlichen Berechtigungen zum Ausführen der Aktion verfügt. Wenn der Benutzer keine Berechtigung hat, wird die Antwort HTTP 403 Forbidden zurückgegeben.

Wenn wir eine Web-Framework-basierte Anwendung verwenden, können wir die Middleware direkt auf der Route registrieren. Beispielsweise können wir AdminOnlyMiddleware für API-Endpunkte registrieren, die Administratorrechte erfordern:

router.Handle("/api/dashboard", AdminOnlyMiddleware(http.HandlerFunc(handler)))

Im obigen Code können nur Benutzer mit Administratorrechten auf den Endpunkt „/api/dashboard“ zugreifen.

Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie man Authentifizierung und Autorisierung mit Golang implementiert. Wir verwenden JWT, um zu überprüfen, ob der Benutzer berechtigt ist, auf das System zuzugreifen, und ein rollenbasiertes Zugriffskontrollmodell, um zu überprüfen, ob der Benutzer berechtigt ist, eine bestimmte Aktion auszuführen. Diese Technologien können uns dabei helfen, Webanwendungen zu erstellen, die sicher, skalierbar und einfach zu warten sind.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Authentifizierung und Autorisierung mit Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!