Creating the Server and Client

    We decided not to generate this part automatically because it typically involves some team/org specific behavior such as wiring in different middlewares. This may change in the future. In the meantime, this section describes how to create a simple gRPC server that will serve our service code.

    Create a new file and write:

    1. go get -u github.com/mattn/go-sqlite3

    Next, let’s run the server, while we write a client that will communicate with it:

    Creating the Client

    Let’s create a simple client that makes some calls to our server. Create a new file named cmd/client/main.go and write:

    1. package main
    3. import (
    4.     "context"
    5.     "fmt"
    6.     "log"
    7.     "math/rand"
    8.     "time"
    10.     "ent-grpc-example/ent/proto/entpb"
    11.     "google.golang.org/grpc"
    12.     "google.golang.org/grpc/status"
    13. )
    15. func main() {
    16.     rand.Seed(time.Now().UnixNano())
    18.     conn, err := grpc.Dial(":5000", grpc.WithInsecure())
    19.     if err != nil {
    20.         log.Fatalf("failed connecting to server: %s", err)
    21.     }
    22.     defer conn.Close()
    24.     // Create a User service Client on the connection.
    25.     client := entpb.NewUserServiceClient(conn)
    27.     // Ask the server to create a random User.
    28.     ctx := context.Background()
    29.     user := randomUser()
    30.     created, err := client.Create(ctx, &entpb.CreateUserRequest{
    31.         User: user,
    32.     })
    33.     if err != nil {
    34.         se, _ := status.FromError(err)
    35.         log.Fatalf("failed creating user: status=%s message=%s", se.Code(), se.Message())
    36.     log.Printf("user created with id: %d", created.Id)
    38.     // On a separate RPC invocation, retrieve the user we saved previously.
    39.     get, err := client.Get(ctx, &entpb.GetUserRequest{
    40.         Id: created.Id,
    41.     })
    42.     if err != nil {
    43.         se, _ := status.FromError(err)
    44.         log.Fatalf("failed retrieving user: status=%s message=%s", se.Code(), se.Message())
    45.     }
    46.     log.Printf("retrieved user with id=%d: %v", get.Id, get)
    47. }
    49. func randomUser() *entpb.User {
    50.     return &entpb.User{
    51.         Name:         fmt.Sprintf("user_%d", rand.Int()),
    52.         EmailAddress: fmt.Sprintf("user_%d@example.com", rand.Int()),
    53.     }
    54. }

    Observe the output:

    Hooray! We have successfully created a real gRPC client to talk to our real gRPC server! In the next sections, we will see how the ent/gRPC integration deals with more advanced ent schema definitions.