Go Academy · Lektion

gRPC-interceptors och metadata

Autentisering, middleware för loggning och gRPC-metadata

Lektion 4 av 413 steg

gRPC-interceptors och metadata är en gratis lektion i Go Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Go Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad är interceptorer?

gRPC-interceptorer (middleware) körs före eller efter RPC-hanterare. De lägger till tvärgående funktioner som loggning, validering av autentiseringstoken, mätvärden, återställning efter panik och spårning.

Unary-interceptor på servern

En unary-interceptor på servern omsluter hanteraren med ytterligare 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-interceptor på servern

Påminner om unary, men omsluter strömningshanteraren:

func StreamLogging(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
    log.Printf("stream: %s", info.FullMethod)
    return handler(srv, ss)
}

Kedja interceptorer

Använd grpc.ChainUnaryInterceptor (Go gRPC v1.38+) för att tillämpa flera interceptorer i ordning:

grpcSrv := grpc.NewServer(
    grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor, MetricsInterceptor),
)

Klientinterceptorer

Unary-interceptorer på klientsidan omsluter utgående anrop — användbart för att lägga till autentiseringstoken, återförsök eller spårningshuvuden:

conn, _ := grpc.NewClient(addr,
    grpc.WithUnaryInterceptor(ClientAuthInterceptor),
    grpc.WithTransportCredentials(insecure.NewCredentials()),
)

gRPC-metadata

Metadata är nyckel-värde-par som skickas tillsammans med ett RPC-anrop, motsvarande HTTP-huvuden. Använd metadata.New och metadata.NewOutgoingContext på klienten.

md := metadata.New(map[string]string{"authorization": "Bearer " + token})
ctx := metadata.NewOutgoingContext(context.Background(), md)

Läsa metadata på servern

Extrahera inkommande metadata med metadata.FromIncomingContext:

md, ok := metadata.FromIncomingContext(ctx)
if !ok { return nil, status.Error(codes.Unauthenticated, "no metadata") }
token := md["authorization"]

Skicka metadata från servern

Skicka svarshuvuden och trailers från servern med grpc.SetHeader och grpc.SetTrailer:

grpc.SetHeader(ctx, metadata.Pairs("x-request-id", requestID))

go-grpc-middleware

Biblioteket github.com/grpc-ecosystem/go-grpc-middleware/v2 tillhandahåller färdiga interceptorer för återställning efter panik, loggning (zap/logrus), autentisering med mera.

Mönster för autentiseringsinterceptor

Extrahera och validera en token i en interceptor och koppla användaren till kontexten för efterföljande hanterare:

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

Interceptor för återställning efter panik

Omslut hanterare så att de återställer efter panik och returnerar ett Internal-fel i stället för att krascha:

defer func() {
    if r := recover(); r != nil {
        err = status.Errorf(codes.Internal, "panic: %v", r)
    }
}()

Snabbkontroll

Hur skickar du autentiseringstoken mellan en gRPC-klient och server?

Besvara frågan i den interaktiva lektionen

Återblick: gRPC-interceptorer och metadata

Viktiga punkter:

Unary-interceptor: func(ctx, req, info, handler) (resp, error)
grpc.ChainUnaryInterceptor för flera interceptorer
Metadata består av nyckel-värde-par och motsvarar HTTP-huvuden
Autentiseringsinterceptor: extrahera metadata → validera → lägg till användaren i kontexten

Gratis att börja

Lär dig Go med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”gRPC-interceptors och metadata” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Go Academy, inklusive ”gRPC-interceptors och metadata”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Go Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”gRPC-interceptors och metadata”?

Autentisering, middleware för loggning och gRPC-metadata Ni övar på Go Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Go Academy?

Du behöver inga förkunskaper. Utbildningen i Go Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”gRPC-interceptors och metadata”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Go Academy-lektionen?

Ja. Varje Go Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Go Academy