gRPC 进阶——利用 Metadata 和 Interceptor 实现 auth 认证

已于 2024-07-16 17:19:42 修改
阅读量413 收藏 9
点赞数 5
分类专栏： gRPC 文章标签： go rpc
于 2024-07-13 20:24:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MPY_3/article/details/140405810
版权

gRPC 是一个高性能的开源 RPC 框架，支持多种编程语言，并且基于 HTTP/2 协议提供了双向流和头部压缩等特性。在构建分布式系统和微服务架构时，安全认证是至关重要的一环。通过利用 gRPC 的 Metadata 和拦截器机制，可以实现灵活且强大的认证解决方案。

利用Metadata和Interceptor可以实现gRPC的auth认证，下面将教你用两种方法实现：

1.利用Metadata和Interceptor

0.目录树如下

以grpc入门的代码作为示例：

.
├── client
│   └── client.go
├── proto
│   ├── helloworld_grpc.pb.go
│   ├── helloworld.pb.go
│   └── helloworld.proto
└── server
    └── server.go
1. proto文件
syntax = "proto3";

option go_package = "grpc/proto";

service Hello {
  rpc Hello(HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string response = 1;
}

利用命令生成对应的go文件

cd proto/
protoc meta.proto --go_out=. --go-grpc_out=.
2.server/server.go
package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"net"

	"go-try/grpc_auth/proto"
)

type HelloServer struct {
	proto.UnimplementedHelloServer
}

func (s *HelloServer) Hello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloResponse, error) {
	return &proto.HelloResponse{
		Response: "Hello " + request.Name,
	}, nil
}

var interceptor = func(ctx context.Context, req any,
	info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
	fmt.Println("接收到了一个新的请求")
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return resp, status.Error(codes.Unauthenticated, "无token认证信息")
	}

	appid, ok1 := md["appid"]
	appkey, ok2 := md["appkey"]
	if !ok1 || !ok2 || appid[0] != "10010" || appkey[0] != "auth token" {
		return resp, status.Error(codes.Unauthenticated, "token认证失败")
	}

	fmt.Println("appid: ", appid, " appkey: ", appkey)
	response, _ := handler(ctx, req)
	fmt.Println("请求已经完成")
	return response, nil
}

func main() {
	opts := grpc.UnaryInterceptor(interceptor)

	server := grpc.NewServer(opts)
	proto.RegisterHelloServer(server, &HelloServer{})
	listen, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
		panic("faild to listen : " + err.Error())
	}
	err = server.Serve(listen)
	if err != nil {
		panic("faild to start grpc : " + err.Error())
	}
}
3.client/client.go
package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc/metadata"
	"time"

	"google.golang.org/grpc"

	"go-try/grpc_auth/proto"
)

var interceptor = func(ctx context.Context, method string,
	req interface{}, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
	// 记录请求开始的时间
	start := time.Now()
	// 创建元数据
	md := metadata.New(map[string]string{
		"appid":  "10010",
		"appkey": "auth token",
	})
	// 将元数据添加到上下文中
	ctx = metadata.NewOutgoingContext(context.Background(), md)
	// 调用方法
	err := invoker(ctx, method, req, reply, cc, opts...)
	// 打印请求耗时
	fmt.Printf("请求耗时: %s\n", time.Since(start))
	// 返回调用方法的错误
	return err
}

