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.
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.
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.
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.
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.
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.
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.
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: