Hello World

A hello world example using Go Micro

Overview

This is a helloworld example of using Go Micro. We’ll run through writing the whole thing.

Writing a service

Writing a service is incredibly simple with Go Micro. It provides you the framework to move fast without needing to understand everything at first. Below is a simple greeter service example that we’ll run through.

Find the full example code at examples/service.

Service Proto

One of the key requirements of microservices is strongly defined interfaces. Micro uses protobuf to achieve this.

Here we define the Greeter handler with the method Hello. It takes a Request and Response both with one string arguments.

  1. syntax = "proto3";
  3. service Greeter {
  4.     rpc Hello(Request) returns (Response) {}
  5. }
  7. message Request {
  8.     string name = 1;
  9. }
  11. message Response {
  12.     string greeting = 2;
  13. }

Generate Proto

After writing the proto definition we must compile it using protoc with the micro plugin.

  1. protoc --proto_path=$GOPATH/src:. --micro_out=. --go_out=. path/to/greeter.proto

Implement Service

Now that we’ve defined the service interface we need to implement the service.

Below is the code for the greeter service. It does the following:

  • Implements the interface defined for the Greeter handler
  • Initialises a micro.Service
  • Registers the Greeter handler
  • Runs the service
  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  7.     micro "github.com/micro/go-micro/v2"
  8.     proto "github.com/micro/examples/service/proto"
  9. )
  11. type Greeter struct{}
  13. func (g *Greeter) Hello(ctx context.Context, req *proto.Request, rsp *proto.Response) error {
  14.     rsp.Greeting = "Hello " + req.Name
  15.     return nil
  16. }
  18. func main() {
  19.     // Create a new service. Optionally include some options here.
  20.     service := micro.NewService(
  21.         micro.Name("greeter"),
  22.     )
  24.     // Init will parse the command line flags.
  25.     service.Init()
  27.     // Register handler
  28.     proto.RegisterGreeterHandler(service.Server(), new(Greeter))
  30.     // Run the server
  31.     if err := service.Run(); err != nil {
  32.         fmt.Println(err)
  33.     }
  34. }

Run Service

Now run the example using Go. If you’re working with the example code do the following:

  1. go run examples/service/main.go

This should output something like the folloing

  1. 2019-11-13 21:39:38.327452 I | Transport [http] Listening on [::]:32945
  2. 2019-11-13 21:39:38.327548 I | Broker [http] Connected to [::]:38955
  3. 2019-11-13 21:39:38.328095 I | Registry [mdns] Registering node: greeter-39373107-5ae7-42a2-b5e2-ebebf7eafbd9

Write Client

Once we’ve got a service we actually need a way to query it. This is at the heart of microservices as we not only serve but also consume other services. Below is the client code to query the greeter service.

The generated proto includes a greeter client to reduce boilerplate code.

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  7.     micro "github.com/micro/go-micro/v2"
  8.     proto "github.com/micro/examples/service/proto"
  9. )
  11. func main() {
  12.     // Create a new service
  13.     service := micro.NewService(micro.Name("greeter.client"))
  14.     // Initialise the client and parse command line flags
  15.     service.Init()
  17.     // Create new greeter client
  18.     greeter := proto.NewGreeterService("greeter", service.Client())
  20.     // Call the greeter
  21.     rsp, err := greeter.Hello(context.TODO(), &proto.Request{Name: "John"})
  22.     if err != nil {
  23.         fmt.Println(err)
  24.     }
  26.     // Print response
  27.     fmt.Println(rsp.Greeting)
  28. }

Now run the client

  1. go run client.go

And the output should simply print the response

  1. Hello John