手把手教大家在 gRPC 中使用 JWT 完成身份校验

最新推荐文章于 2023-11-23 10:54:42 发布
最新推荐文章于 2023-11-23 10:54:42 发布
阅读量475 收藏 1
点赞数
文章标签： restful java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/129175022
版权

@[toc] 上篇文章松哥和小伙伴们聊了在 gRPC 中如何使用拦截器，这些拦截器有服务端拦截器也有客户端拦截器，这些拦截器的一个重要使用场景，就是可以进行身份的校验。当客户端发起请求的时候，服务端通过拦截器进行身份校验，就知道这个请求是谁发起的了。今天松哥就来通过一个具体的案例，来和小伙伴们演示一下 gRPC 如何结合 JWT 进行身份校验。

1. JWT 介绍

1.1 无状态登录

1.1.1 什么是有状态

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如 Tomcat 中的 Session。例如登录：用户登录后，我们把用户的信息保存在服务端 session 中，并且给用户一个 cookie 值，记录对应的 session，然后下次请求，用户携带 cookie 值来（这一步有浏览器自动完成），我们就能识别到对应 session，从而找到用户的信息。这种方式目前来看最方便，但是也有一些缺陷，如下：

  • 服务端保存大量数据，增加服务端压力
  • 服务端保存用户状态，不支持集群化部署

1.1.2 什么是无状态

微服务集群中的每个服务，对外提供的都使用 RESTful 风格的接口。而 RESTful 风格的一个最重要的规范就是：服务的无状态性，即：

  • 服务端不保存任何客户端请求者信息
  • 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

那么这种无状态性有哪些好处呢？

  • 客户端请求不依赖服务端的信息，多次请求不需要必须访问到同一台服务器
  • 服务端的集群和状态对客户端透明
  • 服务端可以任意的迁移和伸缩（可以方便的进行集群化部署）
  • 减小服务端存储压力

1.2 如何实现无状态

无状态登录的流程：

  • 首先客户端发送账户名/密码到服务端进行认证
  • 认证通过后，服务端将用户信息加密并且编码成一个 token，返回给客户端
  • 以后客户端每次发送请求，都需要携带认证的 token
  • 服务端对客户端发送来的 token 进行解密，判断是否有效，并且获取用户登录信息

1.3 JWT

1.3.1 简介

JWT，全称是 Json Web Token， 是一种 JSON 风格的轻量级的授权和身份认证规范，可实现无状态、分布式的 Web 应用授权：

JWT 作为一种规范，并没有和某一种语言绑定在一起，常用的 Java 实现是 GitHub 上的开源项目 jjwt，地址如下：https://github.com/jwtk/jjwt

1.3.2 JWT数据格式

JWT 包含三部分数据：

  • Header：头部，通常头部有两部分信息：

    • 声明类型，这里是JWT
    • 加密算法，自定义

我们会对头部进行 Base64Url 编码（可解码），得到第一部分数据。

  • Payload：载荷，就是有效数据，在官方文档中(RFC7519)，这里给了7个示例信息：

    • iss (issuer)：表示签发人
    • exp (expiration time)：表示token过期时间
    • sub (subject)：主题
    • aud (audience)：受众
    • nbf (Not Before)：生效时间
    • iat (Issued At)：签发时间
    • jti (JWT ID)：编号

这部分也会采用 Base64Url 编码，得到第二部分数据。

  • Signature：签名，是整个数据的认证信息。一般根据前两步的数据，再加上服务的的密钥secret（密钥保存在服务端，不能泄露给客户端），通过 Header 中配置的加密算法生成。用于验证整个数据完整和可靠性。

生成的数据格式如下图：

注意，这里的数据通过 . 隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已。

1.3.3 JWT 交互流程

流程图：

步骤翻译：

  1. 应用程序或客户端向授权服务器请求授权
  2. 获取到授权后，授权服务器会向应用程序返回访问令牌
  3. 应用程序使用访问令牌来访问受保护资源（如 API）

因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就完全符合了 RESTful 的无状态规范。

1.3.4 JWT 存在的问题

