Go Academy · Aula

Interceptadores e metadados de gRPC

Autenticação, middleware de logging e metadados de gRPC

Aula 4 de 413 etapas

Interceptadores e metadados de gRPC é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

O que são interceptadores?

Os interceptadores gRPC (middleware) são executados antes ou depois dos manipuladores RPC. Eles adicionam preocupações transversais: registro, validação de tokens de autenticação, métricas, recuperação de pânico e rastreamento.

Interceptador unário do servidor

Um interceptador unário do servidor envolve o manipulador com 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))

Interceptador de transmissão do servidor

É semelhante ao interceptador unário, mas envolve o manipulador de transmissão:

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

Encadeando interceptadores

Use grpc.ChainUnaryInterceptor (Go gRPC v1.38+) para aplicar vários interceptadores em ordem:

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

Interceptadores do cliente

Os interceptadores unários do lado do cliente envolvem as chamadas de saída — são úteis para injetar tokens de autenticação, fazer novas tentativas ou adicionar cabeçalhos de rastreamento:

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

Metadados gRPC

Metadados são pares de chave e valor enviados junto com um RPC, de forma análoga aos cabeçalhos HTTP. Use metadata.New e metadata.NewOutgoingContext no cliente.

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

Lendo metadados no servidor

Extraia os metadados recebidos com metadata.FromIncomingContext:

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

Enviando metadados do servidor

Envie cabeçalhos de resposta e trailers do servidor com grpc.SetHeader e grpc.SetTrailer:

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

go-grpc-middleware

A biblioteca github.com/grpc-ecosystem/go-grpc-middleware/v2 fornece interceptadores prontos: recuperação, registro (zap/logrus), autenticação e muito mais.

Padrão de interceptador de autenticação

Extraia e valide um token em um interceptador; associe o usuário ao contexto para os manipuladores 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)
}

Interceptador de recuperação de pânico

Envolva os manipuladores para recuperar-se de pânicos e retornar um erro Internal em vez de interromper a execução:

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

Verificação rápida

Como você passa tokens de autenticação entre um cliente e um servidor gRPC?

Responda na aula interativa

Recapitulação: interceptadores e metadados gRPC

Pontos principais:

Interceptador unário: func(ctx, req, info, handler) (resp, error)
grpc.ChainUnaryInterceptor para vários interceptadores
Metadados são pares de chave e valor; análogos aos cabeçalhos HTTP
Interceptador de autenticação: extrair metadados → validar → adicionar o usuário ao contexto

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Interceptadores e metadados de gRPC” é grátis?

Sim — o texto completo de “Interceptadores e metadados de gRPC” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Interceptadores e metadados de gRPC”?

Autenticação, middleware de logging e metadados de gRPC Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Interceptadores e metadados de gRPC”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy