aspnetcore微服务之间grpc通信,无proto文件

群山春晓

aspnetcore微服务之间通信grpc，一般服务对外接口用restful架构，HTTP请求，服务之间的通信grpc多走内网。
以前写过一篇grpc和web前端之间的通讯，代码如下：
exercisebook/grpc/grpc-web at main · liuzhixin405/exercisebook (github.com)
 
本次是微服务之间的通信使用了开源软件MagicOnion,该软件定义接口约束免去proto复杂配置，类似orleans或者webservice，服务调用都通过约定接口规范做传输调用，使用起来非常简单和简洁。
下面通过服务之间调用的示例代码做演示：

Server里面包含简单jwt的token的生成，client和002需要调用登录，通过外部接口调用传入用户和密码，内部再调用jwt服务。

 
服务之间调用如果不用proto的话，那么接口必须是公共部分，值得注意的是接口的参数和返回值必须 包含[MessagePackObject(true)]的特性，硬性条件。返回值必须被UnaryResult包裹，接口继承MagicOnion的IService,有兴趣深入的自己研究源码。

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Threading.Tasks;
6. using MagicOnion;
7. using MessagePack;
9. namespace MicroService.Shared
10. {
11.     public interface IAccountService:IService<IAccountService>
12.     {
13.         UnaryResult<SignInResponse> SignInAsync(string signInId, string password);
14.         UnaryResult<CurrentUserResponse> GetCurrentUserNameAsync();
15.         UnaryResult<string> DangerousOperationAsync();
16.     }
18.     [MessagePackObject(true)]
19.     public class SignInResponse
20.     {
21.         public long UserId { get; set; }
22.         public string Name { get; set; }
23.         public string Token { get; set; }
24.         public DateTimeOffset Expiration { get; set; }
25.         public bool Success { get; set; }
27.         public static SignInResponse Failed { get; } = new SignInResponse() { Success = false };
29.         public SignInResponse() { }
31.         public SignInResponse(long userId, string name, string token, DateTimeOffset expiration)
32.         {
33.             Success = true;
34.             UserId = userId;
35.             Name = name;
36.             Token = token;
37.             Expiration = expiration;
38.         }
39.     }
41.     [MessagePackObject(true)]
42.     public class CurrentUserResponse
43.     {
44.         public static CurrentUserResponse Anonymous { get; } = new CurrentUserResponse() { IsAuthenticated = false, Name = "Anonymous" };
46.         public bool IsAuthenticated { get; set; }
47.         public string Name { get; set; }
48.         public long UserId { get; set; }
49.     }
50. }

复制代码

上面GrpcClientPool和IGrpcClientFactory是我封装的客户端请求的一个链接池，跟MagicOnion没有任何关系。客户端如果使用原生的Grpc.Net.Client库作为客户端请求完全可以,通过 MagicOnionClient.Create(channel)把grpcchannel塞入拿到接口服务即可。
服务端代码如下：

1. using JwtAuthApp.Server.Authentication;
2. using Microsoft.AspNetCore.Authentication.JwtBearer;
3. using Microsoft.AspNetCore.Server.Kestrel.Core;
4. using Microsoft.IdentityModel.Tokens;
6. namespace JwtAuthApp.Server
7. {
8.     public class Program
9.     {
10.         public static void Main(string[] args)
11.         {
12.             var builder = WebApplication.CreateBuilder(args);
14.             // Add services to the container.
15.             builder.WebHost.ConfigureKestrel(options =>
16.             {
17.                 options.ConfigureEndpointDefaults(endpointOptions =>
18.                 {
19.                     endpointOptions.Protocols = HttpProtocols.Http2;
20.                 });
21.             });
22.             builder.Services.AddGrpc();
23.             builder.Services.AddMagicOnion();
25.             builder.Services.AddSingleton<JwtTokenService>();
26.             builder.Services.Configure<JwtTokenServiceOptions>(builder.Configuration.GetSection("JwtAuthApp.Server:JwtTokenService"));
27.             builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
28.                 .AddJwtBearer(options =>
29.                 {
30.                     options.TokenValidationParameters = new TokenValidationParameters
31.                     {
32.                         IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(builder.Configuration.GetSection("JwtAuthApp.Server:JwtTokenService:Secret").Value!)),
33.                         RequireExpirationTime = true,
34.                         RequireSignedTokens = true,
35.                         ClockSkew = TimeSpan.FromSeconds(10),
37.                         ValidateIssuer = false,
38.                         ValidateAudience = false,
39.                         ValidateLifetime = true,
40.                         ValidateIssuerSigningKey = true,
41.                     };
42. #if DEBUG
43.                     options.RequireHttpsMetadata = false;
44. #endif
45.                 });
46.             builder.Services.AddAuthorization();
48.             builder.Services.AddControllers();
49.             // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
50.             builder.Services.AddEndpointsApiExplorer();
51.             builder.Services.AddSwaggerGen();
53.             var app = builder.Build();
55.             // Configure the HTTP request pipeline.
56.             if (app.Environment.IsDevelopment())
57.             {
58.                 app.UseSwagger();
59.                 app.UseSwaggerUI();
60.             }
62.             app.UseHttpsRedirection();
64.             app.UseAuthentication();
66.             app.UseAuthorization();
69.             app.MapControllers();
70.             app.MapMagicOnionService();
71.             app.Run();
72.         }
73.     }
74. }