说了这么多，JWT 也不是天衣无缝，由客户端维护登录状态带来的一些问题在这里依然存在，举例如下：

  1. 续签问题，这是被很多人诟病的问题之一，传统的 cookie+session 的方案天然的支持续签，但是 jwt 由于服务端不保存用户状态，因此很难完美解决续签问题，如果引入 redis，虽然可以解决问题，但是 jwt 也变得不伦不类了。
  2. 注销问题，由于服务端不再保存用户信息，所以一般可以通过修改 secret 来实现注销，服务端 secret 修改后，已经颁发的未过期的 token 就会认证失败，进而实现注销，不过毕竟没有传统的注销方便。
  3. 密码重置，密码重置后，原本的 token 依然可以访问系统，这时候也需要强制修改 secret。
  4. 基于第 2 点和第 3 点，一般建议不同用户取不同 secret。

当然，为了解决 JWT 存在的问题，也可以将 JWT 结合 Redis 来用，服务端生成的 JWT 字符串存入到 Redis 中并设置过期时间，每次校验的时候，先看 Redis 中是否存在该 JWT 字符串，如果存在就进行后续的校验。但是这种方式有点不伦不类（又成了有状态了）。

2. 实践

我们来看下 gRPC 如何结合 JWT。

2.1 项目创建

首先我先给大家看下我的项目结构：

├── grpc_api
│   ├── pom.xml
│   └── src
├── grpc_client
│   ├── pom.xml
│   └── src
├── grpc_server
│   ├── pom.xml
│   └── src
└── pom.xml
复制代码

还是跟之前文章中的一样，三个模块，grpc_api 用来存放一些公共的代码。

grpc_server 用来放服务端的代码，我这里服务端主要提供了两个接口：

  1. 登录接口，登录成功之后返回 JWT 字符串。
  2. hello 接口，客户端拿着 JWT 字符串来访问 hello 接口。

grpc_client 则是我的客户端代码。

2.2 grpc_api

我将 protocol buffers 和一些依赖都放在 grpc_api 模块中，因为将来我的 grpc_server 和 grpc_client 都将依赖 grpc_api。

我们来看下这里需要的依赖和插件：

<dependencies>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-netty-shaded</artifactId>
        <version>1.52.1</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-protobuf</artifactId>
        <version>1.52.1</version>
    </dependency>
    <dependency>
        <groupId>io.grpc</groupId>
        <artifactId>grpc-stub</artifactId>
        <version>1.52.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>annotations-api</artifactId>
        <version>6.0.53</version>
        <scope>provided</scope>
    </dependency>
</dependencies>
<build>
    <extensions>
        <extension>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.6.2</version>
        </extension>
    </extensions>
    <plugins>
        <plugin>
            <groupId>org.xolstice.maven.plugins</groupId>
            <artifactId>protobuf-maven-plugin</artifactId>
            <version>0.6.1</version>
            <configuration>
                <protocArtifact>com.google.protobuf:protoc:3.21.7:exe:${os.detected.classifier}</protocArtifact>
                <pluginId>grpc-java</pluginId>
                <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.51.0:exe:${os.detected.classifier}</pluginArtifact>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                        <goal>compile-custom</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>
复制代码

这里的依赖和插件松哥在本系列的第一篇文章中都已经介绍过了，唯一不同的是，这里引入了 JWT 插件，JWT 我使用了比较流行的 JJWT 这个工具。JJWT 松哥在之前的文章和视频中也都有介绍过，这里就不再啰嗦了。

先来看看我的 Protocol Buffers 文件：

syntax = "proto3";

option java_multiple_files = true;
option java_package = "org.javaboy.grpc.api";
option java_outer_classname = "LoginProto";
import "google/protobuf/wrappers.proto";

package login;

service LoginService {
  rpc login (LoginBody) returns (LoginResponse);
}

service HelloService{
  rpc sayHello(google.protobuf.StringValue) returns (google.protobuf.StringValue);
}

message LoginBody {
  string username = 1;
  string password = 2;
}

message LoginResponse {
  string token = 1;
}
复制代码

经过前面几篇文章的介绍，这里我就不多说啦，就是定义了两个服务：

  • LoginService：这个登录服务，传入用户名密码，返回登录成功之后的令牌。
  • HelloService：这个就是一个打招呼的服务，传入字符串，返回也是字符串。

定义完成之后，生成对应的代码即可。

接下来再定义一个常量类供 grpc_server 和 grcp_client 使用，如下：

public interface AuthConstant {
    SecretKey JWT_KEY = Keys.hmacShaKeyFor("hello_javaboy_hello_javaboy_hello_javaboy_hello_javaboy_".getBytes());
    Context.Key<String> AUTH_CLIENT_ID = Context.key("clientId");
    String AUTH_HEADER = "Authorization";
    String AUTH_TOKEN_TYPE = "Bearer";
}
复制代码

