Use dh-golang for Modern, Debian-Compliant Packaging
dh-golang is the recommended tool for packaging Go applications in Debian, as it integrates with debhelper to automate build, installation, and metadata generation while adhering to Debian’s packaging policies. Unlike manual approaches, it handles Go modules, dependencies, and file placement (e.g., installing binaries to /usr/bin) consistently. To use it, add dh-golang to Build-Depends in debian/control, specify --with golang in debian/rules, and ensure debian/compat is set to a compatible debhelper level (e.g., 13+). This approach streamlines compliance with Debian standards and reduces manual effort.
Leverage Static Compilation for Portability
Go’s default static compilation (achieved via CGO_ENABLED=0) creates self-contained executables that include all dependencies, eliminating runtime library conflicts. For Debian packages, this means fewer external dependencies and simpler deployment across different Debian-based systems. Use the following command to build statically linked binaries:
CGO_ENABLED=0 go build -ldflags="-s -w" -o your-app-name
The -ldflags="-s -w" flags further reduce the binary size by stripping debug symbols and minimizing runtime overhead.
Optimize Dependency Management with Go Modules
Go Modules (introduced in Go 1.11) is the standard dependency management tool for Go. For Debian packaging, use go mod tidy to remove unused dependencies and ensure go.mod and go.sum are up-to-date. This guarantees that only required dependencies are included in the package, reducing its size and attack surface. Always commit go.mod and go.sum to version control to maintain reproducible builds.
Follow Debian Packaging Conventions for File Placement
Debian enforces strict filesystem hierarchy standards (FHS). For Go binaries, install them to /usr/bin (or /usr/sbin for system administration tools) using the debian/install file. Example debian/install content:
your-app-name usr/bin
This ensures the binary is placed in a standard location, making it accessible system-wide without requiring custom environment variables.
Minimize Package Size with Build Optimizations
Reduce the final .deb package size by stripping debug symbols (-w flag), minimizing binary size (-s flag), and using multi-stage Docker builds (for containerized deployments). Multi-stage builds compile the Go app in a lightweight container (e.g., golang:alpine) and copy only the compiled binary to a minimal base image (e.g., debian:buster-slim). This eliminates unnecessary build tools and intermediate files from the final image.
Automate Packaging with CI/CD Pipelines
Integrate Debian packaging into CI/CD workflows (e.g., GitLab CI, GitHub Actions) to automate building, testing, and signing .deb packages. Example .gitlab-ci.yml snippet:
stages:
- build
- package
build:
stage: build
script:
- go build -o your-app-name
package:
stage: package
script:
- debuild -us -uc
artifacts:
paths:
- "*.deb"
Automation ensures consistent builds, reduces human error, and speeds up the release process.
Handle CGO Dependencies Carefully
If your Go app uses CGO (calls C code), you’ll need to add gcc, libc-dev, and other build dependencies to debian/control. For example:
Build-Depends: debhelper-compat (= 13), dh-golang, golang-go, gcc, libc-dev
You may also need to set specific compiler flags (e.g., -extldflags "-static") in debian/rules to handle linking correctly. Note that CGO increases complexity and reduces portability, so avoid it unless absolutely necessary.
