Quick Start

PROJECTNAME=$(shell basename "$(PWD)")
all: format test
format:
    find . -name '*.go' | xargs goimports -w
test:
    go test -v ./...

Makefiles默认的每一行的开头是制表符 (Tab character) , 也可以通过 .RECIPEPREFIX 指定.
例如:

.RECIPEPREFIX = >
all:
> @echo Hello, world

In this tutorial, we are going to be looking at how you, as a Go developer, can leverage the wonderful bit of technology that is Makefiles for fame and fortune when developing your own Go applications.

What are Makefiles?

Let’s start by looking at what Makefiles are first of all. Makefiles are an incredibly useful automation tool that you can use to run and build not just your Go applications, but for most programming languages.

You will typically see ​​Makefiles​​ at the root directory of a whole host of different Go applications on Github and in Gitlab as they are used extensively as the tool of choice for automating tasks that the maintainers of these applications find themselves doing often.

A Simple Example

Now that we have covered the absolute basic concepts, let’s see these concepts in action with a really simple ​​Makefile​​ example to whet our appetite.

Create a new directory in which you can work in and within this directory create a new file called ​​Makefile​​.

Once you have this ​​Makefile​​​, open it up and let’s add a ​​target​​​ called ​​hello​​​ to this ​​Makefile​​. This target, when executed, will run the script below it, very similar to a normal function in programming terms.

Makefile

hello:
    echo "Hello"

With this new defined, let’s try and execute this using the ​​make​​ command-line tool:

$ make hello

echo "Hello"
Hello

As you can see the script within the body of our ​​hello​​​ target has been successfully executed for us and ​​Hello​​ has printed out!

Awesome, hopefully you can see where we are going with this.

Building a Simple Go App

So, we have a simple ​​Makefile​​​ in a project directory that performs the highly complex tax of printing out ​​Hello​​ to our terminal.

Let’s now take this a step further and add a simple Go application into the mix so that we can try our hand at defining new targets which will build and run this new Go app for us.

main.go

package main

import "fmt"

func main() {
    fmt.Println("Hello")
}

Now that we have a suitably complex Go application to work with, let’s define some new targets within our ​​Makefile​​ which will simplify the task of building and running our application for us.

Open up your ​​Makefile​​ once again and add the following targets:

Makefile

hello:
    echo "Hello"

build:
    go build -o bin/main main.go

run:
    go run main.go

Here, we have created a ​​build​​​ target and a ​​run​​​ target. The ​​build​​​ target can be used to compile our amazing Go application it’s final binary state within a ​​bin/​​ directory.

The ​​run​​ target is aptly named as it attempts to run our Go application in its current state.

Let’s try run these both now:

$ make build

go build -o bin/main main.go

Awesome, this ​​make build​​​ command will have gone away and compiled our Go application successfully into a new ​​bin/​​ directory for us.

Let’s now try the ​​make run​​ command:

$ make run

go run main.go
Hello

Here we see that our go application is run for us.

What’s the Big Deal?

At this point, you might be asking what the big deal is about using Makefiles for your own Go applications.

Well imagine you wanted to cross-compile your application to run on every OS and every architecture available but didn’t want to manually set the ​​GOOS​​​ and ​​GOARCH​​ variables for every command.

Within your ​​Makefile​​​, you could define a new ​​compile​​​ target which contains all of the build commands with all the appropriate ​​GOOS​​​ and ​​GOARCH​​ compinations set like so:

Makefile

compile:
    echo "Compiling for every OS and Platform"
    GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go
    GOOS=linux GOARCH=386 go build -o bin/main-linux-386 main.go
    GOOS=windows GOARCH=386 go build -o bin/main-windows-386 main.go

And now, when you try to cross compile for every platform, you simply have to call ​​make compile​​:

$ make compile

echo "Compiling for every OS and Platform"
Compiling for every OS and Platform
GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go
GOOS=linux GOARCH=386 go build -o bin/main-freebsd-386 main.go
GOOS=windows GOARCH=386 go build -o bin/main-freebsd-386 main.go

With everything successfully built, you should now see your ​​bin/​​ directory full of binaries compatible with a range of different Operating Systems and Platforms.

Layering Commands

Let’s now imagine we are working with a complex system that has a multi-stage build/run process that has developed over many years. Instead of having to define all of the commands needed to build and run in a single target, you can break everything up into smaller targets and have something like an ​​all​​​ target combine them into one ​​make​​ command.

Open up your ​​Makefile​​​ once again and add an ​​all​​​ target at the bottom. This ​​all​​​ target will go away and execute your ​​hello​​​ and ​​build​​ targets in series.

Makefile

hello:
    echo "Hello"

build:
    go build -o bin/main main.go

run:
    go run main.go

compile:
    echo "Compiling for every OS and Platform"
    GOOS=linux GOARCH=arm go build -o bin/main-linux-arm main.go
    GOOS=linux GOARCH=arm64 go build -o bin/main-linux-arm64 main.go
    GOOS=freebsd GOARCH=386 go build -o bin/main-freebsd-386 main.go

all: hello build

Now that we have added this new target, let’s see what happens when we call it:

$ make all

echo "Hello"
Hello
go build -o bin/main main.go

Awesome, using this approach we can start to break down more complex instructions into a series of smaller, easier to digest targets that can be individually debugged and executed.

Conclusion

So, in this tutorial, we covered the absolute minimum needed to get up and running using ​​Makefiles​​​ and the ​​make​​ command so that you can simplify your development process.

Further Reading

If you enjoyed this article but wish to learn more about Makefiles and how you can best use them, I suggest you check out the following articles: