Improving docker layer usage and reuse

[isZumpo]

Currently, the last layer (the birdnet-go binary) is quite large. I'd assume it is because of how these tflite models are embedded into the built binary:

• BirdNET_GLOBAL_6K_V2.4_Model_FP32.tflite
• BirdNET_GLOBAL_6K_V2.4_MData_Model_V2_FP16.tflite
• BirdNET_GLOBAL_6K_V2.4_MData_Model_FP16.tflite

Together these files take up around 70.1 MiB. Since these files are rarely changed it would be beneficial if they could be put on an individual docker layer. This means that changes to the source code itself would allow docker to reuse most of the already existing layers, only commiting a smaller layer containing the actual birdnet-go binary.

Of course, it is quite convenient to have a self-contained binary still for those who want to run it without docker. However, I do think it could be beneficial to make some changes to get better layer reuse in docker. Especially since many are running these types of systems on lower-powered devices where bandwidth and storage might be low.

Does anyone have any good input on how to proceed with moving some of these static files that are embedded in the binary out of it just for docker builds?

[tphakala]

Those files are embedded into binary on purpose, and I have no plans to make exception for Docker version on this, it becomes too complicated to support things and I see that there is very little benefit from such change.

[isZumpo]

Yes, I understand that it would make the build process a bit more complicated. It essentially adds another "platform" that differs from the others. Which might be hard to maintain and support. However, a part of me still finds it to be an interesting problem that might be fun to consider at some point in the future to make the docker setup even better.

I did try having a go at an approach that works quite well without changing too much of the code. It makes clever use of go tags during the compilation process to decide whether or not to embed the files. It is based on this discussion.

Moving all the embedded files from internal/birdnet/birdnet.go to internal/birdnet/model_embed.go which is the default file ( uses the //go:build !docker line for that) to use unless a build tag is provided with the value docker:

//go:build !docker

package birdnet

import (
	_ "embed" // Embedding data directly into the binary.
)

// Embedded TensorFlow Lite model data.
//
//go:embed BirdNET_GLOBAL_6K_V2.4_Model_FP32.tflite
var modelData []byte

// Embedded TensorFlow Lite meta model data.
//
//go:embed BirdNET_GLOBAL_6K_V2.4_MData_Model_V2_FP16.tflite
var metaModelData []byte

// Embedded labels in zip format.
//
//go:embed labels.zip
var labelsZip []byte

Then I made a corresponding internal/birdnet/model_noembed.go. Which is used instead of model_embed.go if the build tag with the value docker is provided. It loads the models during runtime, from the disk instead, under a static location which the dockerfile copies the models to:

package birdnet

import (
	"fmt"
	"os"
)

// TensorFlow Lite model data.
var modelData []byte

// TensorFlow Lite meta model data.
var metaModelData []byte

// Labels in zip format.
var labelsZip []byte

func init() {
	modelDataValue, err := os.ReadFile("/birdnet_models/BirdNET_GLOBAL_6K_V2.4_Model_FP32.tflite")
	if err != nil {
		fmt.Println(err)
		return
	}

	modelData = modelDataValue

	metaModelDataValue, err := os.ReadFile("/birdnet_models/BirdNET_GLOBAL_6K_V2.4_MData_Model_V2_FP16.tflite")
	if err != nil {
		fmt.Println(err)
		return
	}

	metaModelData = metaModelDataValue

	labelsZipValue, err := os.ReadFile("/birdnet_models/labels.zip")
	if err != nil {
		fmt.Println(err)
		return
	}

	labelsZip = labelsZipValue
}

Then when building the docker image I make sure to

COPY --from=build /root/src/BirdNET-Go/internal/birdnet /birdnet_models/

then while building the dockerfile, I modify the build line in the makefile to include the tag:

... go build ... -tags=docker

The resulting docker image runs as expected while having a dedicated layer just for the large tflite files:

Without embedded

In the above image, the last layer is only 20MB compared to 89MB which it is otherwise. Meaning that the storage cost of the image would be way less since it can share the previous layers for different images.

With embedded (the way it is today)

However, it does get quite complicated with the different paths etc. In addition, this crude COPY --from=build /root/src/BirdNET-Go/internal/birdnet /birdnet_models/ manages to get extra files such as the unused BirdNET_GLOBAL_6K_V2.4_MData_Model_FP16.tflite:

Meaning that it might make sense to move some of these files around a bit. Further complicating it...