这里的每个常量我都给大家解释下：

  1. JWT_KEY：这个是生成 JWT 字符串以及进行 JWT 字符串校验的密钥。
  2. AUTH_CLIENT_ID：这个是客户端的 ID，即客户端发送来的请求携带了 JWT 字符串，通过 JWT 字符串确认了用户身份，就存在这个变量中。
  3. AUTH_HEADER：这个是携带 JWT 字符串的请求头的 KEY。
  4. AUTH_TOKEN_TYPE：这个是携带 JWT 字符串的请求头的参数前缀，通过这个可以确认参数的类型，常见取值有 Bearer 和 Basic。

如此，我们的 gRPC_api 就定义好了。

2.3 grpc_server

接下来我们来定义 gRPC_server。

首先来定义登录服务：

public class LoginServiceImpl extends LoginServiceGrpc.LoginServiceImplBase {
    @Override
    public void login(LoginBody request, StreamObserver<LoginResponse> responseObserver) {
        String username = request.getUsername();
        String password = request.getPassword();
        if ("javaboy".equals(username) && "123".equals(password)) {
            System.out.println("login success");
            //登录成功
            String jwtToken = Jwts.builder().setSubject(username).signWith(AuthConstant.JWT_KEY).compact();
            responseObserver.onNext(LoginResponse.newBuilder().setToken(jwtToken).build());
            responseObserver.onCompleted();
        }else{
            System.out.println("login error");
            //登录失败
            responseObserver.onNext(LoginResponse.newBuilder().setToken("login error").build());
            responseObserver.onCompleted();
        }
    }
}
复制代码

省事起见，我这里没有连接数据库，用户名和密码固定为 javaboy 和 123。

登录成功之后，就生成一个 JWT 字符串返回。

登录失败，就返回一个 login error 字符串。

再来看我们的 HelloService 服务，如下：

public class HelloServiceImpl extends HelloServiceGrpc.HelloServiceImplBase {
    @Override
    public void sayHello(StringValue request, StreamObserver<StringValue> responseObserver) {
        String clientId = AuthConstant.AUTH_CLIENT_ID.get();
        responseObserver.onNext(StringValue.newBuilder().setValue(clientId + " say hello:" + request.getValue()).build());
        responseObserver.onCompleted();
    }
}
复制代码

这个服务就更简单了，不啰嗦。唯一值得说的是 AuthConstant.AUTH_CLIENT_ID.get(); 表示获取当前访问用户的 ID，这个用户 ID 是在拦截器中存入进来的。

最后，我们来看服务端比较重要的拦截器，我们要在拦截器中从请求头中获取到 JWT 令牌并解析，如下：

public class AuthInterceptor implements ServerInterceptor {
    private JwtParser parser = Jwts.parser().setSigningKey(AuthConstant.JWT_KEY);

    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall, Metadata metadata, ServerCallHandler<ReqT, RespT> serverCallHandler) {
        String authorization = metadata.get(Metadata.Key.of(AuthConstant.AUTH_HEADER, Metadata.ASCII_STRING_MARSHALLER));
        Status status = Status.OK;
        if (authorization == null) {
            status = Status.UNAUTHENTICATED.withDescription("miss authentication token");
        } else if (!authorization.startsWith(AuthConstant.AUTH_TOKEN_TYPE)) {
            status = Status.UNAUTHENTICATED.withDescription("unknown token type");
        } else {
            Jws<Claims> claims = null;
            String token = authorization.substring(AuthConstant.AUTH_TOKEN_TYPE.length()).trim();
            try {
                claims = parser.parseClaimsJws(token);
            } catch (JwtException e) {
                status = Status.UNAUTHENTICATED.withDescription(e.getMessage()).withCause(e);
            }
            if (claims != null) {
                Context ctx = Context.current()
                        .withValue(AuthConstant.AUTH_CLIENT_ID, claims.getBody().getSubject());
                return Contexts.interceptCall(ctx, serverCall, metadata, serverCallHandler);
            }
        }
        serverCall.close(status, new Metadata());
        return new ServerCall.Listener<ReqT>() {
        };
    }
}
复制代码

