.NET Core 3.0 gRPC服务托管方式及Azure部署方案咨询

Hey there! Let's tackle your questions about hosting .NET Core 3.0 gRPC services—this is a common topic once you've built your first gRPC service, so I'm glad you're asking these details.

1. How to host a gRPC server app written in .NET Core 3.0? #

Since gRPC in .NET Core 3.0 is built on top of ASP.NET Core, hosting it follows similar patterns to regular ASP.NET Core apps, with a few key considerations around HTTP/2 support (gRPC requires HTTP/2 to work). Here's the breakdown:

• Local development: If you used the Visual Studio gRPC template, simply hit F5 to launch the app. It uses the Kestrel web server under the hood, pre-configured to listen on a HTTPS port (usually 5001) with HTTP/2 enabled. You can test it immediately with a gRPC client targeting https://localhost:5001.
• Manual self-hosting: If you need to customize the hosting setup, modify your Program.cs to explicitly configure Kestrel for HTTP/2. For example:

  public static IHostBuilder CreateHostBuilder(string[] args) =>
      Host.CreateDefaultBuilder(args)
          .ConfigureWebHostDefaults(webBuilder =>
          {
              webBuilder.ConfigureKestrel(options =>
              {
                  // Listen on localhost port 5001, enforce HTTP/2
                  options.ListenLocalhost(5001, o => o.Protocols = HttpProtocols.Http2);
              });
              webBuilder.UseStartup<Startup>();
          });
  

• Post-deployment check: Always verify your hosting environment supports HTTP/2—gRPC won't function over HTTP/1.1.

2. Web hosting options for .NET Core 3.0 gRPC services & Azure solutions #

You have several solid options for hosting your gRPC service on the web, including first-class support on Azure. Let's go through them:

General web hosting options #

• Self-hosted Kestrel with reverse proxy: Deploy the app to your own server (Windows or Linux), run Kestrel as the backend server, and put a reverse proxy like Nginx (Linux) or IIS (Windows) in front. For Nginx, add http2 on to your server block to enable HTTP/2 forwarding. For IIS, you'll need Windows Server 2019/Windows 10 1809+ (since older versions don't support HTTP/2 for ASP.NET Core apps).
• IIS direct hosting: Deploy directly to IIS (again, only on supported Windows versions). Configure the ASP.NET Core Module in web.config to forward HTTP/2 requests to Kestrel— the Visual Studio publish wizard handles this automatically if you target IIS.
• Containerized deployment: Package your gRPC service into a Docker image using the official .NET Core 3.0 base images, then deploy to any container platform (Docker Swarm, Kubernetes, etc.). A sample Dockerfile might look like this:

  FROM mcr.microsoft.com/dotnet/core/aspnet:3.0 AS base
  WORKDIR /app
  EXPOSE 5001
  ENV ASPNETCORE_URLS=https://+:5001
  
  FROM mcr.microsoft.com/dotnet/core/sdk:3.0 AS build
  WORKDIR /src
  COPY ["GrpcService/GrpcService.csproj", "GrpcService/"]
  RUN dotnet restore "GrpcService/GrpcService.csproj"
  COPY . .
  WORKDIR "/src/GrpcService"
  RUN dotnet build "GrpcService.csproj" -c Release -o /app/build
  
  FROM build AS publish
  RUN dotnet publish "GrpcService.csproj" -c Release -o /app/publish
  
  FROM base AS final
  WORKDIR /app
  COPY --from=publish /app/publish .
  ENTRYPOINT ["dotnet", "GrpcService.dll"]
  

Azure-specific solutions #

Azure has great support for hosting .NET Core 3.0 gRPC services, with options for every use case:

• Azure App Service: The easiest PaaS option. Deploy your service directly via Git, ZIP deploy, or Visual Studio. For Windows App Service plans, enable HTTP/2 in the "General Settings" blade. Linux plans support HTTP/2 out of the box (just make sure your app listens to the PORT environment variable). App Service handles SSL, scaling, and maintenance for you.
• Azure Kubernetes Service (AKS): Perfect if you need container orchestration. Deploy your Docker image to AKS, configure an Ingress controller that supports HTTP/2 (like NGINX Ingress), and let Kubernetes manage scaling, load balancing, and self-healing.
• Azure Virtual Machines: For full control over your environment. Spin up a Windows Server 2019 or Linux VM, install the .NET Core 3.0 runtime, deploy your app, and set up a reverse proxy (Nginx/IIS) to handle HTTP/2 traffic.
• Azure Functions: Note that .NET Core 3.0 Functions have limited gRPC support—this is better for lightweight, event-driven workloads. For a full-fledged gRPC service, stick with App Service or AKS.

Hope this gives you all the info you need to choose the right hosting path for your gRPC service!

内容的提问来源于stack exchange，提问作者sourcewalker