Interceptor e metadati gRPC
Autenticazione, middleware di logging e metadati gRPC
Interceptor e metadati gRPC è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.
Che cosa sono gli interceptor?
Gli interceptor gRPC (middleware) vengono eseguiti prima o dopo i gestori RPC. Aggiungono funzionalità trasversali: logging, convalida dei token di autenticazione, metriche, recupero dai panic e tracing.
Interceptor unario del server
Un interceptor unario del server avvolge il gestore con una logica aggiuntiva:
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))Interceptor di streaming del server
È simile a quello unario, ma avvolge il gestore dello stream:
func StreamLogging(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
log.Printf("stream: %s", info.FullMethod)
return handler(srv, ss)
}Concatenazione degli interceptor
Utilizzi grpc.ChainUnaryInterceptor (Go gRPC v1.38+) per applicare più interceptor nell'ordine desiderato:
grpcSrv := grpc.NewServer(
grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor, MetricsInterceptor),
)Interceptor del client
Gli interceptor unari lato client avvolgono le chiamate in uscita; sono utili per inserire token di autenticazione, retry o header di tracing:
conn, _ := grpc.NewClient(addr,
grpc.WithUnaryInterceptor(ClientAuthInterceptor),
grpc.WithTransportCredentials(insecure.NewCredentials()),
)Metadati gRPC
I metadati sono coppie chiave-valore inviate insieme a una RPC, analoghe agli header HTTP. Utilizzi metadata.New e metadata.NewOutgoingContext sul client.
md := metadata.New(map[string]string{"authorization": "Bearer " + token})
ctx := metadata.NewOutgoingContext(context.Background(), md)Lettura dei metadati sul server
Estragga i metadati in ingresso con metadata.FromIncomingContext:
md, ok := metadata.FromIncomingContext(ctx)
if !ok { return nil, status.Error(codes.Unauthenticated, "no metadata") }
token := md["authorization"]Invio dei metadati dal server
Invii gli header e i trailer della risposta dal server con grpc.SetHeader e grpc.SetTrailer:
grpc.SetHeader(ctx, metadata.Pairs("x-request-id", requestID))go-grpc-middleware
La libreria github.com/grpc-ecosystem/go-grpc-middleware/v2 fornisce interceptor pronti all'uso: recovery, logging (zap/logrus), autenticazione e altro.
Pattern dell'interceptor di autenticazione
Estragga e convalidi un token in un interceptor; associ l'utente al contesto per i gestori downstream:
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 per il recupero dai panic
Avvolga i gestori per recuperare dai panic e restituire un errore Internal invece di arrestare il programma:
defer func() {
if r := recover(); r != nil {
err = status.Errorf(codes.Internal, "panic: %v", r)
}
}()Verifica rapida
Come si passano i token di autenticazione tra un client e un server gRPC?
Riepilogo: interceptor e metadati gRPC
Punti chiave:
- Interceptor unario: func(ctx, req, info, handler) (resp, error)
- grpc.ChainUnaryInterceptor per più interceptor
- I metadati sono coppie chiave-valore, analoghe agli header HTTP
- Interceptor di autenticazione: estrarre i metadati → convalidare → aggiungere l'utente al contesto
Impara Go con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Interceptor e metadati gRPC» è gratuita?
Sì — il testo completo di «Interceptor e metadati gRPC» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.
Cosa imparerò in «Interceptor e metadati gRPC»?
Autenticazione, middleware di logging e metadati gRPC Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Go Academy?
Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Interceptor e metadati gRPC»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Go Academy?
Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Protocol Buffers e file .proto
- Implementare un servizio gRPC unary
- Streaming dal server e dal client
- Interceptor e metadati gRPC