gRPC Server - Go

A gRPC server written in Go.

This sample can be used to try out gRPC, HTTP/2, and custom port configuration in a knative service.

The container image is built with two binaries: the server and the client. This is done for ease of testing and is not a recommended practice for production containers.

Prerequisites

Build and Deploy the sample code

  1. Download a copy of the code:
  1. git clone -b "{{< branch >}}" https://github.com/knative/docs knative-docs
  2. cd knative-docs/docs/serving/samples/grpc-ping-go
  1. Use Docker to build a container image for this service and push to Docker Hub.

Replace {username} with your Docker Hub username then run the commands:

  1. # Build the container on your local machine.
  2. docker build --tag "{username}/grpc-ping-go" .
  4. # Push the container to docker registry.
  5. docker push "{username}/grpc-ping-go"

  1. Update the service.yaml file in the project to reference the published image from step 1.

    Replace {username} in service.yaml with your Docker Hub user name:

  1. apiVersion: serving.knative.dev/v1
  2. kind: Service
  3. metadata:
  4.   name: grpc-ping
  5.   namespace: default
  6. spec:
  7.   template:
  8.     spec:
  9.       containers:
  10.       - image: docker.io/{username}/grpc-ping-go
  11.         ports:
  12.           - name: h2c
  13.             containerPort: 8080
  1. Use kubectl to deploy the service.
  1. kubectl apply --filename service.yaml

Response:

  1. service "grpc-ping" created

Exploring

Once deployed, you can inspect the created resources with kubectl commands:

  1. # This will show the Knative service that we created:
  2. kubectl get ksvc --output yaml
  4. # This will show the Route, created by the service:
  5. kubectl get route --output yaml
  7. # This will show the Configuration, created by the service:
  8. kubectl get configurations --output yaml
  10. # This will show the Revision, created by the Configuration:
  11. kubectl get revisions --output yaml

Testing the service

Testing the gRPC service requires using a gRPC client built from the same protobuf definition used by the server.

The Dockerfile builds the client binary. To run the client you will use the same container image deployed for the server with an override to the entrypoint command to use the client binary instead of the server binary.

Replace {username} with your Docker Hub user name and run the command:

  1. docker run --rm {username}/grpc-ping-go \
  2.   /client \
  3.   -server_addr="grpc-ping.default.1.2.3.4.xip.io:80" \
  4.   -insecure

The arguments after the container tag {username}/grpc-ping-go are used instead of the entrypoint command defined in the Dockerfile CMD statement.

Feedback

Was this page helpful?

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.