Protégez votre API Go

Ce guide explique comment protéger les points de terminaison d’une API Go à l’aide de jetons d’accès JWT avec le SDK go-jwt-middleware v3.

Utilisez l’IA pour intégrer Auth0

Si vous utilisez un assistant IA de programmation comme Claude Code, Cursor ou GitHub Copilot, vous pouvez ajouter automatiquement l’authentification à l’Auth0 API en quelques minutes grâce à Agent Skills.

Installer :

npx skills add auth0/agent-skills --skill auth0

Ensuite, demandez à votre assistant IA :

Add Auth0 JWT authentication to my Go API

Votre assistant IA créera automatiquement votre Auth0 API, récupérera les identifiants, installera go-jwt-middleware, configurera le validateur et protégera vos points de terminaison d’API à l’aide de la validation JWT. Documentation complète d’Agent Skills →

Prérequis : Avant de commencer, assurez-vous d’avoir installé les éléments suivants :

• Go 1.24 ou une version ultérieure (requis pour la prise en charge des génériques dans go-jwt-middleware v3)
• Git pour le contrôle de version

Vérifiez l’installation : go version

​

Pour commencer

Vous allez créer une API Go avec trois points de terminaison illustrant différents niveaux de protection : accès public, authentification par JWT et permissions à portée limitée. La mise en œuvre complète utilise go-jwt-middleware v3 avec la bibliothèque standard net/http de Go.

Voir l’exemple sur GitHub

Exemple complet fonctionnel avec tests

1. Créer un nouveau projet

   Créez un nouveau dossier pour votre API en Go et initialisez un module.

   mkdir myapi && cd myapi
   go mod init github.com/yourorg/myapi
   

   Installez les dépendances requises :

   go get github.com/auth0/go-jwt-middleware/v3
   go get github.com/joho/godotenv
   go mod download
   

   Créez la structure du projet :

   mkdir -p cmd/server internal/auth internal/config internal/handlers
   touch .env cmd/server/main.go internal/config/auth.go internal/auth/claims.go internal/auth/validator.go internal/auth/middleware.go internal/handlers/api.go
   

   Voir le fichier go.mod attendu

   go.mod

   module github.com/yourorg/myapi
   
   go 1.24
   
   require (
       github.com/auth0/go-jwt-middleware/v3 v3.1.0
       github.com/joho/godotenv v1.5.1
   )
   