这段代码逻辑应该好理解：

  1. 首先从 Metadata 中提取出当前请求所携带的 JWT 字符串（相当于从请求头中提取出来）。
  2. 如果第一步提取到的值为 null 或者这个值不是以指定字符 Bearer 开始的，说明这个令牌是一个非法令牌，设置对应的响应 status 即可。
  3. 如果令牌都没有问题的话，接下来就进行令牌的校验，校验失败，则设置相应的 status 即可。
  4. 校验成功的话，我们就会获取到一个 Jws 对象，从这个对象中我们可以提取出来用户名，并存入到 Context 中，将来我们在 HelloServiceImpl 中就可以获取到这里的用户名了。
  5. 最后，登录成功的话，Contexts.interceptCall 方法构建监听器并返回；登录失败，则构建一个空的监听器返回。

最后，我们再来看看启动服务端：

public class LoginServer {
    Server server;

    public static void main(String[] args) throws IOException, InterruptedException {
        LoginServer server = new LoginServer();
        server.start();
        server.blockUntilShutdown();
    }

    public void start() throws IOException {
        int port = 50051;
        server = ServerBuilder.forPort(port)
                .addService(new LoginServiceImpl())
                .addService(ServerInterceptors.intercept(new HelloServiceImpl(), new AuthInterceptor()))
                .build()
                .start();
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            LoginServer.this.stop();
        }));
    }

    private void stop() {
        if (server != null) {
            server.shutdown();
        }
    }

    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }
}
复制代码

这个跟之前的相比就多加了一个 Service，添加 HelloServiceImpl 服务的时候，多加了一个拦截器，换言之，登录的时候，请求是不会被这个认证拦截器拦截的。

好啦，这样我们的 grpc_server 就开发完成了。

2.4 grpc_client

接下来我们来看 grpc_client。

先来看登录：

public class LoginClient {
    public static void main(String[] args) throws InterruptedException {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
                .usePlaintext()
                .build();
        LoginServiceGrpc.LoginServiceStub stub = LoginServiceGrpc.newStub(channel);
        login(stub);
    }

    private static void login(LoginServiceGrpc.LoginServiceStub stub) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        stub.login(LoginBody.newBuilder().setUsername("javaboy").setPassword("123").build(), new StreamObserver<LoginResponse>() {
            @Override
            public void onNext(LoginResponse loginResponse) {
                System.out.println("loginResponse.getToken() = " + loginResponse.getToken());
            }

            @Override
            public void onError(Throwable throwable) {

            }

            @Override
            public void onCompleted() {
                countDownLatch.countDown();
            }
        });
        countDownLatch.await();
    }
}
复制代码

这个方法直接调用就行了，看过前面几篇 gRPC 文章的话，这里都很好理解。

再来看 hello 接口的调用，这个接口调用需要携带 JWT 字符串，而携带 JWT 字符串，则需要我们构建一个 CallCredentials 对象，如下：

public class JwtCredential extends CallCredentials {
    private String subject;

    public JwtCredential(String subject) {
        this.subject = subject;
    }

    @Override
    public void applyRequestMetadata(RequestInfo requestInfo, Executor executor, MetadataApplier metadataApplier) {
        executor.execute(() -> {
            try {
                Metadata headers = new Metadata();
                headers.put(Metadata.Key.of(AuthConstant.AUTH_HEADER, Metadata.ASCII_STRING_MARSHALLER),
                        String.format("%s %s", AuthConstant.AUTH_TOKEN_TYPE, subject));
                metadataApplier.apply(headers);
            } catch (Throwable e) {
                metadataApplier.fail(Status.UNAUTHENTICATED.withCause(e));
            }
        });
    }

    @Override
    public void thisUsesUnstableApi() {

    }
}
复制代码

这里就是将请求的 JWT 令牌放入到请求头中即可。

最后来看看调用：

public class LoginClient {
    public static void main(String[] args) throws InterruptedException {
        ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
                .usePlaintext()
                .build();
        LoginServiceGrpc.LoginServiceStub stub = LoginServiceGrpc.newStub(channel);
        sayHello(channel);
    }

    private static void sayHello(ManagedChannel channel) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        HelloServiceGrpc.HelloServiceStub helloServiceStub = HelloServiceGrpc.newStub(channel);
        helloServiceStub
                .withCallCredentials(new JwtCredential("eyJhbGciOiJIUzM4NCJ9.eyJzdWIiOiJqYXZhYm95In0.IMMp7oh1dl_trUn7sn8qiv9GtO-COQyCGDz_Yy8VI4fIqUcRfwQddP45IoxNovxL"))
                .sayHello(StringValue.newBuilder().setValue("wangwu").build(), new StreamObserver<StringValue>() {
            @Override
            public void onNext(StringValue stringValue) {
                System.out.println("stringValue.getValue() = " + stringValue.getValue());
            }

            @Override
            public void onError(Throwable throwable) {
                System.out.println("throwable.getMessage() = " + throwable.getMessage());
            }

            @Override
            public void onCompleted() {
                countDownLatch.countDown();
            }
        });
        countDownLatch.await();
    }
}
复制代码

