CORS grpc Gateway GoLang

php-Editor Strawberry stellt Ihnen das CORS gRPC-Gateway GoLang vor. CORS, kurz für Cross-Origin Resource Sharing, ist ein Mechanismus, der verwendet wird, um domänenübergreifende Anfragen in Browsern zu stellen. gRPC ist ein leistungsstarkes Open-Source-RPC-Framework (Remote Procedure Call), das zum Aufbau verteilter Systeme verwendet werden kann. GoLang ist eine leistungsstarke Programmiersprache mit hoher Parallelität und Einfachheit. CORS gRPC Gateway GoLang kombiniert CORS und gRPC, um das Gateway über die Go-Sprache zu implementieren und domänenübergreifende Anforderungen zu implementieren. In diesem Artikel stellen wir die Prinzipien und die Verwendung des CORS gRPC-Gateways GoLang im Detail vor, um Ihnen zu helfen, diese Technologie besser zu verstehen und anzuwenden.

Frageninhalt

Ich habe ein vue.js 3-Frontend und rufe das Golang-Backend über grpc-gateway auf. Ich mache das schon eine Weile, aber ich sehe das Licht am Ende des Tunnels.

Ich habe derzeit ein Herzproblem. Allerdings lese ich widersprüchliche Informationen zum Umgang damit. Deshalb wollte ich etwas posten, von dem ich hoffe, dass es für alle hilfreich ist.

Hier ist der Code, wie ich den Mux-Server für grpc (Gateway) initialisiere

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

}

Hier sollte ich meiner Meinung nach die CORS-Konfiguration hinzufügen, bin mir aber nicht sicher, ob ich sie so in der server.go-Datei eingerichtet habe..

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",
    )
})

Konsolenfehler:

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'

Ich weiß nicht, wo ich so etwas hinzufügen soll

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

Ich habe das Gefühl, dass etwas in das Golang-GrPC-Gateway integriert sein sollte, aber ich kann nichts finden?

Für Vorschläge wäre ich sehr dankbar.

-----Update 1-----

Ich habe es versucht

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

und

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

und

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

Kombiniert

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

Habe immer noch das gleiche Problem. Sehr frustrierend

Problemumgehung

Basierend auf dem letzten Fehler, den Sie in den Kommentaren angegeben haben:

Der Zugriff auf xmlhttprequest bei „localhost:8080/v1/test“ vom Ursprung „localhost:9000“ wurde durch die CORS-Richtlinie blockiert: Die Antwort auf die Preflight-Anfrage hat eine Zugriffskontrollprüfung nicht bestanden: Sie hat keinen normalen HTTP-Status.

Ihr Browser sendet eine Preflight-Anfrage (options http-Methode), um festzustellen, ob die erforderliche Cross-Origin-Anfrage gestellt werden kann.

Der Server antwortet mit einer Nicht-2xx-Antwort.

Ich vermute, das liegt daran, dass Ihre enablecors-Funktion die Anfrage an den grpc-gateway-Handler weiterleitet, der mit der enablecors 函数正在将请求传播到 grpc-gateway 处理程序，该处理程序对 options http-Methode nicht zufrieden ist und einen Fehlerstatus zurückgibt, wahrscheinlich:

< 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":[]}

Um dies zu vermeiden, möchten Sie die Anfrage nicht weiter verbreiten, wenn Sie eine Preflight-Anfrage stellen, wie

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

Aber, das Obige ist möglicherweise immer noch keine vernünftige Implementierung der Cors-Verarbeitung. Sie sollten hierfür ein vorhandenes Paket verwenden, z. B. github.com/rs/cors, das dies sinnvoll handhabt und mögliche Fallstricke usw. behebt.

Also importieren

und gehen Sie wie folgt vor: github.com/rs/cors

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

sollte dir dabei helfen, alles passieren zu lassen. Mit dieser Bibliothek können Sie bestimmte Ursprünge, http-Methoden usw. an Ihre Bedürfnisse anpassen.

Das obige ist der detaillierte Inhalt vonCORS grpc Gateway GoLang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!