Définir un middleware différent pour les sous-routes dans go-chi

Dans go-chi, le framework Web du langage Go, la configuration de différents middlewares pour les sous-routes est une exigence courante. Le middleware est une fonction qui gère les requêtes et les réponses HTTP et peut effectuer certaines opérations supplémentaires avant et après que la requête atteigne le processeur cible. En définissant différents middlewares pour différents sous-itinéraires, nous pouvons personnaliser chaque sous-itinéraire en fonction des besoins de l'entreprise. Dans cet article, nous présenterons comment configurer de manière flexible différents middleware pour les sous-routes dans go-chi afin d'obtenir un traitement de routage plus flexible.

Contenu de la question

J'ai un serveur proxy qui peut être désactivé via la configuration, en utilisant mustBeSecure. Je veux que ce proxy se comporte différemment dans un certain sous-domaine : "/application/health", le rendant toujours dangereux. Tous les changements que j'ai essayés jusqu'à présent ont échoué. Existe-t-il un moyen de configurer un groupe différent pour « /application/health » qui utilise toujours le proxy mais ne nécessite jamais d'authentification ?

router := chi.NewRouter()
router.Route("/", func(r chi.Router) {
    r.Use(chimw.Recoverer)
    router.Use(hlog.NewHandler(log.Logger))
    if mustBeSecure() {
        r.Use(keycloak.MustStandardKeycloakAuth("url"))
    }
    setProxy(r)
    r.Group(func(r chi.Router) {
        r.Get("/health", handleHealth())
    })
})
return http.ListenAndServe("0.0.0.0", router)

Comme demandé, voici un exemple de setProxy()

func setProxy(r chi.Router) {
    r.Route("/application", func(r chi.Router) {
        r.Use(func(next http.Handler) http.Handler {
            return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                ctx := context.WithValue(r.Context(), "target", "http:locahost:9999")
                r = r.WithContext(ctx)
                next.ServeHTTP(w, r)
            })
        })
        r.HandleFunc("/*", httputil.ReverseProxy{}.ServeHTTP)
    })
}

Solution de contournement

Je crois que vous essayez ceci.

• Utilisez le routeur pour tous les /application itinéraires
• Déclaration GET /health
• Créez un groupe (en /application) pour tous les autres itinéraires
• Appliquer un middleware conditionnel

Pour une compréhension plus facile, j'ai légèrement simplifié le code. Vous pouvez toujours utiliser la fonction setProxy.

func main() {
    proxy, err := NewProxy("http://localhost:4422")
    if err != nil {
        panic(err)
    }

    router := chi.NewRouter()

    router.Get("/health", handleHealth)

    router.Route("/application", func(r chi.Router) {
        r.Get("/health", ProxyRequestHandler(proxy))

        r.Group(func(r chi.Router) {
            if mustBeSecure() {
                r.Use(keycloak.MustStandardKeycloakAuth("url"))
            }
            r.HandleFunc("/*", ProxyRequestHandler(proxy))
        })
    })

    http.ListenAndServe("0.0.0.0:4411", router)
}

func NewProxy(targetHost string) (*httputil.ReverseProxy, error) {
    targetUrl, err := url.Parse(targetHost)
    if err != nil {
        return nil, err
    }

    return httputil.NewSingleHostReverseProxy(targetUrl), nil
}

func ProxyRequestHandler(proxy *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
    return func(w http.ResponseWriter, r *http.Request) {
        proxy.ServeHTTP(w, r)
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!