这里的登录令牌就是前面调用 login 方法时获取到的令牌。

好啦，大功告成。

3. 小结

上面的登录与校验只是松哥给小伙伴们展示的一个具体案例而已，在此案例基础之上，我们还可以扩展出来更多写法，但是万变不离其宗，其他玩法就需要小伙伴们自行探索啦～

「已注销」
关注
23. 【gRPC系列学习】gRPC安全认证-JWT认证
菜鸟的博客
12-24 976
gRPC安全认证-JWT认证
.netcore grpc身份验证和授权
qq_31975127的博客
08-18 1718
1）引入IdentityServer4、IdentityServer4.AccessTokenValidation、Microsoft.AspNetCore.Authentication.JwtBearer包。2）gRPC工厂中配置token传递 或者在调用对应的客户端函数中对metadata传参。链接：https://pan.baidu.com/s/1viu-REcR-ySdR0FE05sohg。（grpc专栏结束后会开启鉴权授权专栏欢迎大家关注）1）调用鉴权中心获取token。第三步：WPF客户端。
gRPC with JWT
最新发布
Lamb的博客
11-23 277
在 gRPC 中使用 JWT（JSON Web Tokens）进行身份验证是一种常见的做法，它可以帮助你确保请求方的身份和权限。
Akka-CQRS（16）- gRPC用JWT进行权限管理
TIGER_XC的专栏
07-15 523
前面谈过gRPC的SSL/TLS安全机制，发现设置过程比较复杂：比如证书签名：需要服务端、客户端两头都设置等。想想实际上用JWT会更加便捷，而且更安全和功能强大，因为除JWT的加密签名之外还可以把私密的用户信息放在JWT里加密后在服务端和客户端之间传递。当然，最基本的是通过对JWT的验证机制可以控制客户端对某些功能的使用权限。 通过JWT实现gRPC的函数调用权限管理原理其实很简单：客户端...
grpc-jwt-spring-boot-starter:具有JWT授权的gRPC框架的Spring Boot Starter
03-28
具有Spring Boot Starter-gRPC Java JWT 使用Auth模块扩展出色的。 使用类似于Spring Security模块中使用的简单注释的简单实现。 快速开始 （尝试示例项目：Kotlin中的。） 简单的开始仅由3个简单的步骤组成。 （如果您以前从未使用过请先看一下此。） 1.添加Maven依赖 < dependency> < groupId>io.github.majusko</ groupId> < artifactId>grpc-jwt-spring-boot-starter</ artifactId> < version>${version}</ version> </ dependency> 2.在服务方法中添加@Allow批注 您需要做的就是在服务实现中注释您的方法。 @GRpcService public clas
grpc-jwt:探索gRPC验证JWT的示例代码
05-15
在这个"grpc-jwt"项目中，我们将深入探讨如何在Go语言环境下使用gRPC和JWT进行安全通信。 首先，我们需要了解gRPC的基本概念。gRPC是一个高性能、开源和通用的RPC（远程过程调用）框架，由Google设计并支持跨平台...
go grpc安装使用教程
01-03
gRPC是由Google主导开发的RPC框架，使用HTTP/2协议并用ProtoBuf作为序列化工具。其客户端提供Objective-C、Java接口，服务器侧则有Java、Golang、C++等接口，从而为移动端（iOS/Androi）到服务器端通讯提供了一种...
Go Grpc Jwt身份认证
dz45693的专栏
01-04 2181
在 http 请求当中我们可以设置 header 用来传递数据，grpc 底层采用 http2 协议也是支持传递数据的，采用的是 metadata。 Metadata 对于 gRPC 本身来说透明， 它使得 client 和 server 能为对方提供本次调用的信息。就像一次 http 请求的 RequestHeader 和 ResponseHeader，http header 的生命周期是一次 http 请求， Metadata 的生命周期则是一次 RPC 调用。在 go 语言中，可以用grpc.Wit.
JWT校验
Monster
03-08 2195
1. 什么是JWT Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准（(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源，也可以增加一些额外的其它业务逻辑所必须的声明信息，该token也可直接被用于认证，也可被加密。 通俗说：\color{#FF3030}{通俗说：}通俗说： 在数据传输过程中还可
grpc-demo:java版grpc 示例，使用拦截器实现了token认证
05-16
grpc-demo java版grpc 示例，使用拦截器实现了token认证
GRPC_demo.rar
12-31
grpc通讯python端demo，其中包含proto文件以及python写的服务、python写的客户端，可用于grpc学习
C# 微服务---Grpc框架 Demo 服务端 客户端分离
09-24
服务端 客户端已经做了分离 基于Core开发
.Net Core gRPC入门(四)——身份认证
自云—自在之心，无缚于体
04-17 959
目录一、服务端添加身份认证1. 添加Nuget包2. 添加身份认证3. 添加Proto文件4. 添加服务实现5. 注册授权服务二、客户端获取Token认证1. Console客户端 身份认证用于登陆认证、授权等作用，下面将展示如何在gRPC中进行身份认证 一、服务端添加身份认证 1. 添加Nuget包 工具 > Nuget包管理器 > 程序包管理控制台 > 设置默认项目为GrpcDemo.Service 输入以下命令： Install-Package Microsoft.AspNetCo
gRPC（七）进阶：自定义身份验证
林钟一的博客
11-10 1506
基于 CA 的 TLS 证书认证而在实际需求中，常常会对某些模块的 RPC 方法做特殊认证或校验，而gRPC也专门提供了这类特殊认证的接口。gRPC为每个gRPC方法调用提供了Token认证支持，可以基于用户传入的Token判断用户是否登陆、以及权限等，实现Token认证的前提是，需要定义一个结构体，并实现接口。1）客户端请求时带上 Credentials；2）服务端取出 Credentials，并验证有效性，一般配合拦截器使用（这里我们使用两种方法，拦截器以及RPC方法）。
grpc-go源码剖析九十九之grpc+jwt认证方式介绍
码二哥的技术池
10-27 1333
本文主要介绍jwt相关原理。 1、jwt基本介绍 1.1、jwt格式？ jwt类型的token由三部分组成： 每部分由.作为分隔符。 形式如下： A.B.C 其中: A：表示头部信息 B：表示载荷信息 C：表示签名信息 1.2、jwt头部信息 主要存储？ 头部信息，主要由两部分组成： 参考形式： { "alg": "HS256", "typ": "JWT" } 每部分都是kv键值对； alg，表示第3部分使用的签名算法 typ，表示类型，JWT 1.3、jwt载荷信息payload 主要用来存储什么？ 主
Grpc 整合 Nacos SpringBoot 日常使用（Java版本）包括 Jwt 认证
风团团
05-24 2782
最近感到有点子迷茫，天天写业务代码有点麻木，趁着有点空闲时间去了解了下 Grpc 这个框架，一方面是听说他很火，支持多种语言。另一方面也是为了将来可能需要用到他，未雨绸缪一下，当然了本文只是基于使用上来带大家入门 Grpc，应付基本的日常开发足够了，后续有时间给大家分析一波源码，帮助大家更好的理解 net.devh.boot.grpc 这个包里面关于自动装配、Grpc服务是如何注册、@GrpcService以及内置注解是如何生效的。
【gRPC】来聊一聊gRPC的认证
m0_37322399的博客
05-27 965
文章目录gRPC认证认证方式**gRPC消息传输的四种类型**SSL/TLS认证方式**那么什么是SSL/TLS？****那么HTTP 2 默认就有加密吗？****HTTP 2 有啥特性？****SSL/TLS加密的基本做法是啥?****SSL/TLS协议提供啥服务呢？****SSL/TLS协议提供的安全通道有哪些特性呢？**必要环境搭建OpenSSL安装TLS证书制作一个DEMO基于Token的认证方式又一个DEMO gRPC认证 我们再来回顾一下gRPC的基本结构 gRPC 是一个典型的C/S模型，需要
JWT
xiaoguangtouqiang的博客
06-24 1551
http状态保持
在Hyperledger Fabric中使用gRPC和ProtoBufv3
本文主要介绍了如何在Hyperledger Fabric项目中使用gRPC和Protocol Buffers v3（proto）进行客户端与服务端通信的消息修改。在进行此类操作时，需要确保已经正确安装并配置了gRPC、Protocol Buffers v3以及protoc的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值