JWT (JSON Web Token) ist eine ?u?erst effektive Methode zum Sichern von APIs durch tokenbasierte Authentifizierung und stellt sicher, dass nur authentifizierte Benutzer auf Ihre API-Endpunkte zugreifen k?nnen. Im Gegensatz zu herk?mmlichen sitzungsbasierten Ans?tzen ist JWT zustandslos, sodass keine serverseitige Sitzungsspeicherung erforderlich ist, was es ideal für skalierbare und leistungsstarke Anwendungen macht. In diesem Leitfaden führen wir Sie durch die Implementierung der JWT-Authentifizierung in einer Go-API, von der Generierung von Tokens bei der Benutzeranmeldung bis hin zur Sicherung Ihrer Endpunkte durch Validierung dieser Tokens, um letztendlich die Sicherheit und Robustheit der Daten und Ressourcen Ihrer Anwendung zu verbessern.

Voraussetzungen

• Gehen Sie 1,21

Setup-Projekt

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 

Projektstruktur

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

Projektdateien

.env

jwt_secret = b0WciedNJvFCqFRbB2A1QhZoCDnutAOen5g1FEDO0HsLTwGINp04GXh2OXVpTqQL

Diese .env-Datei enth?lt eine einzelne Umgebungsvariable jwt_secret, die einen geheimen Schlüssel enth?lt, der zum Signieren und überprüfen von JWT-Tokens in der Anwendung verwendet wird.

Authenticate.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()
    }
}

Die Authenticate.go-Middleware definiert eine Funktion für die JWT-Authentifizierung in einer Go-API unter Verwendung des Gin-Frameworks. Es prüft, ob die Anforderung für die Pfade / oder /login gilt. In diesem Fall ist keine Authentifizierung erforderlich. Für andere Routen ruft es den Authorization-Header ab und erwartet ein Bearer-Token. Das Token wird mithilfe des JWT-Pakets und eines geheimen Schlüssels aus Umgebungsvariablen analysiert und validiert. Wenn das Token ungültig ist oder fehlt, wird die Anfrage mit dem Status ?401 Nicht autorisiert“ abgebrochen. Wenn sie gültig sind, werden die Benutzeransprüche (z. B. ID und Name) extrahiert und dem Gin-Kontext hinzugefügt, wodurch der Zugriff auf geschützte Routen erm?glicht wird.

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

Die main.go-Datei richtet einen Go-Webserver mithilfe des Gin-Frameworks ein, um Routen mit JWT-basierter Authentifizierung zu verarbeiten. Zur Authentifizierung wird Middleware verwendet, die in Anfragen nach gültigen JWT-Tokens sucht. Der Server stellt zwei HTML-Seiten bereit: index.html und login.html, die über die Routen / und /login zug?nglich sind.

Für die /user-Route ruft der Server den Namen des authentifizierten Benutzers aus den JWT-Ansprüchen ab und gibt ihn in der Antwort zurück. Für die POST-Route /login validiert der Server die Benutzeranmeldeinformationen (Name und Passwort) und generiert, falls gültig, ein JWT-Token, signiert es mit einem geheimen Schlüssel und sendet es an den Client zurück. Der Server ist so konfiguriert, dass er auf Anfragen wartet und auf dem Standardport ausgeführt wird.

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

?ffnen Sie den Webbrowser und gehen Sie zu http://localhost:8080

Sie finden diese Testseite.

Testen

Nach ein paar Sekunden werden Sie zur Anmeldeseite weitergeleitet.

Drücken Sie die Anmeldeschaltfl?che und Sie werden auf der Startseite angemeldet, auf der der Name des angemeldeten Benutzers angezeigt wird.

Versuchen Sie, den Browser zu aktualisieren, und Sie werden sehen, dass Sie immer noch angemeldet sind. Klicken Sie dann auf die Schaltfl?che ?Abmelden“. Das JWT-Token wird entfernt und Sie werden erneut zur Anmeldeseite weitergeleitet.

Abschluss

Zusammenfassend l?sst sich sagen, dass die Implementierung der JWT-Authentifizierung in einer Go-API einen sicheren und skalierbaren Ansatz für die Benutzerauthentifizierung bietet. Durch die Verwendung des Gin-Frameworks zusammen mit dem Paket golang-jwt/jwt k?nnen wir die tokenbasierte Authentifizierung problemlos in unsere Anwendung integrieren. JWT-Tokens werden w?hrend der Anmeldung generiert, um Benutzeranmeldeinformationen sicher zu validieren und Zugriff auf geschützte Routen zu gew?hren. Die Middleware stellt sicher, dass nur authentifizierte Benutzer auf diese Routen zugreifen k?nnen, indem sie die Gültigkeit des Tokens überprüft. Dieser zustandslose Authentifizierungsmechanismus bietet verbesserte Leistung und Flexibilit?t und ist somit eine ideale Wahl für moderne API-Architekturen.

Quellcode: https://github.com/stackpuz/Example-JWT-Go

Erstellen Sie in wenigen Minuten eine CRUD-Web-App: https://stackpuz.com