# Serverless gRPC + ASP.NET Core with Knative

Author: [Mete Atamel](https://atamel.dev/) | Published: 2019-07-24 | Updated: 2020-04-11 | Canonical: https://atamel.dev/posts/2019/07-24_serverless-grpc---asp-net-core-with-knative/


![](/img/2019/0__nv__x9HwUJDwaIYEg.jpg)

I was recently going through the [ASP.NET Core updates in .NET Core 3.0 Preview 3](https://devblogs.microsoft.com/aspnet/asp-net-core-updates-in-net-core-3-0-preview-3/) post, this section got my attention: _gRPC template._

Apparently, .NET Core 3.0 got a new [gRPC](https://grpc.io/) template for easily building gRPC services with ASP.NET Core. I tested gRPC and .NET before and I have some samples in my [grpc-samples-dotnet](https://github.com/meteatamel/grpc-samples-dotnet) repo. Even though gRPC and .NET worked before, it wasn’t that straightforward to setup. I was curious to try out the new gRPC template and see how it helped.

Additionally, I wanted to go beyond a simple gRPC service and see what it takes to turn it into a serverless Knative service with all the benefits of Knative such as autoscaling, revisions, etc.

If you want to try this out yourself, I have a new section in my Knative tutorial: [Serverless gRPC with Knative](https://github.com/meteatamel/knative-tutorial/blob/master/docs/07.5-grpc.md) with detailed instructions. In this blog post, I want to highlight some of the main steps for a serverless, gRPC enabled, ASP.NET Core service deployed to Knative on Google Kubernetes Engine (GKE).

### Create a gRPC service with the new template

Creating a HelloWorld gRPC service with .NET Core 3.0 couldn’t be any simpler with the gRPC template. This is the command:

```sh
\> dotnet new grpc -o GrpcGreeter
```

This command does a few things in the background:

* Creates an ASP.NET Core project with all gRPC dependencies already included.
* Creates a gRPC service definition file named `greet.proto`.
* Auto-generates all gRPC stubs based on the service definition file.
* Creates a gRPC service (`GreeterService.cs`) based on the auto-generated gRPC stub.
* Configures the gRPC pipeline in `Startup.cs` to map to `GreeterService.cs`

The end result is that you have all of gRPC details taken care of and you can simply start running the service:

```sh
\> dotnet run
info: Microsoft.Hosting.Lifetime\[0\] Now listening on: [http://localhost:50051](http://localhost:50051)
```

This is much simpler than what I had to before. Great job from the .NET Core team!

### Containerize the gRPC service

Next step is to containerize the gRPC service, so it can be deployed to Knative. The `Dockerfile` looks something like this:

```yaml
FROM mcr.microsoft.com/dotnet/core/sdk:3.0  
  
WORKDIR /app  
COPY \*.csproj .  
RUN dotnet restore  
  
COPY . .  
  
RUN dotnet publish -c Release -o out  
  
ENV PORT 8080  
  
ENV ASPNETCORE\_URLS http://\*:${PORT}  
  
CMD \["dotnet", "out/GrpcGreeter.dll"\]
```

I’m using .NET Core 3.0 as the base image and making sure that the service runs on port 8080, instead of the default gRPC port 50051. Nothing special.

### Deploy the Knative service

Once the image is built and pushed, define the Knative service in a `service.yaml` file:

```yaml
apiVersion: serving.knative.dev/v1beta1  
kind: Service  
metadata:  
  name: grpc-greeter  
  namespace: default  
spec:  
  template:  
    spec:  
      containers:  
        # Replace {username} with your actual DockerHub  
        - image: docker.io/{username}/grpc-greeter:v1  
 **ports:  
          - name: h2c  
            containerPort: 8080**
```

This is a plain Knative service definition pointing to the image. The only special part is the **ports** section where we define a **h2c** port 8080. This tells Knative that container is expecting HTTP/2 traffic on port 8080.

Deploy the Knative service:

```sh
\> kubectl apply -f service.yaml
```

Make sure that a pod with gRPC service is running:

```sh
\> kubectl get pods 

NAME grpc-greeter-5tpwl-deployment-6fb423289c5-r5qmt
```

### Test it out

To test out the gRPC service, you need the corresponding gRPC enabled client. You can refer to [Create a gRPC client](https://github.com/meteatamel/knative-tutorial/blob/master/docs/07.5-grpc-csharp.md#create-a-grpc-client) part of my tutorial on how to create a `GrpcGreeterClient.cs`. Once you have the client, just point to your Knative service. You should see a reply from the gRPC service running in Knative:

```sh
\> dotnet run  
Greeting: Hello GreeterClient Press any key to exit...
```

On the surface, this looks like the response you’d get from a plain gRPC service. However, it’s a Knative managed service, meaning you have 0-n automatic scaling, revisions and all other benefits of running a service in Knative.

.NET Core 3.0 makes it really easy to get started with gRPC and Knative transforms plain gRPC into serverless-style services that autoscale and respond to events. This is a powerful combination and hopefully this blog post and the corresponding tutorial gave you a glimpse of how to use .NET Core with gRPC and Knative.