Application Golang : l'en-tête 'Access-Control-Allow-Origin' n'existe pas sur la ressource demandée

Contenu de la question

Chaque fois que j'essaie d'envoyer une requête HTTP depuis une application Angular vers un serveur Go, j'obtiens la réponse suivante :

La réponse à l'échec de la vérification du contrôle d'accès de la demande de contrôle en amont : l'en-tête « Access-Control-Allow-Origin » n'est pas présent sur la ressource demandée.

J'ai ajouté les en-têtes détaillés dans la réponse d'erreur, mais l'erreur persiste.

server.go

package rest

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "sync"
    "syscall"

    "github.com/gorilla/mux"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/configs"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/http/rest/handlers"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/pkg/db"
    "github.com/rs/cors"
    "github.com/sirupsen/logrus"
)

type Server struct {
    logger *logrus.Logger
    router *mux.Router
    config configs.Config
}

func NewServer() (*Server, error) {
    config, err := configs.NewParsedConfig()

    if err != nil {
        return nil, err
    }

    database, err := db.Connect(db.ConfigDB{
        Host:     config.Database.Host,
        Port:     config.Database.Port,
        User:     config.Database.User,
        Password: config.Database.Password,
        Name:     config.Database.Name,
    })

    if err != nil {
        return nil, err
    }

    log, err := NewLogger()

    if err != nil {
        return nil, err
    }

    router := mux.NewRouter()

    handlers.Register(router, log, database)

    server := Server{
        logger: log,
        config: config,
        router: router,
    }

    return &server, nil
}

func (s *Server) Run(ctx context.Context) error {
    cors := cors.New(cors.Options{
        AllowedMethods: []string{"GET, POST"},
        AllowedOrigins: []string{"http://localhost:4200"},
        AllowedHeaders: []string{"Content-Type", "Accept"},
    })

    server := http.Server{
        Addr:    fmt.Sprintf(":%d", s.config.ServerPort),
        Handler: cors.Handler(s.router),
    }

    stopServer := make(chan os.Signal, 1)

    signal.Notify(stopServer, syscall.SIGINT, syscall.SIGTERM)

    defer signal.Stop(stopServer)

    serverErrors := make(chan error, 1)

    var wg sync.WaitGroup
    wg.Add(1)

    go func(wg *sync.WaitGroup) {
        defer wg.Done()
        s.logger.Printf("REST API listening on  %d", s.config.ServerPort)
        serverErrors <- server.ListenAndServe()
    }(&wg)

    select {
    case err := <-serverErrors:
        return fmt.Errorf("error: starting REST API server %w", err)
    case <-stopServer:
        s.logger.Warn("server recieved STOP signal")

        err := server.Shutdown(ctx)

        if err != nil {
            return fmt.Errorf("graceful shutdown did not complete: %w", err)
        }

        wg.Wait()
        s.logger.Info("server was shutdown gracefully")
    }

    return nil
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Access-Control-Allow-Origin", "http://localhost:4200")
    w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
    w.Header().Set("Access-Control-Allow-Credentials", "true")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, Accept, origin, Cache-Control, X-Requested-With")

    if r.Method == "OPTIONS" {
        return
    }

    s.router.ServeHTTP(w, r)
}

route.go

package handlers

import (
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    "github.com/sirupsen/logrus"
)

func Register(r *mux.Router, lg *logrus.Logger, db *sqlx.DB) {
    handler := newHandler(lg, db)

    r.Use(handler.MiddlewareLogger())
    r.HandleFunc("/weather/current", handler.GetCurrentWeather()).Methods(http.MethodPost)
    r.HandleFunc("/weather/welcome", handler.Test()).Methods(http.MethodGet)
}

Bonne réponse

La première question que j'ai remarquée était :

AllowedMethods: []string{"GET, POST"},

Cela devrait être :

AllowedMethods: []string{"GET", "POST"}, (或者稍微不易出错的 []string{http.MethodGet, http.MethodPost})

Selon la Documentation, voici la valeur par défaut (vous pouvez donc l'omettre) :

Ma prochaine question est "Quelle est l'origine" ; CORS est "Partage de ressources entre origines croisées" et vise à "empêcher les applications Web clientes exécutées à partir d'une origine d'obtenir des données récupérées à partir d'une autre origine", alors comprenez l'origine du La page faisant la demande est très importante. Vous autorisez http://localhost:4200 (AllowedOrigins: []string{"http://localhost:4200"}) 所以我假设您有两个服务器在本地主机上运行（但如果这不是案件）。如果您希望允许所有来源，请使用 "*" ; Pour les tests, j'utiliserai test-cors.org - allez simplement sur le site Web, entrez l'URL, par exemple "http://127.0.0.1:8080/weather/welcome", entrez "URL distante " " et cliquez sur "Envoyer la demande" pour tester.

Votre code est un peu déroutant (par exemple (s *Server) ServeHTTP non utilisé - veuillez essayer de fournir exemples minimaux et reproductibles lorsque vous demandez ici), j'ai donc un peu simplifié les choses et j'espère que ce qui suit vous indiquera la bonne direction.

package main

import (
    "context"
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/rs/cors"
)

func main() {
    s, err := NewServer()
    if err != nil {
        panic(err)
    }
    s.Run(context.Background())
}

type Server struct {
    router *mux.Router
}

func NewServer() (*Server, error) {
    router := mux.NewRouter()
    Register(router)
    server := Server{
        router: router,
    }
    return &server, nil
}

func (s *Server) Run(ctx context.Context) {
    cors := cors.New(cors.Options{
        AllowedMethods: []string{http.MethodGet, http.MethodPost},
        AllowedOrigins: []string{"https://www.php.cn/link/9113c52c5f26af1782e6bf7c56973ef4"},
        // AllowedOrigins: []string{"*"},
        AllowedHeaders: []string{"Content-Type", "Accept"},
    })

    server := http.Server{
        Addr:    fmt.Sprintf(":%d", 8080),
        Handler: cors.Handler(s.router),
    }

    fmt.Println(server.ListenAndServe())
}

type handler struct{}

func Register(r *mux.Router) {
    handler := handler{}

    r.HandleFunc("/", handler.Index).Methods(http.MethodGet)
    r.HandleFunc("/weather/welcome", handler.Test).Methods(http.MethodGet)
}

// Index - Provide a simple page with a link to the other page to simplify testing
func (h *handler) Index(w http.ResponseWriter, _ *http.Request) {
    w.Write([]byte(`<a href="weather/welcome" >Test Link</a>`))
}

// The real page
func (h *handler) Test(w http.ResponseWriter, _ *http.Request) {
    fmt.Println("Test Called")
    w.Write([]byte("all OK"))
}

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!