Interceptores y metadatos de gRPC
Autenticación, middleware de registro y metadatos de gRPC
Interceptores y metadatos de gRPC es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.
¿Qué son los interceptores?
Los interceptores de gRPC (middleware) se ejecutan antes o después de los controladores RPC. Añaden funcionalidades transversales: registro, validación de tokens de autenticación, métricas, recuperación ante panics y trazas.
Interceptor unario del servidor
Un interceptor unario del servidor envuelve el controlador con lógica adicional:
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 de streaming del servidor
Es similar al interceptor unario, pero envuelve el controlador del 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)
}Encadenamiento de interceptores
Utilice grpc.ChainUnaryInterceptor (Go gRPC v1.38+) para aplicar varios interceptores en orden:
grpcSrv := grpc.NewServer(
grpc.ChainUnaryInterceptor(LoggingInterceptor, AuthInterceptor, MetricsInterceptor),
)Interceptores del cliente
Los interceptores unarios del lado del cliente envuelven las llamadas salientes; son útiles para inyectar tokens de autenticación, reintentos o encabezados de trazas:
conn, _ := grpc.NewClient(addr,
grpc.WithUnaryInterceptor(ClientAuthInterceptor),
grpc.WithTransportCredentials(insecure.NewCredentials()),
)Metadatos de gRPC
Los metadatos son pares clave-valor que se envían junto con un RPC, de forma análoga a los encabezados HTTP. Utilice metadata.New y metadata.NewOutgoingContext en el cliente.
md := metadata.New(map[string]string{"authorization": "Bearer " + token})
ctx := metadata.NewOutgoingContext(context.Background(), md)Lectura de metadatos en el servidor
Extraiga los metadatos entrantes con metadata.FromIncomingContext:
md, ok := metadata.FromIncomingContext(ctx)
if !ok { return nil, status.Error(codes.Unauthenticated, "no metadata") }
token := md["authorization"]Envío de metadatos desde el servidor
Envíe encabezados y trailers de respuesta desde el servidor con grpc.SetHeader y grpc.SetTrailer:
grpc.SetHeader(ctx, metadata.Pairs("x-request-id", requestID))go-grpc-middleware
La biblioteca github.com/grpc-ecosystem/go-grpc-middleware/v2 proporciona interceptores listos para usar: recuperación, registro (zap/logrus), autenticación y más.
Patrón de interceptor de autenticación
Extraiga y valide un token en un interceptor; adjunte el usuario al contexto para los controladores posteriores:
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 de recuperación ante panics
Envuelva los controladores para recuperarse de los panics y devolver un error Internal en lugar de hacer que el proceso se bloquee:
defer func() {
if r := recover(); r != nil {
err = status.Errorf(codes.Internal, "panic: %v", r)
}
}()Comprobación rápida
¿Cómo se pasan los tokens de autenticación entre un cliente y un servidor gRPC?
Recapitulación: interceptores y metadatos de gRPC
Puntos clave:
- Interceptor unario: func(ctx, req, info, handler) (resp, error)
- grpc.ChainUnaryInterceptor para varios interceptores
- Los metadatos son pares clave-valor, análogos a los encabezados HTTP
- Interceptor de autenticación: extraer metadatos → validar → añadir el usuario al contexto
Preguntas frecuentes
¿La lección «Interceptores y metadatos de gRPC» es gratis?
Sí — el texto completo de «Interceptores y metadatos de gRPC» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Interceptores y metadatos de gRPC»?
Autenticación, middleware de registro y metadatos de gRPC Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Go Academy?
No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Interceptores y metadatos de gRPC»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Go Academy?
Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Protocol Buffers y archivos .proto
- Implementación de un servicio gRPC unario
- Streaming del servidor y del cliente
- Interceptores y metadatos de gRPC