CORS- und Panic-Recovery-Middleware
Ursprungsübergreifende Richtlinien und das Abfangen von Panics
CORS- und Panic-Recovery-Middleware ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist CORS?
Cross-Origin Resource Sharing (CORS) ist ein Browsersicherheitsmechanismus, der einschränkt, welche Origins HTTP-Anfragen an Ihre API senden dürfen. Der Server aktiviert dies, indem er Response-Header setzt.
CORS-Preflight
Vor einer Cross-Origin-Anfrage mit einem benutzerdefinierten Header oder einer nicht einfachen Methode sendet der Browser eine OPTIONS-Preflight-Anfrage. Ihre Middleware muss OPTIONS verarbeiten und 200 mit CORS-Headern zurückgeben.
CORS-Middleware
Eine einfache CORS-Middleware für die Entwicklung:
func CORS(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "https://myapp.com")
w.Header().Set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Authorization,Content-Type")
if r.Method == http.MethodOptions {
w.WriteHeader(http.StatusOK); return
}
next.ServeHTTP(w, r)
})
}Zulässige Origins
Verwenden Sie Access-Control-Allow-Origin: * nicht, wenn Credentials (Cookies, Authorization-Header) beteiligt sind – verwenden Sie stattdessen eine explizite Origin. Prüfen Sie bei mehreren Origins gegen eine Whitelist.
allowedOrigins := map[string]bool{
"https://app.example.com": true,
"https://dev.example.com": true,
}
if allowedOrigins[r.Header.Get("Origin")] {
w.Header().Set("Access-Control-Allow-Origin", r.Header.Get("Origin"))
}Access-Control-Allow-Credentials
Cookies und Authorization-Header über Cross-Origin-Anfragen mitsenden dürfen:
w.Header().Set("Access-Control-Allow-Credentials", "true")rs/cors-Bibliothek
Verwenden Sie die Bibliothek github.com/rs/cors für CORS auf Produktionsniveau mit flexibler Origin-Zuordnung, Credential-Unterstützung und Preflight-Caching.
c := cors.New(cors.Options{
AllowedOrigins: []string{"https://example.com"},
AllowedMethods: []string{"GET","POST","PUT","DELETE"},
AllowedHeaders: []string{"Authorization","Content-Type"},
AllowCredentials: true,
})
handler := c.Handler(mux)Panic-Recovery-Middleware
Panics abfangen, damit der Server nicht abstürzt und alle aktiven Verbindungen verliert:
func Recovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if rec := recover(); rec != nil {
log.Printf("panic: %v\n%s", rec, debug.Stack())
http.Error(w, "Internal Server Error", 500)
}
}()
next.ServeHTTP(w, r)
})
}runtime/debug.Stack
Beim Auftreten eines Panics den vollständigen Stacktrace aller Goroutines ausgeben, um die Grundursache zu ermitteln:
import "runtime/debug"
log.Printf("panic: %v\n%s", rec, debug.Stack())Sentry-Integration
Panics innerhalb der Recovery-Middleware an Sentry oder einen ähnlichen Dienst zur Fehlerverfolgung senden, bevor 500 an den Client zurückgegeben wird.
Reihenfolge: Recovery außen
Registrieren Sie Recovery immer als äußerste (zuerst angewendete) Middleware, damit Panics aus allen anderen Middleware-Komponenten und Handlern abgefangen werden.
handler := Recovery(RequestID(Logger(Auth(mux))))Panic-Recovery testen
Schreiben Sie einen Handler, der absichtlich einen Panic auslöst, rufen Sie ihn über die Middleware in einem httptest auf und prüfen Sie, ob die Antwort 500 lautet.
panicHandler := http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) { panic("test") })
w := httptest.NewRecorder()
Recovery(panicHandler).ServeHTTP(w, httptest.NewRequest("GET", "/", nil))
assert.Equal(t, 500, w.Code)Kurzer Check
Warum muss die Panic-Recovery-Middleware die äußerste Schicht sein?
Zusammenfassung: CORS und Panic-Recovery
Wichtige Punkte:
- CORS: Access-Control-Allow-*-Header setzen und OPTIONS-Preflight verarbeiten
- Explizite Origin statt * verwenden, wenn Credentials beteiligt sind
- Recovery: defer recover() + Stacktrace protokollieren + 500 zurückgeben
- Recovery muss die äußerste Middleware sein
Häufig gestellte Fragen
Ist die Lektion „CORS- und Panic-Recovery-Middleware“ kostenlos?
Ja — der vollständige Text von „CORS- und Panic-Recovery-Middleware“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „CORS- und Panic-Recovery-Middleware“?
Ursprungsübergreifende Richtlinien und das Abfangen von Panics Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.
Wie lange dauert die Lektion „CORS- und Panic-Recovery-Middleware“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen der HTTP-Middleware-Kette
- Logging- und Request-ID-Middleware
- Middleware für Authentifizierung und Rate Limiting
- CORS- und Panic-Recovery-Middleware