保持 Dotnet Core Grpc Server 作为控制台应用程序运行？

Question

我试图让 Grpc 服务器作为控制台守护进程运行。这个 gRPC 服务器是一个在 docker 容器中运行的微服务。

我能找到的所有示例都使用以下内容：

Console.ReadKey();

这确实阻塞了主线程并使其保持运行，但在 docker 中不起作用，并出现以下错误：

"Cannot read keys when either application does not have a console or when console input has been redirected. Try Console.Read."

现在我可能会尝试专门为 docker 找到一种解决方法，但这仍然感觉不对。有谁知道保持服务运行的良好“生产就绪”方式？

Answer 1

您现在可以使用 Microsoft.Extensions.Hosting pacakge，它是 asp.net 核心和控制台应用程序的托管和启动基础架构。

与 asp.net core 一样，您可以使用 HostBuilder API 开始构建 gRPC 主机并进行设置。以下代码是为了让控制台应用程序一直运行直到它停止（例如使用 Control-C）：

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static async Task Main(string[] args)
    {
        var hostBuilder = new HostBuilder();

         // register your configuration and services.
        ....

        await hostBuilder.RunConsoleAsync();
    }
}

为了运行 gRPC 服务，您需要在托管服务中启动/停止 Grpc.Core.Server。托管服务基本上是在主机本身启动时由主机运行的一段代码，在它停止时也是如此。这在 IHostedService 接口中表示。也就是说，实现一个 GrpcHostedService 来覆盖接口：

using System.Threading;
using System.Threading.Tasks;
using Grpc.Core;
using Microsoft.Extensions.Hosting;

namespace Grpc.Host
{
    public class GrpcHostedService: IHostedService
    {
        private Server _server;

        public GrpcHostedService(Server server)
        {
            _server = server;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _server.Start();
            return Task.CompletedTask;
        }

        public async Task StopAsync(CancellationToken cancellationToken) => await _server.ShutdownAsync();
    }
}

真的很简单。我们通过依赖注入获得一个GrpcHostedService 实例，并在主机启动时在其上运行 StartAsync。当主机停止时，我们运行 StopAsync 以便我们可以优雅地关闭所有东西，包括 Grpc 服务器。

然后回到Program.cs并进行一些更改：

public class Program
{
    public static async Task Main(string[] args)
    {
        var hostBuilder = new HostBuilder()
             // Add configuration, logging, ...
            .ConfigureServices((hostContext, services) =>
            {
                // Better to use Dependency Injection for GreeterImpl
                Server server = new Server
                {
                    Services = {Greeter.BindService(new GreeterImpl())},
                    Ports = {new ServerPort("localhost", 5000, ServerCredentials.Insecure)}
                };
                services.AddSingleton<Server>(server);
                services.AddSingleton<IHostedService, GrpcHostedService>();
            });

        await hostBuilder.RunConsoleAsync();
    }
}

通过这样做，通用主机将自动在我们的托管服务上运行 StartAsync，这反过来又会在 Server 实例上调用 StartAsync，实质上是启动 gRPC 服务器。

当我们使用 Control-C 关闭主机时，通用主机将自动在我们的托管服务上调用 StopAsync，该服务将再次在 Server 实例上调用 StopAsync，这将进行一些清理。

HostBuilder中的其他配置可以看这个blog。

Answer 2

使用ManualResetEvent 阻塞主线程，直到收到关闭事件。

例如在一个琐碎的情况下：

class Program
{
  public static ManualResetEvent Shutdown = new ManualResetEvent(false);

  static void Main(string[] args)
  {
    Task.Run(() =>
    {
      Console.WriteLine("Waiting in other thread...");
      Thread.Sleep(2000);
      Shutdown.Set();
    });

    Console.WriteLine("Waiting for signal");
    Shutdown.WaitOne();

    Console.WriteLine("Resolved");
  }
}

例如，在您的情况下，我想像：

using System;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using Grpc.Core;
using Helloworld;

namespace GreeterServer
{
  class GreeterImpl : Greeter.GreeterBase
  {
    // Server side handler of the SayHello RPC
    public override Task<HelloReply> SayHello(HelloRequest request, ServerCallContext context)
    {
      Program.Shutdown.Set(); // <--- Signals the main thread to continue 
      return Task.FromResult(new HelloReply {Message = "Hello " + request.Name});
    }
  }

  class Program
  {
    const int Port = 50051;

    public static ManualResetEvent Shutdown = new ManualResetEvent(false);

    public static void Main(string[] args)
    {
      Server server = new Server
      {
        Services = {Greeter.BindService(new GreeterImpl())},
        Ports = {new ServerPort("localhost", Port, ServerCredentials.Insecure)}
      };
      server.Start();

      Shutdown.WaitOne(); // <--- Waits for ever or signal received

      server.ShutdownAsync().Wait();
    }
  }
}