Aktivieren Sie CORS in GoLang
- GoLang CORS
- Aktivieren Sie CORS in GoLang
- CORS-Paket in GoLang
-
Verwenden Sie die Methoden
GETundPOSTmit CORS in Go
Dieses Tutorial zeigt, wie Sie CORS in GoLang aktivieren und verwenden.
GoLang CORS
Cross-Origin Resource Sharing (CORS) ist ein HTTP-Header-basierter Prozess, der die Ursprünge definiert, von denen die Browser Ressourcen laden und verwenden dürfen. Der CORS wird verwendet, um die Same-origin policy-Richtlinie zu lockern, die es JS-Skripten auf einer Seite erlaubt, auf Daten auf anderen Seiten zuzugreifen.
Die Same-Origin-Policy stellt sicher, dass beide Webseiten denselben Ursprung haben. Diese Richtlinie trägt zur Verbesserung der Sicherheit bei, indem bösartige Dokumente isoliert werden.
Das CORS wird verwendet, um die gleiche Ursprungsrichtlinie zu lockern, indem die Header verwendet werden, wie in der Tabelle gezeigt:
| Header | Typ | Beschreibung |
|---|---|---|
Origin |
Anfrage | Wird verwendet, um dem Server den Ursprung der Anfrage anzuzeigen. |
Access-Control-Request-Method |
Anfrage | Wird verwendet, um die HTTP-Methoden zum Implementieren der Anforderung an den Server anzugeben. |
Access-Control-Request-Headers |
Anfrage | Wird verwendet, um die Header in der Anfrage an den Server anzugeben. |
Access-Control-Allow-Origin |
Antwort | Wird für die vom Server zugelassenen Ursprünge verwendet. |
Access-Control-Allow-Methods |
Antwort | Wird für die Liste der durch Kommas getrennten Methoden verwendet, die vom Server zugelassen werden. |
Access-Control-Allow-Headers |
Antwort | Wird für die Liste der durch Kommas getrennten Header verwendet, die vom Server zugelassen werden. |
Access-Control-Expose-Headers |
Antwort | Wird für die Liste der durch Kommas getrennten Header verwendet, die es dem Client ermöglichen, auf eine Antwort zuzugreifen. |
Access-Control-Max-Age |
Antwort | Wird verwendet, um den Server darüber zu informieren, wie viele Sekunden es dauert, die Antwort auf die Preflight-Anfrage zwischenzuspeichern. |
Access-Control-Allow-Credentials |
Antwort | Wird verwendet, um die Anmeldeinformationen für den Server zuzulassen oder einzuschränken. |
Aktivieren Sie CORS in GoLang
Wir können eine Funktion in Go implementieren, in der wir unsere CORS-Richtlinie implementieren, indem wir das net/http-Paket von GoLang verwenden. Folgen Sie dem schrittweisen Prozess, um CORS in GO zu aktivieren:
-
Erstellen Sie eine Anwendung, die auf dem lokalen Host ausgeführt wird, mit einer Portnummer, die Header enthält, die von anderen Seiten auf Ressourcen des aktuellen Servers zugreifen. Siehe die Überschriften:
Response_Writer.Header().Set("Content-Type", "text/plain; charset=utf-8") Response_Writer.Header().Set("Access-Control-Allow-Origin", "http://127.0.1.1:5555") Response_Writer.Header().Set("Access-Control-Max-Age", "10") -
Wie wir sehen können, aktivieren wir unsere CORS-Richtlinie, sodass das JS-Skript von
http://127.0.1.1:5555auf Daten von unseren Seiten oder Ressourcen zugreifen kann. Es ist besser, diese Header in einer Methode zu behalten, damit wir die CORS-Richtlinie für unseren Server implementieren können. -
Legen Sie nun die CORS-Richtlinie für unseren Server fest; Die Funktion für Header ist beispielsweise
DelftstackHandler. Mach das jetzt:http.HandleFunc("/delftstack", DelftstackHandler) log.Fatal(http.ListenAndServe(":3000", nil))
Das log.Fatal(http.ListenAndServe(":3000", nil)) legt die CORS-Richtlinie für unseren Server fest. Lassen Sie uns dieses Beispiel implementieren und die Ausgabe sehen.
Die GoLang-Datei für die CORS-Richtlinie:
package main
import (
"fmt"
"log"
"net/http"
)
func main() {
http.HandleFunc("/delftstack", DelftstackHandler)
log.Println("Listening the request..")
log.Fatal(http.ListenAndServe(":3000", nil))
}
func DelftstackHandler(Response_Writer http.ResponseWriter, _ *http.Request) {
Response_Writer.Header().Set("Content-Type", "text/plain; charset=utf-8")
Response_Writer.Header().Set("Access-Control-Allow-Origin", "http://127.0.1.1:5555")
Response_Writer.Header().Set("Access-Control-Max-Age", "10")
fmt.Fprintf(Response_Writer, "Hello, this is delftstack.com!")
}
Die HTML/JS-Datei für die Antwort:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Delftstack</title>
</head>
<body>
<script>
async function doRequest() {
let localhost_url = 'http://localhost:3000/delftstack';
let page_response = await fetch(localhost_url);
if (page_response.ok) {
let text = await page_response.text();
return text;
} else {
return `HTTP error: ${page_response.status}`;
}
}
doRequest().then(data => {
document.getElementById("print_output").innerText = data;
});
</script>
<div id="print_output">
</div>
</body>
</html>
Der obige Code schreibt die Antwort Hallo, das ist delftstack.com! aus dem Go-Code auf der HTML/JS-Seite.
Siehe die Ausgabe:
CORS-Paket in GoLang
Ein Drittanbieterpaket CORS wird verwendet, um die ursprungsübergreifende gemeinsame Nutzung von Ressourcen zu implementieren, indem der NET/HTTP-Handler definiert wird. Bevor Sie dieses Paket verwenden können, müssen wir es installieren.
Verwenden Sie den folgenden Befehl:
go get github.com/rs/cors
Sobald es erfolgreich installiert ist, können wir CORS in unserem Code verwenden. Versuchen wir es mit einem einfachen Beispiel:
package main
import (
"net/http"
"github.com/rs/cors"
)
func main() {
Demo_Mux := http.NewServeMux()
Demo_Mux.HandleFunc("/", func(Response_Writer http.ResponseWriter, Req *http.Request) {
Response_Writer.Header().Set("Content-Type", "application/json")
Response_Writer.Write([]byte("{\"hello!\": \"This is delftstack.com\"}"))
})
DemoHandler := cors.Default().Handler(Demo_Mux)
http.ListenAndServe(":3000", DemoHandler)
}
Im obigen Code richtet cors.Default() eine Middleware mit Standardoptionen ein, bei der alle Ursprünge mit einfachen Methoden wie GET und POST akzeptiert werden.
Sehen Sie sich die Ausgabe für den obigen Code an:
Verwenden Sie die Methoden GET und POST mit CORS in Go
Wir können auch die Methoden GET und POST verwenden, um die Anfrage per CORS zu senden. Diese müssen wir im CORS über das Feld AllowedMethods zuweisen.
Sehen wir uns das Beispiel an:
package main
import (
"net/http"
"github.com/rs/cors"
)
func main() {
Demo_Mux := http.NewServeMux()
Demo_CORS := cors.New(cors.Options{
AllowedOrigins: []string{"*"}, //all
AllowedMethods: []string{http.MethodPost, http.MethodGet},
AllowedHeaders: []string{"*"}, //all
AllowCredentials: false, //none
})
Demo_Mux.HandleFunc("/delftstack", func(Response_Writer http.ResponseWriter, r *http.Request) {
Response_Writer.Header().Set("Content-Type", "application/json")
Response_Writer.Write([]byte("{\"hello!\": \"This is delftstack.com\"}"))
})
Demo_Handler := Demo_CORS.Handler(Demo_Mux)
http.ListenAndServe(":3000", Demo_Handler)
}
Der obige Code verwendet das CORS-Paket, um die Richtlinie zu implementieren und die beiden Methoden GET und POST zum Senden der Anfrage zu aktivieren.
Siehe die Ausgabe:
Sheeraz is a Doctorate fellow in Computer Science at Northwestern Polytechnical University, Xian, China. He has 7 years of Software Development experience in AI, Web, Database, and Desktop technologies. He writes tutorials in Java, PHP, Python, GoLang, R, etc., to help beginners learn the field of Computer Science.
LinkedIn Facebook