Passerelle CORS grpc GoLang

l'éditeur php Strawberry vous présente la passerelle CORS gRPC GoLang. CORS, abréviation de Cross-Origin Resource Sharing, est un mécanisme utilisé pour effectuer des requêtes inter-domaines dans les navigateurs. gRPC est un framework d'appel de procédure à distance (RPC) open source hautes performances qui peut être utilisé pour créer des systèmes distribués. GoLang est un langage de programmation puissant avec une concurrence et une simplicité élevées. CORS gRPC Gateway GoLang combine CORS et gRPC pour implémenter la passerelle via le langage Go afin d'implémenter des requêtes inter-domaines. Dans cet article, nous présenterons en détail les principes et l'utilisation de la passerelle CORS gRPC GoLang pour vous aider à mieux comprendre et appliquer cette technologie.

Contenu de la question

J'ai un frontend vue.js 3 et j'appelle le backend golang via grpc-gateway. Je fais ça depuis un moment, mais je vois la lumière au bout du tunnel.

Je suis actuellement confronté à un problème de cors. Cependant, je lis des informations contradictoires sur la façon de gérer ce problème. C'est pourquoi je voulais publier quelque chose qui, je l'espère, sera utile à tout le monde.

Voici le code pour initialiser le serveur multiplex pour grpc (passerelle)

func runhttpserver(server *http.server, httpendpoint, grpcendpoint, swaggerpath string) (err error) {
    server.addr = httpendpoint

    ctx, cancel := context.withcancel(context.background())

    defer cancel()

    // register groc server endpoint
    mux := runtime.newservemux(
        runtime.witherrorhandler(func(ctx context.context,
            mux *runtime.servemux,
            marshaler runtime.marshaler,
            w http.responsewriter, r *http.request,
            err error,
        ) {
            s, ok := status.fromerror(err)
            if ok {
                if s.code() == codes.unavailable {
                    err = status.error(codes.unavailable, errunavailable)
                }
            }

            runtime.defaulthttperrorhandler(ctx, mux, marshaler, w, r, err)

        }),
    )

    opts := []grpc.dialoption{
        grpc.withtransportcredentials(insecure.newcredentials()),
        grpc.withchainunaryinterceptor(),
    }

    if err = api.registerapiservicehandlerfromendpoint(ctx, mux, grpcendpoint, opts); err != nil {
        return
    }

    swmux := http.newservemux()
    swmux.handle("/", mux)
    serveswagger(swmux, swaggerpath)

    server.handler = swmux

    return server.listenandserve()

}

C'est ici que je pense que la configuration cors devrait être ajoutée, mais je ne suis pas sûr que ce soit ainsi que je l'ai configurée dans le fichier server.go..

var httpserver http.server

// run http server with grpc gateway
g.go(func() error {
    fmt.println("starting http sever (port {}) and grpc gateway (port {})",
        strconv.itoa(cfg.server.httpport),
        strconv.itoa(cfg.server.grpcport),
    )

    return rest.runhttpserver(
        &httpserver,
        ":"+strconv.itoa(cfg.server.httpport),
        ":"+strconv.itoa(cfg.server.grpcport),
        "/webapi",
    )
})

Erreur de console :

access to xmlhttprequest at 'http://localhost:8080/v1/test' from origin 'http://localhost:9000' has been blocked by cors policy: response to preflight request doesn't pass access control check: no 'access-control-allow-origin'

Je ne sais pas où ajouter quelque chose comme ça

func enablecors(w *http.responsewriter) {
    (*w).header().set("access-control-allow-origin", "*")
}

J'ai l'impression qu'il devrait y avoir quelque chose d'intégré à la passerelle golang grpc, mais je ne trouve rien ?

Toutes suggestions seraient grandement appréciées.

-----Mise à jour 1-----

Je l'ai essayé

func enablecors(h http.handler) http.handler {
    return http.handlerfunc(func(w http.responsewriter, r *http.request) {
        w.header().set("access-control-allow-origin", "http://localhost:9000")
        w.header().set("access-control-allow-methods", "get, put, post, delete, head, options")
        h.servehttp(w, r)
    })
}

et

func enablecors(h http.handler) http.handler {
    return http.handlerfunc(func(w http.responsewriter, r *http.request) {
        w.header().set("access-control-allow-origin", "*")
        w.header().set("access-control-allow-methods", "get, put, post, delete, head, options")
        h.servehttp(w, r)
    })
}

et

func enablecors(h http.handler) http.handler {
    return http.handlerfunc(func(w http.responsewriter, r *http.request) {
        w.header().set("access-control-allow-origin", "http://localhost")
        w.header().set("access-control-allow-methods", "get, put, post, delete, head, options")
        h.servehttp(w, r)
    })
}

Combiné

func serveSwagger(mux *http.ServeMux, swaggerPath string) {
    fileServer := http.FileServer(http.Dir(swaggerPath))
    prefix := "/swagger-ui"
    mux.Handle(prefix, http.StripPrefix(prefix, fileServer))
}

J'ai toujours le même problème.. Très frustrant

Solution de contournement

Basée sur la dernière erreur que vous avez fournie dans les commentaires :

L'accès à xmlhttprequest à 'localhost:8080/v1/test' depuis l'origine 'localhost:9000' a été bloqué par la politique cors : la réponse à la demande de contrôle en amont a échoué à une vérification de contrôle d'accès : elle n'a pas de statut http normal.

Votre navigateur envoie une demande de contrôle en amont (options méthode http) pour déterminer si la demande d'origine croisée requise peut être effectuée.

Le serveur répond avec une réponse non-2xx.

Je soupçonne que cela est dû au fait que votre fonction enablecors propage la requête au gestionnaire grpc-gateway, qui n'est pas satisfait de la méthode enablecors 函数正在将请求传播到 grpc-gateway 处理程序，该处理程序对 options http et renvoie probablement un statut d'erreur :

< http/1.1 501 not implemented
< content-type: application/json
< vary: origin
< date: fri, 25 nov 2022 11:17:52 gmt
< content-length: 55
< 
{"code":12,"message":"method not allowed","details":[]}

Donc, pour éviter cela, vous souhaitez ne pas propager davantage la demande lorsque vous effectuez une demande de contrôle en amont, comme

func enablecors(h http.handler) http.handler {
    return http.handlerfunc(func(w http.responsewriter, r *http.request) {
        w.header().set("access-control-allow-origin", "http://localhost:9000")
        w.header().set("access-control-allow-methods", "get, put, post, delete, head, options")
        if r.method == http.methodoptions {
            w.writeheader(http.statusnocontent)
            return
        }
        h.servehttp(w, r)
    })
}

Mais, ce qui précède n'est peut-être toujours pas une implémentation raisonnable de la gestion des cors. Vous devez utiliser un package existant pour cela, tel que github.com/rs/cors, qui gérera cela de manière judicieuse et gérera tous les pièges potentiels, etc.

Alors importez

et procédez comme suit : github.com/rs/cors

server.Handler = cors.AllowAll().Handler(swMux)

devrait vous inciter à commencer à tout laisser passer. Cette bibliothèque vous permettra d'adapter des origines spécifiques, des méthodes http, etc. à vos besoins.

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!