Summary
Resources related to backend services that support the Mono iOS and Android clients can be found here.
Structure
server
├── cmd
│ └── dummy
│ ├── BUILD.bazel
│ └── main.go
├── pkg
│ └── dummy
│ └── v1
│ ├── BUILD.bazel
│ └── dummy.proto
├── Dockerfile
├── Dockerfile.test
├── BUILD
├── WORKSPACE
├── tools.go
├── go.mod
└── go.sum
-
cmd
cmd
contains service entry points in the main.go
. Each directory in cmd
maps to a similarly named service.
-
pkg
pkg
contains shared code, libraries, and service definitions. In keeping with the buf
styleguide,
protobuf messages and services are in versioned packages.
Getting started
With the introduction of the Bazel system, getting up and running is fairly simple. The first of two requirements is that bazel
be installed like so:
$ brew install bazel
Next, install docker
manually by following the linked steps.
Existing services
An existing service can be brought up individually using the
$ bazel run //cmd/[SERVICE]:[SERVICE]
command. To bring up all existing services in containers, just run
$ make coldstart
New services
Start by creating a versioned service definition in a package named after the service (i.e. [SERVICE]/v1/[SERVICE].proto
). Be sure to follow
the buf
styleguide when declaring RPCs and messages. This versioned package should be under pkg
.
Then, create a BUILD.bazel
that has instructions for how to build the service. The BUILD.bazel
for the dummer
service is a good example of a service with both external and local
dependencies. The dummy
service contains an example for a service with no local dependencies.
Finally, create a new service entrypoint and BUILD.bazel
file in a package named after the service under cmd
(i.e. cmd/[SERVICE]/main.go
). Once service endpoints
are implemented, use
$ bazel run //cmd/[SERVICE]:SERVICE
to bring up the service locally. Also, be sure to add the service configuration to the docker-compose.yml
file so that the new service can be brought up in a container.
[Deprecated] Getting started
It's assumed that the Go environment ($GOPATH
and $GOBIN
) have been correctly setup. In order to get started, clone this repo and install the following tools:
protoc
- This is the protocol buffer compiler
protoc-gen-go
- This is a compiler plugin to protoc
that enables the compiler to generate Go code
grpc-gateway
- This compiler plugin to protoc
generates a reverse-proxy server which translates a RESTful HTTP API into gRPC
$ brew install protobuf
$ GO111MODULE=on go get github.com/golang/protobuf/protoc-gen-go
$ GO111MODULE=on go get github.com/grpc-ecosystem/grpc-gateway/protoc-gen-grpc-gateway@v1.14.7
-
docker
- This is a containerization tool that services will run in
Install docker
manually by following the steps linked above
-
googleapis
- This repo provides some helpful tools and .proto
files for transcoding HTTP/JSON to gRPC
$ go get github.com/googleapis/googleapis@v0.0.0-20200814034631-3a54e988edcb
After these steps, you should be able to bring up existing services using make start
and make stop
.
To define a new service, write a definition for that service i.e. [NAME].proto
in idl
and create an entry point i.e. main.go
in a new directory
under cmd/[NAME]
. Then, using make proto SERVICE="[NAME]"
where SERVICE
is the name of the service's definition and entry point i.e. dummy
, generate
the service stubs. These can be found in pkg/[NAME]_gen
. The final step is to implement the business logic in the entry point that was created earlier.
Helpful notes
Bazel protobuf docs
Bazel gazelle docs
Bazel go docs
Bazel go + protobuf docs
gRPC gateway docs
Buf docs