func main() {
	var opts []grpc.DialOption
	opts = append(opts, grpc.WithInsecure())
	opts = append(opts, grpc.WithUnaryInterceptor(interceptor))

	conn, err := grpc.NewClient("0.0.0.0:8080", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	cli := proto.NewHelloClient(conn)
	msg, err := cli.Hello(context.Background(), &proto.HelloRequest{Name: "zs"})
	if err != nil {
		panic(err)
	}
	fmt.Println(msg)
}
4.分别运行server.go和client.go

server端运行结果如下：

接收到了一个新的请求
appid:  [10010]  appkey:  [auth token]
请求已经完成

如果我们将client.go文件中的appid修改：

md := metadata.New(map[string]string{
		"appid":  "10010",
		"appkey": "auth token",
	})

修改为

md := metadata.New(map[string]string{
		"appid":  "100101",
		"appkey": "auth token",
	})

再次分别运行server.go和client.go

server端运行结果会显示：

接收到了一个新的请求

client端运行结果会显示报错：

请求耗时: 3.539849ms
panic: rpc error: code = Unauthenticated desc = token认证失败

由此说明，利用Metadata和Interceptor已经实现了较为简单的auth认证。

2.利用go中grpc自带的函数

1.修改client/client.go代码
package main

import (
	"context"
	"fmt"
	"google.golang.org/grpc"

	"go-try/grpc_auth/proto"
)

type customCredential struct{}

func (cc *customCredential) GetRequestMetadata(ctx context.Context,
	uri ...string) (map[string]string, error) {
	return map[string]string{
		"appid":  "10010",
		"appkey": "auth token",
	}, nil
}

// RequireTransportSecurity indicates whether the credentials requires
// transport security.
func (cc *customCredential) RequireTransportSecurity() bool {
	return false
}

func main() {
	var opts []grpc.DialOption
	opts = append(opts, grpc.WithInsecure())
	//opts = append(opts, grpc.WithUnaryInterceptor(interceptor))
	opts = append(opts, grpc.WithPerRPCCredentials(&customCredential{}))

	conn, err := grpc.NewClient("0.0.0.0:8080", opts...)
	if err != nil {
		panic(err)
	}
	defer conn.Close()

	cli := proto.NewHelloClient(conn)
	msg, err := cli.Hello(context.Background(), &proto.HelloRequest{Name: "zs"})
	if err != nil {
		panic(err)
	}
	fmt.Println(msg)
}
2.分别运行server.go和client.go

server端运行结果如下：

接收到了一个新的请求
appid:  [10010]  appkey:  [auth token]
请求已经完成

如果我们将client.go文件中的appid修改：

md := metadata.New(map[string]string{
		"appid":  "10010",
		"appkey": "auth token",
	})

修改为

md := metadata.New(map[string]string{
		"appid":  "100101",
		"appkey": "auth token",
	})

再次分别运行server.go和client.go

server端运行结果会显示：

接收到了一个新的请求

client端运行结果会显示报错：

请求耗时: 3.539849ms
panic: rpc error: code = Unauthenticated desc = token认证失败

由此说明，利用go中grpc自带的WithPerRPCCredentials()也可以实现较为简单的auth认证。

总结

客户端实现流程

客户端通过创建一个自定义的拦截器，在每个 RPC 调用之前将认证令牌（例如 OAuth 令牌）添加到请求的 Metadata 中。这样可以确保每个请求都包含了有效的认证信息，并且可以在需要时自动处理认证逻辑，提高了安全性和代码的复用性。

服务器实现流程

服务器则通过设置一个拦截器来截取每个传入的 RPC 请求，并验证其中的认证信息。通过解析传入请求的 Metadata，服务器可以检查认证令牌的有效性或者其他自定义的认证机制。如果认证失败，服务器可以返回相应的错误代码，如 codes.Unauthenticated，以保护服务不受未经授权的访问。

通过这种方式，gRPC 提供了一种强大而灵活的认证机制，可以根据具体需求定制和扩展，确保在分布式系统中的通信安全和可靠性。

MPY_3
关注
专栏目录
grpc 拦截器 python_Golang gRPC实践 连载五 拦截器 Interceptor
weixin_39913628的博客
12-21 259
Interceptorgrpc服务端提供了interceptor功能，可以在服务端接收到请求时优先对请求中的数据做一些处理后再转交给指定的服务处理并响应，功能类似middleware，很适合在这里处理验证、日志等流程。在自定义Token认证的示例中，认证信息是由每个服务中的方法处理并认证的，如果有大量的接口方法，这种姿势就太蛋疼了，每个接口实现都要先处理认证信息。这个时候interceptor就站...
c++客户端 grpc_grpc加TLS加密和令牌认证
weixin_39587238的博客
12-21 987
grpc加TLS加密和令牌认证(金庆的专栏 2018.11)用 golang 创建 grpc 服务，开启 TLS 加密，并采用令牌认证。然后用 C++ 和 golang 分别创建客户端连接服务器。参考：https://segmentfault.com/a/1190000007933303服务器import (...grpc_auth "github.com/grpc-ecosystem/go-gr...
grpc-auth-example:使用gRPC进行客户端身份验证的示例
04-29
grpc-auth-example 使用gRPC进行客户端身份验证的示例。 显示了服务器端和客户端实现。 所有身份验证均在实现的服务器端拦截器中执行。 TLS客户端证书认证 第一种身份验证使用TLS证书主题来验证正确的客户端正在连接。 当然，这仅依赖于颁发证书颁发机构，该颁发机构仅颁发具有适用于正确服务的正确主题的证书，但这不在此存储库的范围之内。 在客户端，我们创建具有适当主题的证书： pk , err := rsa . GenerateKey ( rand . Reader , 2048 ) if err != nil { return nil , err } template := & x509. Certificate { SerialNumber : serialNumber , Subject : pkix. Name { Orga
gRPC完成简单的auth认证
一个菜鸟的博客
05-19 788
metadata+拦截器 proto syntax = "proto3"; option go_package = ".;proto"; service Greeter{ rpc SayHello(HelloRequest) returns(HelloReply); } message HelloRequest { string name = 1; } message HelloReply{ string message = 1; } .pb.go // Code generated b
gRPC的metadata
weixin_54984185的博客
01-05 561
metadata是以key-value的形式存储数据的，其中key是字符串类型，value是字符串数组类型，类似于http请求中的header。
gRPC之metadata
weixin_33955681的博客
04-02 1751
2019独角兽企业重金招聘Python工程师标准>>> ...
利用 gRPC 的拦截器实现 Python 服务端的认证和授权
# 1. gRPC 简介 gRPC 是一种高性能、开源、通用的远程过程调用（RPC）框架，由...在 gRPC 中，定义一个 RPC 服务，需要编写一个 `.proto` 文件来描述服务的接口和消息。通过 Protocol Buffers 定义的服务接口，可以生
gRPC（七）进阶：自定义身份验证
林钟一的博客
11-10 1456
基于 CA 的 TLS 证书认证而在实际需求中，常常会对某些模块的 RPC 方法做特殊认证或校验，而gRPC也专门提供了这类特殊认证的接口。gRPC为每个gRPC方法调用提供了Token认证支持，可以基于用户传入的Token判断用户是否登陆、以及权限等，实现Token认证的前提是，需要定义一个结构体，并实现接口。1）客户端请求时带上 Credentials；2）服务端取出 Credentials，并验证有效性，一般配合拦截器使用（这里我们使用两种方法，拦截器以及RPC方法）。
gRPC：gRPC基础概念与原理
kkchenjj的博客
07-12 1588
首先，我们需要使用 Protocol Buffers 定义服务接口。创建一个名为协议缓冲区（Protocol Buffers）是Google开发的一种数据交换格式，它高效、简洁且自描述。Protocol Buffers非常适合用于网络通信和数据存储，可以将结构化数据序列化，使得数据可以存储在数据库中或通过网络进行传输。Protocol Buffers的数据描述语言（.proto文件）允许你定义数据结构，然后通过Protocol Buffers编译器生成代码，用于在各种语言中读写这些数据结构。
GRPC 四种模式（官方的demo）
05-24
利用Grpc实现四种客户端和服务端交互模式，并且代码中有中文说明，方便同仁们学习
通过拦截器和metadata实现grpc的auth认证#Golang
席万里的博客
05-16 461
grpc实现一个拦截器
深入gRPC：构建高效微服务的进阶指南
weixin_53840353的博客
04-25 336
良好的服务接口设计是使用gRPC的关键。避免设计大而全的接口，而是应该遵循单一职责原则，每个服务接口负责一个明确的功能。这样不仅可以减少服务间的耦合，还能提高系统的整体可维护性和扩展性。通过深入了解gRPC的高级特性和最佳实践，开发者可以充分利用这一强大的RPC框架来构建高性能、可扩展且安全的微服务应用。gRPC的设计哲学和技术优势使其成为现代云原生应用开发的理想选择。随着对gRPC的深入探索和实践，你将能够更加自信地设计和实现复杂的服务架构，满足不断变化的业务需求。
grpc传输metadata
qq2252852775的博客
05-16 1938
grpc 开发进阶 -传递 metadata metadata作用简介 grpc 支持在 server 端和 client 端发送 metedata，一些验证信息之类的可以放在这个里边 metadata 可以通过 metadata 包来构建 type MD map[string][]string 一个键可以对应多个值 生成 metadata func New(m map[string]string) MD func Pairs(kv ...string) MD md := metadata.New(m
gRPC进阶——Metadata机制
最新发布
MPY_3的博客
07-13 670
gRPC的Metadata机制是一种用于在客户端和服务器之间传递额外信息的方式，以键值对的形式存在，类似于HTTP头部。它广泛用于传递身份验证信息、追踪ID、压缩指令等，增强了RPC调用的灵活性和功能性。在请求中，客户端可以附加Metadata，服务器可以通过上下文对象读取并处理这些Metadata，从而实现身份验证、请求追踪等功能。
gRPC 高级特性之 重试机制
u013433591的博客
11-07 3302
gRPC 重试机制、重试原理、重试配置模板 grpc-previous-rpc-attempts
Java使用gRPC协议开发服务
程序员小潘
07-07 1058
gRPC通过proto文件来定义服务
gRPC-Go基础（4）metadata和超时设置
ldxxxxll的博客
12-28 1429
Go在多个go routine之间传递数据使用的是Go SDK提供的context包，而context的作用范围在进程内，而gRPC使用的是跨进程的网络传输，那如何实现跨进程的元数据传输呢？
Go语言与GRPC进阶实战： Protobuf与Web开发
"该资源是一本关于GRPC进阶的教程，涵盖了Go语言的基础知识，CGO编程，汇编语言，RPC和Protobuf，以及Go语言在Web开发和分布式系统中的应用。书中通过详细的章节划分，深入讲解了各个主题，包括Go语言的基本语法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值