I'm using Docker's Go client to build my projects. This post highlights how to do that with the Go client. I'm calling ImageBuild
on three of my Dockerfiles (1.Dockerfile
, 2.Dockerfile
, and 3.Dockerfile
) as a test. Here is my code:
func GetContext(filePath string) io.Reader {
// Use homedir.Expand to resolve paths like '~/repos/myrepo'
filePath, _ = homedir.Expand(filePath)
ctx, err := archive.TarWithOptions(filePath, &archive.TarOptions{})
if err != nil {
panic(err)
}
return ctx
}
func testImageBuild() {
ctx := context.Background()
cli, err := client.NewEnvClient()
if err != nil {
log.Fatal(err, " :unable to init client")
}
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
dockerFile := fmt.Sprintf("%d.Dockerfile", i)
imageBuildResponse, err := cli.ImageBuild(
ctx,
GetContext("."),
types.ImageBuildOptions{
Dockerfile: dockerFile,
Tags: []string{fmt.Sprintf("devbuild_%d", i)},
})
if err != nil {
log.Fatal(err, " :unable to build docker image"+string(1))
}
defer imageBuildResponse.Body.Close()
_, err = io.Copy(os.Stdout, imageBuildResponse.Body)
if err != nil {
log.Fatal(err, " :unable to read image build response "+string(1))
}
}(i)
}
wg.Wait()
}
func main() {
testImageBuild()
}
GetContext
is used to tar the directory path as a context for Docker. testImageBuild
spins off three different goroutines to build the three different images.
My question is: When I run this, the output to stdout is always the same and seems deterministic, which makes me think that the images aren't actually been built in parallel. I'm not familiar with how docker build its images, and it seems entirely possible that this approach is simply sending requests to docker server in parallel rather than actually building in parallel. Is this true? If so, how can I build my projects in parallel?