Melaksanakan Pengesahan JWT dalam Go API

JWT (JSON Web Token) ialah kaedah yang sangat berkesan untuk mendapatkan API melalui pengesahan berasaskan token, memastikan hanya pengguna yang disahkan boleh mengakses titik akhir API anda. Tidak seperti pendekatan berasaskan sesi tradisional, JWT adalah tanpa kewarganegaraan, menghapuskan keperluan untuk storan sesi sebelah pelayan, yang menjadikannya ideal untuk aplikasi berskala dan berprestasi. Dalam panduan ini, kami akan membimbing anda melaksanakan pengesahan JWT dalam API Go, daripada menjana token semasa log masuk pengguna kepada memastikan titik akhir anda dengan mengesahkan token ini, akhirnya meningkatkan keselamatan dan keteguhan data dan sumber aplikasi anda.

Prasyarat

• Pergi 1.21

Projek persediaan

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 

Struktur projek

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

Fail projek

.env

jwt_secret = b0WciedNJvFCqFRbB2A1QhZoCDnutAOen5g1FEDO0HsLTwGINp04GXh2OXVpTqQL

Fail .env ini mengandungi pembolehubah persekitaran tunggal jwt_secret, yang memegang kunci rahsia yang digunakan untuk menandatangani dan mengesahkan token JWT dalam aplikasi.

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

Perisian tengah authenticate.go mentakrifkan fungsi untuk pengesahan JWT dalam API Go menggunakan rangka kerja Gin. Ia menyemak sama ada permintaan adalah untuk laluan / atau /log masuk, dalam hal ini tiada pengesahan diperlukan. Untuk laluan lain, ia mendapatkan semula pengepala Kebenaran, mengharapkan token Pembawa. Token dihuraikan dan disahkan menggunakan pakej jwt dan kunci rahsia daripada pembolehubah persekitaran. Jika token tidak sah atau tiada, permintaan akan dibatalkan dengan status 401 Tanpa Kebenaran. Jika sah, tuntutan pengguna (seperti id dan nama) diekstrak dan ditambahkan pada konteks Gin, membenarkan akses kepada laluan yang dilindungi.

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

Fail main.go menyediakan pelayan web Go menggunakan rangka kerja Gin untuk mengendalikan laluan dengan pengesahan berasaskan JWT. Ia menggunakan middleware untuk pengesahan, yang menyemak token JWT yang sah dalam permintaan. Pelayan menyediakan dua halaman HTML: index.html dan login.html, yang boleh diakses melalui laluan / dan /log masuk.

Untuk laluan /user, pelayan mendapatkan semula nama pengguna yang disahkan daripada tuntutan JWT dan mengembalikannya dalam respons. Untuk laluan POST /log masuk, pelayan mengesahkan kelayakan pengguna (nama dan kata laluan) dan, jika sah, menjana token JWT, menandatanganinya dengan kunci rahsia dan menghantarnya kembali kepada klien. Pelayan dikonfigurasikan untuk mendengar permintaan dan dijalankan pada port lalai.

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

Buka pelayar web dan pergi ke http://localhost:8080

Anda akan menemui halaman ujian ini.

Menguji

Selepas beberapa saat, anda akan dialihkan ke halaman log masuk.

Tekan butang log masuk, dan anda akan log masuk ke halaman utama, yang akan memaparkan nama pengguna log masuk.

Cuba muat semula penyemak imbas, dan anda akan melihat bahawa anda masih log masuk. Kemudian, tekan butang log keluar, token JWT akan dialih keluar dan anda akan diubah hala ke halaman log masuk sekali lagi.

Kesimpulan

Kesimpulannya, melaksanakan pengesahan JWT dalam API Go menyediakan pendekatan yang selamat dan berskala untuk mengendalikan pengesahan pengguna. Dengan menggunakan rangka kerja Gin bersama pakej golang-jwt/jwt, kami boleh dengan mudah menyepadukan pengesahan berasaskan token ke dalam aplikasi kami. Token JWT dijana semasa log masuk, mengesahkan kelayakan pengguna dengan selamat, dan memberikan akses kepada laluan yang dilindungi. Perisian tengah memastikan bahawa hanya pengguna yang disahkan boleh mengakses laluan ini dengan mengesahkan kesahihan token. Mekanisme pengesahan tanpa kewarganegaraan ini menawarkan prestasi dan fleksibiliti yang dipertingkatkan, menjadikannya pilihan ideal untuk seni bina API moden.

Kod sumber: https://github.com/stackpuz/Example-JWT-Go

Buat Apl Web CRUD dalam Minit: https://stackpuz.com

Atas ialah kandungan terperinci Melaksanakan Pengesahan JWT dalam Go API. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!