复制代码

1. 实际上跟组件有关的代码只有这么多了，剩下的就是jwt的。<br>

复制代码

1. builder.WebHost.ConfigureKestrel(options =>
2.             {
3.                 options.ConfigureEndpointDefaults(endpointOptions =>
4.                 {
5.                     endpointOptions.Protocols = HttpProtocols.Http2;
6.                 });
7.             });
8.             builder.Services.AddGrpc();
9.             builder.Services.AddMagicOnion();
10.             app.MapMagicOnionService();

复制代码

当然作为服务的提供者实现IAccountService的接口是必须的。

1. using Grpc.Core;
2. using JwtAuthApp.Server.Authentication;
3. using System.Security.Claims;
4. using MagicOnion;
5. using MagicOnion.Server;
6. using MicroService.Shared;
7. using Microsoft.AspNetCore.Authorization;
9. namespace JwtAuthApp.Server.GrpcService
10. {
11.     [Authorize]
12.     public class AccountService : ServiceBase<IAccountService>, IAccountService
13.     {
14.         private static IDictionary<string, (string Password, long UserId, string DisplayName)> DummyUsers = new Dictionary<string, (string, long, string)>(StringComparer.OrdinalIgnoreCase)
15.         {
16.             {"signInId001", ("123456", 1001, "Jack")},
17.             {"signInId002", ("123456", 1002, "Rose")},
18.         };
20.         private readonly JwtTokenService _jwtTokenService;
22.         public AccountService(JwtTokenService jwtTokenService)
23.         {
24.             _jwtTokenService = jwtTokenService ?? throw new ArgumentNullException(nameof(jwtTokenService));
25.         }
27.         [AllowAnonymous]
28.         public async UnaryResult<SignInResponse> SignInAsync(string signInId, string password)
29.         {
30.             await Task.Delay(1); // some workloads...
32.             if (DummyUsers.TryGetValue(signInId, out var userInfo) && userInfo.Password == password)
33.             {
34.                 var (token, expires) = _jwtTokenService.CreateToken(userInfo.UserId, userInfo.DisplayName);
36.                 return new SignInResponse(
37.                     userInfo.UserId,
38.                     userInfo.DisplayName,
39.                     token,
40.                     expires
41.                 );
42.             }
44.             return SignInResponse.Failed;
45.         }
47.         [AllowAnonymous]
48.         public async UnaryResult<CurrentUserResponse> GetCurrentUserNameAsync()
49.         {
50.             await Task.Delay(1); // some workloads...
52.             var userPrincipal = Context.CallContext.GetHttpContext().User;
53.             if (userPrincipal.Identity?.IsAuthenticated ?? false)
54.             {
55.                 if (!int.TryParse(userPrincipal.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier)?.Value, out var userId))
56.                 {
57.                     return CurrentUserResponse.Anonymous;
58.                 }
60.                 var user = DummyUsers.SingleOrDefault(x => x.Value.UserId == userId).Value;
61.                 return new CurrentUserResponse()
62.                 {
63.                     IsAuthenticated = true,
64.                     UserId = user.UserId,
65.                     Name = user.DisplayName,
66.                 };
67.             }
69.             return CurrentUserResponse.Anonymous;
70.         }
72.         [Authorize(Roles = "Administrators")]
73.         public async UnaryResult<string> DangerousOperationAsync()
74.         {
75.             await Task.Delay(1); // some workloads...
77.             return "rm -rf /";
78.         }
79.     }
80. }

复制代码

当然jwt服务的代码也必不可少，还有密钥串json文件。

