Build multiple binaries into current directory

go build
go build multiple binaries
golang build multiple architecture
go mod
golang multiple packages in same directory
building binaries
golang project structure
golang import package

When doing go build github.com/.../foo from any directory, the compiled binary will be placed in the directory from which I executed the command. When doing go build /github.com/.../cmd/... I expected all of the compiled binaries to appear in my current directory. But they don't.

How can I compile multiple/all binaries of that package into my current work dir?

As the issue 23616 states:

The fact that go build doesn't build is counter-intuitive

You will be able to get multiple binaries in your current directory when... the issue 14295 "cmd/go: go build should be able to write multiple executables" will be completed.

But that will be for Go 1.13 (not 1.12, so late 2019)

This is so close to working. I'm not sure why it doesn't. We should fix it for Go 1.12. Clearly -o can't be used with multiple binary targets, but the implicit "write to the current directory" should work, and instead it does nothing.

There is a bit of discussion on the proposed CL, as well s the comment that the CL as implemented breaks go build -a std cmd.

See CL 143139/ (CL = "Change List").

cmd/go: go build should be able to write multiple executables · Issue , Clearly -o can't be used with multiple binary targets, but the implicit "write to the current directory" should work, and instead it does nothing. The local path on the agent you can use as an output folder for compiled binaries. By default, new build pipelines are not set up to clean this directory. You can define your build to clean it up on the Repository tab. For example: c:\agent_work\1\b. This variable is agent-scoped.

You can compile your binary using the project's file path (instead of the package name) to generate them in your current directory.

For example:

$ go build ~/Go/src/github.com/.../cmd

And the binaries will be in your current directory.

Packing multiple binaries in a Golang package, Imagine we need to build a CLI program in Golang. after buildilng, these binaries will be installed into the Go binaries path ( $GOPATH/bin ). Install and build binaries. Binary packages, after being installed and built, will be placed in the current working directory. I switch to the directory that is mapped back to the host so that I can keep the binary packages around after the container stops. setwd('/data') # to drop binary tarballs into this directory

From go build -h:

When compiling multiple packages or a single non-main package, build compiles the packages but discards the resulting object, serving only as a check that the packages can be built.

But you can use this one-liner to achieve the same result (only the binaries directly under cmd will be built): find $GOPATH/src/github.com/.../cmd -mindepth 1 -maxdepth 1 | xargs -n1 go build

Our favorite Go 1.13 features · Banzai Cloud, Before Go 1.13, if you tried to build a project with multiple binaries using the module mode whenever the current working directory (or bellow)  I am copying jre folder from ojdkbuild along with Tomcat and Elasticsearch apps, each going into their directory structure. When trying to copy the dependent binaries into jre/bin folder, the binaries are not picking it up either. They are looked up based on current working directory, but not where JRE/JDK is installed.

The Debian System: Concepts and Techniques, The Debian Women project has published a guide on how to create packages Before creating these files, dh_make duplicates the current directory for later creation debian directories for four types of source packages: multiple binary The  Regardless of where the Dockerfile actually lives, all recursive contents of files and directories in the current directory are sent to the Docker daemon as the build context. Build context example. Create a directory for the build context and cd into it. Write “hello” into a text file named hello and create a Dockerfile that runs cat on it.

Professional Linux Programming, For example, you can copy the existing hello1.0.tar.gz into a new directory and use you would like to create: Since you are creating a single binary package, you hello-1.0.tar.gz Type of package: single binary, multiple binary, library, kernel  Installing the freshly built binaries into the appropriate system directories is usually a matter of running make installas root. The usual directories for system-wide binaries on modern Linux distributions are /usr/bin, /usr/X11R6/bin, and /usr/local/bin. The

Managing Projects with GNU Make, Supporting Multiple Binary Trees Once the makefile is modified to write binary files This wrapper can also parse the current directory and set an environ- ment​  This final step pulls the variable from Cloud 66, decodes it and then saves it as a key under the root directory of the container. Pulling binaries into your Dockerfile using env_vars. It’s possible to add small binary files (30KB or smaller) to your application during the build step using a combination of Base64 encoding and environment

Comments
  • The actual discussion thread is here: github.com/golang/go/issues/14295. At least after "some" it seems it will make its way into Go :D
  • The idea is to build everything under the path github.com/.../cmd/... at once and not for every binary
  • So append "..." to your directory path (like you did). In Go, "x/..." means "every path under x/".
  • As I described in my question: When adding ... then NO files are placed into my current dir. Only if I specify an exact binary to build it will be placed into my current dir.
  • Please post a concrete case of what you're trying to do, not an example. Post the command and the output. Use "go build -v" to enable more verbose output. I'm running the command I posted in my answer and it generates a binary file in my current directory (which is somewhere very different from where the code is). It should also work for you.
  • This is exactly my use case. On a CI system I have to build a Docker image. So I cd into the dir where the Dockerfile is. I need .../cmd/cliA and .../cmd/cliB to build into my current dir. I could build cliA and cliB one after another but I would like to have it in one command. But go build .../cmd/... does NOT build BOTH binaries into my current dir. This only happens if I specify cliA or cliB explicitly