Learn the coding skills for your next job

Using ‘Go Generate’ To Deploy Multi-Process Apps

In microservice architectures, it’s fairly common to have a project that includes different worker types. A Makefile can be used to manage the creation of multiple programs, but the Go toolchain has a tool that can be used as well, go generate. Here are some examples of how it can be used:

  • API/Worker – We have an API that allows clients to start/stop long-running jobs, and a worker which accesses the same database to run the jobs.
  • NLP Classifier – We have different processes that share a majority of the same code, but have different quirks depending on if they are classifying sentiment, vulgarity, or subjectivity.

In other words, we have one git repository, but from that code, we want to generate ‘n‘ number of executables.

Learn the Go the right way

Go is the language of cloud-native technologies. If you’re interested in modern web systems then our Go Mastery track of courses and projects will give you all the skills you need to have a successful switch.

Repository Structure

Our normal single-process repositories have the following structure:

  • main.go
  • foo.go (other main package source files)
  • bar.go
  • internal (folder for packages intended just for this project)
    • database (package for database access)
      • database.go
    • rabbit (package for rabbitmq access)
      • rabbit.go

As you can see, when there is only one program (one main.go) its really easy to build and deploy. We just run:

go build
Code language: Bash (bash)

from the root of the repository.

Structure With Multiple Programs

Now let’s say we have a project that has an API that is responsible for managing some long-running jobs. For example, we can pretend it manages RSS scraping jobs. Here is how we would build out the repository:

  • cmd
    • api
      • main.go
    • worker
      • main.go
  • internal (folder for packages intended just for this project)
    • database (package for database access)
      • database.go
    • rss (package for rss scraping logic)
      • rss.go
  • gen.go

Here we have a cmd folder in the root, which then holds a directory for each executable. This allows us to still scope packages to the entire project, share a CI/CD pipeline, and keep code that is tightly-coupled all in one place.

How Do We Build It?

In the above project structure, you may have noticed the gen.go file. Here is what it looks like:

package main //go:generate go build ./cmd/api //go:generate go build ./cmd/worker
Code language: Go (go)

Now we can run go generate from the root of our project and both executables will be built at the root.

Can We Do More?

Have more steps in the build process? Go generate is quite flexible, lets build the production docker image as well (assuming we have a Dockerfile in the root of the project):

package main //go:generate go build ./cmd/api //go:generate go build ./cmd/worker //go:generate docker build .
Code language: Go (go)

The generate function is a powerful tool and can do a lot more than just build a list of executables. Nevertheless, we’ve found this to be a convenient way to keep our projects “go native”.

Trying to find your next programming job?

If you are a self-taught developer having trouble finding your first programming job, we've got your back! We have the learning resources and tight-knit dev community that you need to land the coding job you've been looking for. To get started, create a free account and join our Discord community.

Have questions or feedback?

If we've made a mistake in the article, please let us know so we can get it corrected!