1. using Microsoft.Extensions.Options;
2. using Microsoft.IdentityModel.Tokens;
3. using System.IdentityModel.Tokens.Jwt;
4. using System.Security.Claims;
6. namespace JwtAuthApp.Server.Authentication
7. {
8.     public class JwtTokenService
9.     {
10.         private readonly SymmetricSecurityKey _securityKey;
12.         public JwtTokenService(IOptions<JwtTokenServiceOptions> jwtTokenServiceOptions)
13.         {
14.             _securityKey = new SymmetricSecurityKey(Convert.FromBase64String(jwtTokenServiceOptions.Value.Secret));
15.         }
17.         public (string Token, DateTime Expires) CreateToken(long userId, string displayName)
18.         {
19.             var jwtTokenHandler = new JwtSecurityTokenHandler();
20.             var expires = DateTime.UtcNow.AddSeconds(10);
21.             var token = jwtTokenHandler.CreateEncodedJwt(new SecurityTokenDescriptor()
22.             {
23.                 SigningCredentials = new SigningCredentials(_securityKey, SecurityAlgorithms.HmacSha256),
24.                 Subject = new ClaimsIdentity(new[]
25.                 {
26.                     new Claim(ClaimTypes.Name, displayName),
27.                     new Claim(ClaimTypes.NameIdentifier, userId.ToString()),
28.                 }),
29.                 Expires = expires,
30.             });
32.             return (token, expires);
33.         }
34.     }
36.     public class JwtTokenServiceOptions
37.     {
38.         public string Secret { get; set; }
39.     }
40. }

复制代码

1. {
2.     "JwtAuthApp.Server": {
3.         "JwtTokenService": {
4.             /* 64 bytes (512 bits) secret key */
5.             "Secret": "/Z8OkdguxFFbaxOIG1q+V9HeujzMKg1n9gcAYB+x4QvhF87XcD8sQA4VsdwqKVuCmVrXWxReh/6dmVXrjQoo9Q=="
6.         }
7.     },
8.     "Logging": {
9.         "LogLevel": {
10.             "Default": "Trace",
11.             "System": "Information",
12.             "Microsoft": "Information"
13.         }
14.     }
15. }

复制代码

上面的代码完全可以运行一个jwt服务了。
下面就是客户端代码，因为两个客户端是一样的只是做测试，所以列出一个就够了。

1. using Login.Client.GrpcClient;
2. using MicroService.Shared.GrpcPool;
3. using MicroService.Shared;
5. namespace Login.Client
6. {
7.     public class Program
8.     {
9.         public static void Main(string[] args)
10.         {
11.             var builder = WebApplication.CreateBuilder(args);
13.             // Add services to the container.
15.             builder.Services.AddControllers();
16.             // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
17.             builder.Services.AddEndpointsApiExplorer();
18.             builder.Services.AddSwaggerGen();
19.             builder.Services.AddTransient<IGrpcClientFactory<IAccountService>, LoginClientFactory>();
20.             builder.Services.AddTransient(sp => new GrpcClientPool<IAccountService>(sp.GetService<IGrpcClientFactory<IAccountService>>(), builder.Configuration, builder.Configuration["Grpc:Service:JwtAuthApp.ServiceAddress"]));
22.             var app = builder.Build();
24.             // Configure the HTTP request pipeline.
25.             if (app.Environment.IsDevelopment())
26.             {
27.                 app.UseSwagger();
28.                 app.UseSwaggerUI();
29.             }
31.             app.UseHttpsRedirection();
33.             app.UseAuthorization();
36.             app.MapControllers();
38.             app.Run();
39.         }
40.     }
41. }

复制代码

客户端Program.cs只是注入了连接池，没有其他任何多余代码，配置文件当然必不可少。

1.   builder.Services.AddTransient<IGrpcClientFactory<IAccountService>, LoginClientFactory>();
2.   builder.Services.AddTransient(sp => new GrpcClientPool<IAccountService>(sp.GetService<IGrpcClientFactory<IAccountService>>(), builder.Configuration, builder.Configuration["Grpc:Service:JwtAuthApp.ServiceAddress"]));

复制代码

1. {
2.     "Logging": {
3.         "LogLevel": {
4.             "Default": "Information",
5.             "Microsoft.AspNetCore": "Warning"
6.         }
7.     },
8.     "AllowedHosts": "*",
9.     "Grpc": {
10.         "Service": {
11.             "JwtAuthApp.ServiceAddress": "https://localhost:7021"
12.         },
13.         "maxConnections": 10,
14.         "handoverTimeout":10  // seconds
15.     }
16. }

复制代码

登录的对外接口如下：