2. Configurez votre API Auth0

   Ensuite, vous devez créer une nouvelle API dans votre tenant Auth0 et ajouter les variables d’environnement à votre projet.

   Vous avez deux options pour configurer votre API Auth0 : utiliser une commande CLI ou la configurer manuellement dans le Dashboard :

   CLI

   Exécutez la commande suivante dans le répertoire racine de votre projet pour créer une API Auth0 :

   Mac

   # Installer Auth0 CLI (si ce n’est pas déjà fait)
   brew tap auth0/auth0-cli && brew install auth0
   
   # Créer une API Auth0
   auth0 apis create \
     --name "My Go API" \
     --identifier https://my-go-api.example.com
   

   Une fois l’API créée, copiez les valeurs Identifier et Domain, puis créez votre fichier .env :

   Cette commande va :

   1. Vérifier si vous êtes authentifié (et vous inviter à vous connecter au besoin)
   2. Créer une API Auth0 avec l’identifiant spécifié
   3. Afficher les détails de l’API, y compris le domaine et l’identifiant

   Dashboard

   1. Accédez au Auth0 Dashboard
   2. Allez à Applications → APIs → Create API
   3. Entrez un nom pour votre API (par ex., “My Go API”)
   4. Définissez l’Identifier (par ex., https://my-go-api.example.com)
      • Il s’agit de l’audience de votre API et il doit respecter un format d’URL valide
      • Il n’a pas besoin d’être une vraie URL ; c’est simplement un identifiant
   5. Laissez Signing Algorithm à RS256
   6. Cliquez sur Create
   7. Copiez la valeur de l’Identifier depuis l’onglet Settings

   Créez votre fichier .env avec les valeurs suivantes :

   .env

   AUTH0_DOMAIN=YOUR_AUTH0_DOMAIN
   AUTH0_AUDIENCE=YOUR_API_IDENTIFIER
   

   Remplacez YOUR_AUTH0_DOMAIN par le domaine de votre tenant Auth0 (par ex., dev-abc123.us.auth0.com) et YOUR_API_IDENTIFIER par l’identifiant de votre API dans le dashboard (par ex., https://my-go-api.example.com).

   Sécurité : N’envoyez jamais de fichiers .env dans le contrôle de version. Ajoutez .env à votre fichier .gitignore.

3. Définir les permissions d’API

   Les permissions (scopes) vous permettent de définir comment les ressources peuvent être consultées. Par exemple, accordez l’accès read aux gestionnaires et l’accès write aux administrateurs.

   1. Dans les paramètres de votre API, cliquez sur l’onglet Permissions
   2. Créez la permission suivante :

   Permission	Description
   read:messages	Lire les messages de l’API

   Ce tutoriel utilise le scope read:messages pour protéger le point de terminaison associé à cette portée. Vous pouvez définir des permissions supplémentaires selon les besoins de votre application.

4. Créer un chargeur de configuration

   Créez un package de configuration pour charger et valider des variables d’environnement.

   internal/config/auth.go

   package config
   
   import (
       "fmt"
       "os"
   )
   
   type AuthConfig struct {
       Domain   string
       Audience string
   }
   
   func LoadAuthConfig() (*AuthConfig, error) {
       domain := os.Getenv("AUTH0_DOMAIN")
       if domain == "" {
           return nil, fmt.Errorf("AUTH0_DOMAIN environment variable required")
       }
   
       audience := os.Getenv("AUTH0_AUDIENCE")
       if audience == "" {
           return nil, fmt.Errorf("AUTH0_AUDIENCE environment variable required")
       }
   
       return &AuthConfig{
           Domain:   domain,
           Audience: audience,
       }, nil
   }
   

   Ce que cela fait :

   • Charge le domaine Auth0 et l’audience à partir des variables d’environnement
   • Valide que la configuration requise est présente au démarrage
   • Renvoie une structure de configuration typée et sûre à utiliser dans toute l’application
5. Créer des revendications personnalisées et un validateur JWT

   Les claims personnalisées vous permettent d’extraire et de valider des données propres à l’application à partir de JWTs. Le validateur est le composant central qui vérifie les jetons auprès d’Auth0.

   claims.go

   internal/auth/claims.go

   package auth
   
   import (
       "context"
       "fmt"
       "strings"
   )
   
   // CustomClaims contient les données personnalisées que nous voulons extraire du JWT.
   type CustomClaims struct {
       Scope string `json:"scope"`
   }
   
   // Validate s’assure que les claims personnalisées sont correctement formatées.
   func (c *CustomClaims) Validate(ctx context.Context) error {
       if c.Scope == "" {
           return nil
       }
   
       if strings.TrimSpace(c.Scope) != c.Scope {
           return fmt.Errorf("scope claim has invalid whitespace")
       }
   
       if strings.Contains(c.Scope, "  ") {
           return fmt.Errorf("scope claim contains double spaces")
       }
   
       return nil
   }
   
   // HasScope vérifie si nos claims contiennent une scope précise.
   func (c *CustomClaims) HasScope(expectedScope string) bool {
       if c.Scope == "" {
           return false
       }
   
       scopes := strings.Split(c.Scope, " ")
       for _, scope := range scopes {
           if scope == expectedScope {
               return true
           }
       }
       return false
   }
   

   validator.go

   internal/auth/validator.go

   package auth
   
   import (
       "fmt"
       "net/url"
       "time"
   
       "github.com/auth0/go-jwt-middleware/v3/jwks"
       "github.com/auth0/go-jwt-middleware/v3/validator"
   )
   
   func NewValidator(domain, audience string) (*validator.Validator, error) {
       // Construire l’issuer URL (doit inclure la barre oblique finale)
       issuerURL, err := url.Parse("https://" + domain + "/")
       if err != nil {
           return nil, fmt.Errorf("failed to parse issuer URL: %w", err)
       }
   
       // Initialiser le fournisseur JWKS à l’aide du modèle d’options v3
       provider, err := jwks.NewCachingProvider(
           jwks.WithIssuerURL(issuerURL),
           jwks.WithCacheTTL(5*time.Minute),
       )
       if err != nil {
           return nil, fmt.Errorf("failed to create JWKS provider: %w", err)
       }
   
       // Créer le validateur à l’aide du modèle d’options v3
       jwtValidator, err := validator.New(
           validator.WithKeyFunc(provider.KeyFunc),
           validator.WithAlgorithm(validator.RS256),
           validator.WithIssuer(issuerURL.String()),
           validator.WithAudience(audience),
           validator.WithCustomClaims(func() validator.CustomClaims {
               return &CustomClaims{}
           }),
           validator.WithAllowedClockSkew(30*time.Second),
       )
       if err != nil {
           return nil, fmt.Errorf("failed to create validator: %w", err)
       }
   
       return jwtValidator, nil
   }
   

   Points clés :

   • La méthode Validate est appelée automatiquement par le middleware après l’analyse du JWT
   • HasScope analyse les scopes séparées par des espaces pour le contrôle d’accès basé sur les permissions
   • Le validateur utilise la mise en cache JWKS (TTL de 5 min) et tolère un décalage d’horloge de 30 s
   • L’algorithme RS256 est explicitement défini pour prévenir les attaques de confusion d’algorithme
6. Créer un middleware HTTP et des gestionnaires

   Le middleware encapsule le validateur pour les requêtes HTTP. Les handlers illustrent trois niveaux de protection : public, privé et protégé par permission.

   middleware.go

   internal/auth/middleware.go

   package auth
   
   import (
       "log/slog"
       "net/http"
   
       jwtmiddleware "github.com/auth0/go-jwt-middleware/v3"
       "github.com/auth0/go-jwt-middleware/v3/validator"
   )
   
   func NewMiddleware(jwtValidator *validator.Validator) (*jwtmiddleware.JWTMiddleware, error) {
       return jwtmiddleware.New(
           jwtmiddleware.WithValidator(jwtValidator),
           jwtmiddleware.WithValidateOnOptions(false),
           jwtmiddleware.WithErrorHandler(func(w http.ResponseWriter, r *http.Request, err error) {
               slog.Error("JWT validation failed", "error", err, "path", r.URL.Path)
               w.Header().Set("Content-Type", "application/json")
               w.WriteHeader(http.StatusUnauthorized)
               w.Write([]byte(`{"message":"Failed to validate JWT."}`))
           }),
       )
   }
   

   api.go

   internal/handlers/api.go

   package handlers
   
   import (
       "encoding/json"
       "net/http"
   
       "github.com/yourorg/myapi/internal/auth"
       jwtmiddleware "github.com/auth0/go-jwt-middleware/v3"
       "github.com/auth0/go-jwt-middleware/v3/validator"
   )
   
   // PublicHandler - aucune authentification requise
   func PublicHandler(w http.ResponseWriter, r *http.Request) {
       response := map[string]string{
           "message": "Hello from a public endpoint! You don't need to be authenticated to see this.",
       }
       w.Header().Set("Content-Type", "application/json")
       json.NewEncoder(w).Encode(response)
   }
   
   // PrivateHandler - nécessite un JWT valide
   func PrivateHandler(w http.ResponseWriter, r *http.Request) {
       response := map[string]string{
           "message": "Hello from a private endpoint! You need to be authenticated to see this.",
       }
       w.Header().Set("Content-Type", "application/json")
       json.NewEncoder(w).Encode(response)
   }
   
   // ScopedHandler - nécessite la permission 'read:messages'
   func ScopedHandler(w http.ResponseWriter, r *http.Request) {
       claims, err := jwtmiddleware.GetClaims[*validator.ValidatedClaims](r.Context())
       if err != nil {
           w.Header().Set("Content-Type", "application/json")
           w.WriteHeader(http.StatusUnauthorized)
           w.Write([]byte(`{"message":"Unauthorized."}`))
           return
       }
   
       customClaims, ok := claims.CustomClaims.(*auth.CustomClaims)
       if !ok || !customClaims.HasScope("read:messages") {
           w.Header().Set("Content-Type", "application/json")
           w.WriteHeader(http.StatusForbidden)
           w.Write([]byte(`{"message":"Insufficient scope."}`))
           return
       }
   
       response := map[string]string{
           "message": "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this.",
       }
       w.Header().Set("Content-Type", "application/json")
       json.NewEncoder(w).Encode(response)
   }
   

   Niveaux de protection :

   • Public (/api/public) — Aucune authentification requise
   • Privé (/api/private) — JWT valide requis
   • Avec permission (/api/private-scoped) — JWT valide + permission read:messages requise
7. Créer le serveur principal

   Reliez le tout dans le point d’entrée principal avec des délais d’expiration prêts pour la production et un arrêt en douceur :

   cmd/server/main.go

   package main
   
   import (
       "context"
       "log"
       "net/http"
       "os"
       "os/signal"
       "time"
   
       "github.com/yourorg/myapi/internal/auth"
       "github.com/yourorg/myapi/internal/config"
       "github.com/yourorg/myapi/internal/handlers"
       "github.com/joho/godotenv"
   )
   
   func main() {
       // Charger les variables d'environnement depuis le fichier .env
       if err := godotenv.Load(); err != nil {
           log.Println("No .env file found, using environment variables")
       }
   
       // Charger la configuration Auth0
       cfg, err := config.LoadAuthConfig()
       if err != nil {
           log.Fatalf("Failed to load config: %v", err)
       }
   
       // Créer le validateur JWT
       jwtValidator, err := auth.NewValidator(cfg.Domain, cfg.Audience)
       if err != nil {
           log.Fatalf("Failed to create validator: %v", err)
       }
   
       // Créer le middleware HTTP
       middleware, err := auth.NewMiddleware(jwtValidator)
       if err != nil {
           log.Fatalf("Failed to create middleware: %v", err)
       }
   
       // Configurer les routes
       mux := http.NewServeMux()
       mux.HandleFunc("/api/public", handlers.PublicHandler)
       mux.Handle("/api/private", middleware.CheckJWT(http.HandlerFunc(handlers.PrivateHandler)))
       mux.Handle("/api/private-scoped", middleware.CheckJWT(http.HandlerFunc(handlers.ScopedHandler)))
   
       // Configurer le serveur avec des délais d'expiration pour la production
       srv := &http.Server{
           Addr:         ":8080",
           Handler:      mux,
           ReadTimeout:  15 * time.Second,
           WriteTimeout: 15 * time.Second,
           IdleTimeout:  60 * time.Second,
       }
   
       // Démarrer le serveur dans une goroutine
       go func() {
           log.Println("Server starting on :8080")
           if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
               log.Fatalf("Server failed: %v", err)
           }
       }()
   
       // Arrêt gracieux
       quit := make(chan os.Signal, 1)
       signal.Notify(quit, os.Interrupt)
       <-quit
   
       log.Println("Shutting down server...")
       ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
       defer cancel()
   
       if err := srv.Shutdown(ctx); err != nil {
           log.Fatalf("Server forced to shutdown: %v", err)
       }
   
       log.Println("Server exited")
   }
   

   Structure du projet

   myapi/
   ├── cmd/
   │   └── server/
   │       └── main.go              # Point d’entrée de l’application
   ├── internal/
   │   ├── auth/
   │   │   ├── claims.go            # Claims JWT personnalisées
   │   │   ├── middleware.go         # Middleware JWT
   │   │   └── validator.go         # Validateur JWT
   │   ├── config/
   │   │   └── auth.go              # Chargement de la configuration
   │   └── handlers/
   │       └── api.go               # Gestionnaires HTTP (publics, privés, scopés)
   ├── .env                         # Variables d’environnement (non versionnées)
   ├── .gitignore
   ├── go.mod
   └── go.sum
   
8. Lancez et testez votre API

   Lancez le serveur de développement :

   go run cmd/server/main.go
   

   Vous devriez voir : Server starting on :8080

   Testez le point de terminaison public (aucune authentification requise) :

   curl http://localhost:8080/api/public
   

   Vous devriez voir :

   {
     "message": "Hello from a public endpoint! You don't need to be authenticated to see this."
   }
   

   Testez l’endpoint privé sans token (échec attendu) :

   curl http://localhost:8080/api/private
   

   Vous devriez voir une erreur 401 Unauthorized :

   {
     "message": "Failed to validate JWT."
   }
   

   Pour tester avec un token valide, accédez à votre API dans le Auth0 Dashboard, cliquez sur l’onglet Test et copiez l’access token. Exécutez ensuite :

   curl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        http://localhost:8080/api/private
   

   Testez le point de terminaison à portée restreinte (nécessite l’autorisation read:messages) :

   curl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
        http://localhost:8080/api/private-scoped
   

Vérification

Vous devriez maintenant disposer d’une API Go protégée. Votre API :

1. Accepte les requêtes vers les points de terminaison publics sans authentification
2. Rejette les requêtes vers les points de terminaison protégés sans jeton valide
3. Valide les jetons JWT en fonction de votre domaine Auth0 et de votre audience
4. Applique un contrôle d’accès basé sur les permissions à l’aide des scopes

---

​

Appeler votre API

Vous pouvez appeler votre API protégée à partir de n’importe quelle application en transmettant un jeton d’accès dans l’en-tête Authorization en tant que jeton Bearer.

Exemples de code client

cURL

curl --request GET \
  --url http://localhost:8080/api/private \
  --header 'authorization: Bearer YOUR_ACCESS_TOKEN'

Obtenir un jeton d’accès

Applications monopages ou mobiles

Si vous appelez l’API à partir d’une Single-Page Application ou d’une application mobile/native, une fois le flux d’autorisation terminé, vous obtiendrez un jeton d’accès. La façon d’obtenir le jeton et d’effectuer la requête vers l’API dépend du type d’application que vous développez et du framework que vous utilisez.

Applications monopages

Quickstarts React, Vue et Angular avec exemples

Applications mobiles / natives

Quickstarts iOS, Android et React Native

Machine-to-Machine (M2M)

Si vous appelez l’API à partir d’un outil en ligne de commande ou d’un autre service où aucun utilisateur ne saisit ses identifiants, vous devez utiliser le flux OAuth Client Credentials.

1. Enregistrer une application M2M

   Enregistrez une Machine to Machine Application dans votre Auth0 Dashboard.

2. Obtenir les identifiants

   Copiez votre Client ID et votre Client Secret à partir des Application Settings.

3. Demander un jeton d’accès

   Utilisez le flux Client Credentials pour obtenir un jeton d’accès :

   curl --request POST \
     --url 'https://YOUR_AUTH0_DOMAIN/oauth/token' \
     --header 'content-type: application/x-www-form-urlencoded' \
     --data grant_type=client_credentials \
     --data 'client_id=YOUR_CLIENT_ID' \
     --data client_secret=YOUR_CLIENT_SECRET \
     --data audience=YOUR_API_IDENTIFIER
   

Réutilisation des jetons : les clients d’Auth0 sont facturés en fonction du nombre de jetons d’accès Machine-to-Machine émis. Une fois que votre application a obtenu un jeton d’accès, elle devrait continuer à l’utiliser jusqu’à son expiration afin de réduire au minimum le nombre de jetons demandés.

---

​

Utilisation avancée

Sécurité DPoP (Proof-of-Possession)

DPoP (Demonstrating Proof-of-Possession), selon la RFC 9449, offre une sécurité renforcée en empêchant le vol de jeton grâce à l’association à une clé cryptographique.

internal/auth/middleware.go

func NewMiddleware(jwtValidator *validator.Validator) *jwtmiddleware.JWTMiddleware {
    return jwtmiddleware.New(
        jwtmiddleware.WithValidator(jwtValidator),
        jwtmiddleware.WithDPoPMode(jwtmiddleware.DPoPRequired),
        jwtmiddleware.WithLogger(slog.Default()),
    )
}

Modes DPoP :

• DPoPAllowed (par défaut) — Accepte les jetons Bearer et DPoP
• DPoPRequired — Accepte uniquement les jetons DPoP et rejette les jetons Bearer
• DPoPDisabled — Accepte uniquement les jetons Bearer et rejette les jetons DPoP

DPoP est recommandé pour les API financières, les API du secteur de la santé et les applications d’entreprise hautement sécurisées. Pour en savoir plus, consultez la documentation DPoP.

Configuration CORS

Activez CORS pour autoriser les requêtes provenant d’applications web. Vous pouvez utiliser un middleware simple ou une bibliothèque comme rs/cors :

go get github.com/rs/cors

cmd/server/main.go

import "github.com/rs/cors"

// Encapsuler le mux avec le middleware CORS
handler := cors.New(cors.Options{
    AllowedOrigins:   []string{"http://localhost:3000"},
    AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE"},
    AllowedHeaders:   []string{"Authorization", "Content-Type"},
    AllowCredentials: true,
}).Handler(mux)

srv := &http.Server{
    Addr:    ":8080",
    Handler: handler,
}

En production, indiquez des origines exactes au lieu d’utiliser des caractères génériques.

Journalisation structurée avec slog

Activez une journalisation détaillée pour déboguer la validation de jeton :

internal/auth/middleware.go

middleware := jwtmiddleware.New(
    jwtmiddleware.WithValidator(jwtValidator),
    jwtmiddleware.WithLogger(slog.Default()),
)

Ajoutez une vérification au démarrage :

cmd/server/main.go

log.Printf("Validator configured:")
log.Printf("  Issuer: https://%s/", cfg.Domain)
log.Printf("  Audience: %s", cfg.Audience)
log.Printf("  Algorithm: RS256")

---

​

Dépannage

Problèmes courants et solutions

​

”Échec de la validation du JWT” ou 401 Unauthorized

Problème : L’API ne parvient pas à trouver ou à valider le jeton d’accès.

Solutions :

1. Assurez-vous que l’en-tête Authorization est présent : Authorization: Bearer YOUR_TOKEN
2. Vérifiez que “Bearer” figure bien avant le jeton
3. Vérifiez que le jeton n’est pas expiré
4. Assurez-vous d’utiliser un jeton d’accès, et non un ID token

​

”incompatibilité de la claim aud”

Problème : L’audience du jeton ne correspond pas à celle de votre API.

Solution : Vérifiez que AUTH0_AUDIENCE correspond exactement à l’identificateur de votre API dans l’Auth0 Dashboard. L’audience ne doit PAS se terminer par une barre oblique :

# Correct
AUTH0_AUDIENCE=https://my-go-api.example.com

# Wrong (no trailing slash)
AUTH0_AUDIENCE=https://my-go-api.example.com/

L’application cliente doit aussi demander un jeton avec le bon paramètre d’audience.

​

”méthode de signature inattendue”

Problème : L’algorithme du jeton ne correspond pas à la configuration du validateur.

Solutions :

1. Auth0 utilise RS256 par défaut (asymétrique)
2. Assurez-vous que votre validateur utilise validator.RS256
3. N’utilisez jamais validator.HS256 pour des jetons Auth0, sauf si cela a été configuré explicitement

​

Point de terminaison JWKS inaccessible

Problème : Le fournisseur de mise en cache JWKS ne parvient pas à joindre le point de terminaison de clé publique d’Auth0.

Solutions :

1. Vérifiez la connectivité réseau vers Auth0 (paramètres de pare-feu/proxy)
2. Testez le point de terminaison JWKS manuellement : curl https://YOUR_AUTH0_DOMAIN/.well-known/jwks.json
3. Vérifiez que la région Auth0 est correcte (us/eu/au)

​

Chemin d’importation incorrect

Problème : cannot find package "github.com/auth0/go-jwt-middleware/v3/..."

Solution : Assurez-vous que toutes les importations utilisent le suffixe /v3 :

// Correct
import "github.com/auth0/go-jwt-middleware/v3/validator"

// Wrong
import "github.com/auth0/go-jwt-middleware/validator"

​

Erreurs liées au décalage d’horloge / jeton expiré

Problème : L’horloge du serveur n’est pas synchronisée, ce qui fait paraître expirés des jetons valides.

Solution : Le validateur inclut déjà une tolérance de 30 s pour le décalage d’horloge. Si vous avez besoin de plus, ajustez :

validator.WithAllowedClockSkew(60*time.Second)

​

Échec de l’extraction des claims

Problème : Failed to retrieve claims lors de l’utilisation des génériques.

Solution : Assurez-vous d’utiliser le bon paramètre de type :

claims, err := jwtmiddleware.GetClaims[*validator.ValidatedClaims](r.Context())

---

​

Prochaines étapes

Maintenant que vous disposez d’une API protégée, pensez à explorer :

• Contrôle d’accès basé sur les rôles — Mettez en place des permissions granulaires
• Bonnes pratiques pour les jetons d’accès — Découvrez la sécurité des jetons
• Surveillez votre API — Configurez la journalisation et la surveillance
• Vérifications de préparation à la production — Vérification de sécurité avant le lancement

---

​

Ressources

• go-jwt-middleware GitHub — Code source, exemples et prise en charge de DPoP
• Go API Sample — Exemple complet fonctionnel
• Auth0 Community — Obtenez de l’aide auprès de la communauté