gRPC-Interceptoren und Metadaten
Authentifizierung, Logging-Middleware und gRPC-Metadaten
gRPC-Interceptoren und Metadaten 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 sind Interceptors?
gRPC-Interceptoren (Middleware) werden vor oder nach RPC-Handlern ausgeführt. Sie ergänzen querschnittliche Funktionen wie Protokollierung, Validierung von Authentifizierungstoken, Metriken, Panic-Recovery und Tracing.
Unärer Server-Interceptor
Ein unärer Server-Interceptor umschließt den Handler mit zusätzlicher Logik:
func LoggingInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
log.Printf("RPC: %s", info.FullMethod)
resp, err := handler(ctx, req)
log.Printf("done: %v", err)
return resp, err
}
grpcSrv := grpc.NewServer(grpc.UnaryInterceptor(LoggingInterceptor))Stream-Server-Interceptor
Ähnlich wie bei einem unären Aufruf, aber der Stream-Handler wird umschlossen:
func StreamLogging(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
log.Printf("stream: %s", info.FullMethod)
return handler(srv, ss)
}Interceptoren verketten
Verwenden Sie grpc.ChainUnaryInterceptor (Go gRPC v1.38+), um mehrere Interceptoren in einer bestimmten Reihenfolge anzuwenden:
grpcSrv := grpc.NewServer(
grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor, MetricsInterceptor),
)Client-Interceptoren
Unäre Interceptoren auf der Clientseite umschließen ausgehende Aufrufe — nützlich zum Einfügen von Authentifizierungstoken, für Wiederholungen oder Tracing-Header:
conn, _ := grpc.NewClient(addr,
grpc.WithUnaryInterceptor(ClientAuthInterceptor),
grpc.WithTransportCredentials(insecure.NewCredentials()),
)gRPC-Metadaten
Metadaten bestehen aus Schlüssel-Wert-Paaren, die zusammen mit einem RPC gesendet werden, ähnlich wie HTTP-Header. Verwenden Sie auf dem Client metadata.New und metadata.NewOutgoingContext.
md := metadata.New(map[string]string{"authorization": "Bearer " + token})
ctx := metadata.NewOutgoingContext(context.Background(), md)Metadaten auf dem Server lesen
Extrahieren Sie eingehende Metadaten mit metadata.FromIncomingContext:
md, ok := metadata.FromIncomingContext(ctx)
if !ok { return nil, status.Error(codes.Unauthenticated, "no metadata") }
token := md["authorization"]Metadaten vom Server senden
Senden Sie Antwort-Header und Trailer vom Server mit grpc.SetHeader und grpc.SetTrailer:
grpc.SetHeader(ctx, metadata.Pairs("x-request-id", requestID))go-grpc-middleware
Die Bibliothek github.com/grpc-ecosystem/go-grpc-middleware/v2 stellt fertige Interceptoren bereit, unter anderem für Recovery, Protokollierung (zap/logrus) und Authentifizierung.
Muster für einen Auth-Interceptor
Extrahieren und validieren Sie ein Token in einem Interceptor und hängen Sie den Benutzer für nachgelagerte Handler an den Kontext an:
func AuthInterceptor(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (interface{}, error) {
md, _ := metadata.FromIncomingContext(ctx)
if !validateToken(md["authorization"]) {
return nil, status.Error(codes.Unauthenticated, "invalid token")
}
return handler(ctx, req)
}Panic-Recovery-Interceptor
Umschließen Sie Handler, um Panics abzufangen und stattdessen einen Internal-Fehler zurückzugeben, anstatt den Prozess abstürzen zu lassen:
defer func() {
if r := recover(); r != nil {
err = status.Errorf(codes.Internal, "panic: %v", r)
}
}()Kurzer Test
Wie übertragen Sie Authentifizierungstoken zwischen einem gRPC-Client und einem Server?
Zusammenfassung: gRPC-Interceptoren und Metadaten
Wichtige Punkte:
- Unärer Interceptor: func(ctx, req, info, handler) (resp, error)
- grpc.ChainUnaryInterceptor für mehrere Interceptoren
- Metadaten bestehen aus Schlüssel-Wert-Paaren und sind mit HTTP-Headern vergleichbar
- Auth-Interceptor: Metadaten extrahieren → validieren → Benutzer zum Kontext hinzufügen
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „gRPC-Interceptoren und Metadaten“ kostenlos?
Ja — der vollständige Text von „gRPC-Interceptoren und Metadaten“ 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 „gRPC-Interceptoren und Metadaten“?
Authentifizierung, Logging-Middleware und gRPC-Metadaten 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 „gRPC-Interceptoren und Metadaten“?
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
- Protocol Buffers und .proto-Dateien
- Einen unären gRPC-Service implementieren
- Server- und Client-Streaming
- gRPC-Interceptoren und Metadaten