1. using System.ComponentModel.DataAnnotations;
2. using System.Threading.Channels;
3. using Grpc.Net.Client;
4. using Login.Client.GrpcClient;
5. using MagicOnion.Client;
6. using MicroService.Shared;
7. using MicroService.Shared.GrpcPool;
8. using Microsoft.AspNetCore.Mvc;
10. namespace Login.Client.Controllers
11. {
12.     [ApiController]
13.     [Route("[controller]")]
14.     public class LoginController : ControllerBase
15.     {
18.         private readonly ILogger<LoginController> _logger;
19.         private IConfiguration _configuration;
20.         private readonly IGrpcClientFactory<IAccountService> _grpcClientFactory;
21.         private readonly GrpcClientPool<IAccountService> _grpcClientPool;
22.         public LoginController(ILogger<LoginController> logger, IConfiguration configuration, IGrpcClientFactory<IAccountService> grpcClientFactory, GrpcClientPool<IAccountService> grpcClientPool)
23.         {
25.             _configuration = configuration;
26.             _logger = logger;
27.             _grpcClientFactory = grpcClientFactory;
28.             _grpcClientPool = grpcClientPool;
29.         }
31.         [HttpGet(Name = "Login")]
32.         public async Task<ActionResult<Tuple<bool,string?>>> Login([Required]string signInId, [Required]string pwd)
33.         {
34.             SignInResponse authResult;
35.             /*using (var channel = GrpcChannel.ForAddress(_configuration["JwtAuthApp.ServiceAddress"]))
36.             {
37.                 //var accountClient = MagicOnionClient.Create<IAccountService>(channel);
39.                  
40.             }*/
42.             var client = _grpcClientPool.GetClient();
43.             try
44.             {
45.                 // 使用client进行gRPC调用
46.                 authResult = await client.SignInAsync(signInId, pwd);
47.             }
48.             finally
49.             {
50.                 _grpcClientPool.ReleaseClient(client);
51.             }
52.             return (authResult!=null && authResult.Success)?  Tuple.Create(true,authResult.Token): Tuple.Create(false,string.Empty);
53.         }
54.     }
55. }

复制代码

客户端就剩下一个返回服务的接口工厂了

1. using Grpc.Net.Client;
2. using MagicOnion.Client;
3. using MicroService.Shared;
4. using MicroService.Shared.GrpcPool;
6. namespace Login.Client.GrpcClient
7. {
8.     public class LoginClientFactory : IGrpcClientFactory<IAccountService>
9.     {
10.         public IAccountService Create(GrpcChannel channel)
11.         {
12.             return MagicOnionClient.Create<IAccountService>(channel);
13.         }
14.     }
15. }

复制代码

最后就是连接池的实现：

1. using System;
2. using System.Collections.Concurrent;
3. using System.Collections.Generic;
4. using System.Linq;
5. using System.Text;
6. using System.Threading.Channels;
7. using System.Threading.Tasks;
8. using Grpc.Core;
9. using Grpc.Net.Client;
10. using Microsoft.Extensions.Configuration;
11. using Microsoft.Extensions.Hosting;
13. namespace MicroService.Shared.GrpcPool
14. {
15.     public class GrpcClientPool<TClient>
16.     {
17.         private readonly static ConcurrentBag<TClient> _clientPool = new ConcurrentBag<TClient>();
18.       
19.         private readonly IGrpcClientFactory<TClient> _clientFactory;
20.       
21.         private readonly int _maxConnections;
22.         private readonly TimeSpan _handoverTimeout;
23.         private readonly string _address;
24.         private readonly DateTime _now;
25.         public GrpcClientPool(IGrpcClientFactory<TClient> clientFactory,
26.             IConfiguration configuration,string address)
27.         {
28.             _now =  DateTime.Now;
29.             _clientFactory = clientFactory;
30.             _maxConnections = int.Parse(configuration["Grpc:maxConnections"]?? throw new ArgumentNullException("grpc maxconnections is null"));
31.             _handoverTimeout = TimeSpan.FromSeconds(double.Parse(configuration["Grpc:maxConnections"]??throw new ArgumentNullException("grpc timeout is null")));
32.             _address = address;
33.         }
35.         public TClient GetClient()
36.         {
37.             if (_clientPool.TryTake(out var client))
38.             {
39.                 return client;
40.             }
42.             if (_clientPool.Count < _maxConnections)
43.             {
44.                 var channel = GrpcChannel.ForAddress(_address);
45.                 client = _clientFactory.Create(channel);
46.                 _clientPool.Add(client);
47.                 return client;
48.             }
50.             if (!_clientPool.TryTake(out client) && DateTime.Now.Subtract(_now) > _handoverTimeout)
51.             {
52.                 throw new TimeoutException("Failed to acquire a connection from the pool within the specified timeout.");
53.             }
54.             return client;
55.         }
57.         public void ReleaseClient(TClient client)
58.         {
59.             if (client == null)
60.             {
61.                 return;
62.             }
63.             _clientPool.Add(client);
64.         }
65.     }
66. }

复制代码

上面已经演示过了接口调用的接口，这里不再展示，代码示例如下：
liuzhixin405/efcore-template (github.com)
 
不想做池化客户端注入的代码全部不需要了，只需要下面代码就可以了，代码会更少更精简。

1. SignInResponse authResult;
2.             using (var channel = GrpcChannel.ForAddress(_configuration["JwtAuthApp.ServiceAddress"]))
3.             {
4.                 var accountClient = MagicOnionClient.Create<IAccountService>(channel);
5.                  authResult = await accountClient.SignInAsync(user, pwd);
6.             }

复制代码

 

来源:https://www.cnblogs.com/morec/archive/2023/10/22/17779841.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！