grpc

Got it — I’ll give you a full working example of a gRPC with TLS/SSL (gRPCs) implementation in .NET 8 so you can run it end-to-end.
This will include:

1. Proto file (service contract)

2. Server implementation with TLS enabled (Kestrel)

3. Client implementation connecting securely

4. Certificate generation for local testing

1. Create the .proto file

Protos/Greeter.proto

syntax = "proto3";

option csharp_namespace = "GrpcDemo";

package greet;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

2. Generate certificates for gRPCs

Run these commands in PowerShell or Bash:

# Create server certificate
dotnet dev-certs https --clean
dotnet dev-certs https -ep ./server.pfx -p password
dotnet dev-certs https --trust

# Extract .crt for client trust (optional in dev)
openssl pkcs12 -in server.pfx -clcerts -nokeys -out server.crt -passin pass:password

3. Server implementation

Server/Program.cs

using GrpcDemo;
using GrpcDemo.Services;

var builder = WebApplication.CreateBuilder(args);

// Enable gRPC
builder.Services.AddGrpc();

// Configure Kestrel for gRPC over TLS
builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenAnyIP(5001, listenOptions =>
    {
        listenOptions.Protocols = Microsoft.AspNetCore.Server.Kestrel.Core.HttpProtocols.Http2;
        listenOptions.UseHttps("server.pfx", "password");
    });
});

var app = builder.Build();

app.MapGrpcService();
app.MapGet("/", () => "gRPC Server running securely.");

app.Run();

Server/Services/GreeterService.cs

using Grpc.Core;
using greet;

namespace GrpcDemo.Services
{
    public class GreeterService : Greeter.GreeterBase
    {
        public override Task SayHello(HelloRequest request, ServerCallContext context)
        {
            return Task.FromResult(new HelloReply
            {
                Message = $"Hello, {request.Name} (secure gRPC)!"
            });
        }
    }
}

4. Client implementation

Client/Program.cs

using Grpc.Net.Client;
using greet;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;

// Load server certificate for trust (optional in dev)
var cert = new X509Certificate2("server.crt");
var handler = new HttpClientHandler();
handler.ClientCertificates.Add(cert);
handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;

// Connect to gRPC server over HTTPS
using var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
{
    HttpHandler = handler
});

var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(new HelloRequest { Name = "Naimish" });

Console.WriteLine(reply.Message);

5. Project setup steps

For the server:

dotnet new grpc -n Server
# Replace Program.cs and add Greeter.proto
dotnet add package Grpc.AspNetCore
dotnet run

For the client:

dotnet new console -n Client
dotnet add package Grpc.Net.Client
dotnet add package Google.Protobuf
dotnet add package Grpc.Tools
# Add Greeter.proto and configure csproj to compile it

Client .csproj snippet for .proto:

? How it works

• The server listens on port 5001 using HTTP/2 over TLS (gRPCs).

• The client connects using the server’s TLS cert.

• The proto file defines the contract; Grpc.Tools generates the C# types.

If you want, I can extend this example with bidirectional streaming, unary calls, and deadline handling so it covers all gRPC patterns in secure mode.

Do you want me to make that advanced version next?