GitHub - observIQ/otel-distro-builder: Build custom OpenTelemetry Collector Distributions from manifest files with a local build utility, Docker, Google Cloud Build, or a GitHub Action.

🚀 OpenTelemetry Distribution Builder

🤔 Why OpenTelemetry Distribution Builder?

Built on top of the OpenTelemetry Collector Builder (OCB), it uses a manifest.yaml to define the components you need, then automates packaging for multiple platforms and manages version releases via GitHub.

While OCB (OpenTelemetry Collector Builder) focuses on building single collector binaries, the OpenTelemetry Distribution Builder provides a complete distribution management solution:

• 🔨 Builds multi-platform binaries using OCB under the hood
• 📦 Generates installation packages following OTel community best practices
• 🚀 Automates versioned releases through GitHub Actions
• 🔄 Simplifies updates through manifest-based configuration

It handles all the complex aspects of managing your own distribution that have historically made building custom collectors challenging. With the OpenTelemetry Distribution Builder, you can focus on defining your components while the tooling takes care of the rest.

✨ Features

• 🎯 Custom Component Selection: Build distributions with exactly the components you need
• 🌐 Multi-Platform Support: Build for multiple architectures (amd64, arm64)
• 📦 Multiple Package Formats: Generate APK, DEB, RPM, and TAR.GZ packages
• 🔄 GitHub Actions Integration: Seamless CI/CD integration
• 🚀 Automated Releases: Streamlined versioning and release process
• 🔍 Platform-Specific Builds: Optimize for your target environment

📥 Install

The CLI runs on your host and reads config/manifest files from the host filesystem. Docker is not required—the CLI downloads OCB and Go automatically when needed for full builds.

Then run otel-distro-builder --help.

Dependencies: For manifest generation (--from-config, --generate-only), the standalone binary and pip install need no other dependencies. For full distribution builds on the host, no other dependencies are required—the CLI downloads OCB and Go automatically when needed. Docker is optional and only for an isolated build environment.

🚀 Quick Start

1. Create a new repository

2. Add your manifest file (manifest.yaml):

   dist:
     name: my-otelcol
     description: My Custom OpenTelemetry Collector Distro
     # ...
   extensions:
     -  # ...
   exporters:
     -  # ...
   processors:
     -  # ...
   receivers:
     -  # ...
   connectors:
     -  # ...
   providers:
     -  # ...

3. Set up GitHub Actions (.github/workflows/build.yml):

name: OpenTelemetry Distribution Build

on:
   push:
     tags:
       - "v*"
   workflow_dispatch:

  permissions:
    contents: write # This is required for creating/modifying releases

  jobs:
    build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # Build the OpenTelemetry distribution using this custom action
      - uses: observiq/otel-distro-builder@v1.1.0
        with:
          manifest: "./manifest.yaml"

      # Create a GitHub Release and attach the build artifacts
      # This makes the artifacts available for download from the Releases page
      - name: Create Release
        uses: softprops/action-gh-release@v2
        with:
          files: ${{ github.workspace }}/artifacts/*

4. Trigger a build:

   git tag v1.0.0 && git push --tags

5. Build (host CLI or optional Docker):

   # Host (after pip install -e . or pip install otel-distro-builder)
   otel-distro-builder --manifest manifest.yaml --artifacts ./artifacts
   
   # Optional: build with Docker (isolated environment)
   docker pull ghcr.io/observiq/otel-distro-builder:main
   docker run --rm -v $(pwd):/workspace -v $(pwd)/artifacts:/artifacts \
     ghcr.io/observiq/otel-distro-builder:main \
     --manifest /workspace/manifest.yaml --artifacts /artifacts

🔄 Generate Manifest from Existing Config

Already have a running OpenTelemetry Collector with a config.yaml? Generate a minimal manifest containing only the components you need. No Docker required—run the CLI on your host (after install); for full builds, no other dependencies are required—the CLI downloads OCB and Go automatically.

# Generate manifest only (writes to ./artifacts/manifest.yaml)
otel-distro-builder --from-config config.yaml --generate-only

# Generate manifest to a custom directory
otel-distro-builder --from-config config.yaml --generate-only --artifacts ./out

# Generate manifest and build in one step
otel-distro-builder --from-config config.yaml --artifacts ./artifacts --platforms linux/amd64,linux/arm64

The generated manifest is always saved to <artifacts>/manifest.yaml (default ./artifacts/manifest.yaml).

Optional: use Docker for an isolated environment (mount your workspace and artifacts):

# Generate manifest only (writes to /workspace/artifacts/manifest.yaml)
docker run -v $(pwd):/workspace ghcr.io/observiq/otel-distro-builder:main \
  --from-config /workspace/config.yaml --generate-only --artifacts /workspace/artifacts

# Generate manifest and build
docker run -v $(pwd):/workspace ghcr.io/observiq/otel-distro-builder:main \
  --from-config /workspace/config.yaml --artifacts /workspace/dist --platforms linux/amd64,linux/arm64

Config-to-Manifest Options

By default, generated manifests include Bindplane components. Use --no-bindplane to exclude them.

See Config to Manifest for detailed options, examples, and troubleshooting.

📚 Documentation

To view detailed guides, see the docs directory.

GitHub Action Configuration

Inputs

Outputs

All generated packages and binaries are available in the ${{ github.workspace }}/artifacts/* folder.

Docker Usage

# Pull the latest version
docker pull ghcr.io/observiq/otel-distro-builder:main

# Pull specific version
docker pull ghcr.io/observiq/otel-distro-builder:v1.0.5

# Run a build
docker run --rm \
  -v "$(pwd)/manifest.yaml:/manifest.yaml:ro" \
  -v "$(pwd)/artifacts:/artifacts" \
  ghcr.io/observiq/otel-distro-builder:main \
  --manifest /manifest.yaml \
  --artifacts /artifacts \
  --platforms linux/amd64,linux/arm64,darwin/amd64,darwin/arm64 \
  --ocb-version 0.123.0 \
  --supervisor-version 0.123.0 \
  --go-version 1.25.0 \
  --parallelism 4

Using --platforms (comma-separated GOOS/GOARCH):

# Single platform (e.g. Apple Silicon)
docker run --rm -v "$(pwd)/manifest.yaml:/manifest.yaml:ro" -v "$(pwd)/artifacts:/artifacts" \
  ghcr.io/observiq/otel-distro-builder:main --manifest /manifest.yaml --artifacts /artifacts \
  --platforms darwin/arm64

# Linux only (amd64 + arm64)
docker run --rm -v "$(pwd)/manifest.yaml:/manifest.yaml:ro" -v "$(pwd)/artifacts:/artifacts" \
  ghcr.io/observiq/otel-distro-builder:main --manifest /manifest.yaml --artifacts /artifacts \
  --platforms linux/amd64,linux/arm64

# Linux + Darwin (all common arches)
docker run --rm -v "$(pwd)/manifest.yaml:/manifest.yaml:ro" -v "$(pwd)/artifacts:/artifacts" \
  ghcr.io/observiq/otel-distro-builder:main --manifest /manifest.yaml --artifacts /artifacts \
  --platforms linux/amd64,linux/arm64,darwin/amd64,darwin/arm64

Optional builder arguments: --platforms (GOOS/GOARCH list), --goos, --goarch, --ocb-version, --supervisor-version, --go-version, --parallelism (number of parallel Goreleaser build tasks; default 4; lower to reduce memory use).

Read more details in the Docker documentation.

Parallelism Benchmarks

When building for multiple architectures or large manifests, the number of parallel Goreleaser build tasks (--parallelism) directly affects memory usage and build time. Here are real-world benchmarks for different parallelism settings (measured on a MacBook Pro M4 Pro with 48GB RAM, Docker Engine set to 14 CPUs + 24GB RAM):

• Lower --parallelism reduces peak memory use and may be required for constrained environments or very large builds, at the expense of longer build times.
• Higher --parallelism can speed up builds if you have sufficient memory, but may cause OOM failures on systems with limited RAM. In particular for multi-architecture builds for multiple platforms.
• For collector builds with many components, ensure Docker/host RAM is at least 4–6 GB (more for larger/parallel builds).

See Docker documentation for more details and troubleshooting tips.

🛠️ Development

Prerequisites

• Using the CLI (binary or pip): For full builds, no other dependencies are required; the CLI downloads OCB and Go automatically. For manifest generation only, no dependencies.
• Development (editing this repo): Python 3, Make. Docker is optional (for running the builder in a container).

Available Commands

# Show all commands
make help

# Setup development environment
make setup

# Run tests
make test

# Run linting
make lint

Build Scripts

run_cloud_build.sh

Triggers a build using Google Cloud Build:

./scripts/run_cloud_build.sh -m manifest.yaml -p project_id -b artifact_bucket

Options:

• -m: Path to manifest file (required)
• -p: Google Cloud project ID
• -b: Artifact bucket name

run_local_build.sh

Build a custom OpenTelemetry Collector distribution using a local Docker container (single or custom platform):

# Basic build (host platform)
./scripts/run_local_build.sh -m manifest.yaml

# Custom output directory and versions
./scripts/run_local_build.sh -m manifest.yaml -o ./dist -v 0.147.0 -s 0.147.0 -g 1.25.0

# Build Docker image for a specific platform (e.g. Apple Silicon / arm64)
./scripts/run_local_build.sh -m manifest.yaml -p linux/arm64

# Multiple platforms for Docker image (comma-delimited)
./scripts/run_local_build.sh -m manifest.yaml -p linux/arm64,linux/amd64

Options: -m (required), -o (output dir), -p (platforms), -v (OCB version), -g (Go version), -s (Supervisor version). When running the container directly, you can also pass --parallelism N to the builder (default 4; lower for less memory use).

Via Make: make build, make build-local, make build output_dir=./artifacts ocb_version=0.147.0, make build platforms=linux/arm64,linux/amd64.

Multi-arch builds use the same script with -p (omit -p for single-arch; defaults to the host platform):

# Multi-arch: linux + darwin, amd64 + arm64
./scripts/run_local_build.sh -m manifest.yaml -p linux/amd64,linux/arm64,darwin/amd64,darwin/arm64

# Or a subset of platforms
./scripts/run_local_build.sh -m manifest.yaml -p linux/amd64,linux/arm64 -o ./dist -v 0.147.0 -s 0.147.0 -g 1.25.0

Via Make: make multiarch-build (default platforms), make multiarch-build-local, or make build platforms=linux/amd64,linux/arm64.

Artifacts are written to the specified output directory (default: ./artifacts).

📁 Project Structure

otel-distro-builder/
├── builder/                # Builder application
│   ├── src/               # Core builder code
│   ├── templates/         # Build templates
│   ├── tests/            # Test suite
│   └── Dockerfile        # Builder image definition
├── action/                # GitHub Action
├── scripts/              # Build scripts
└── Makefile              # Development commands

🔧 Build Process

1. Builder Image Preparation: Build and push to registry
2. Manifest Processing: Upload and validate manifest configuration
3. Build Execution:
   • Download OpenTelemetry Collector Builder (OCB)
   • Generate Go source files
   • Build platform-specific packages
   • Create SBOMs and checksums
4. Artifact Management: Upload to GitHub, Google Cloud Storage, or save locally

📦 Build Artifacts

The builder produces:

• 📦 Binary packages (APK, DEB, RPM)
• 📚 Source tarball
• 🔧 Raw binary
• 📋 SBOM files
• 🔍 Checksums
• 📝 Build metadata

Storage Locations

• Local builds: ./artifacts directory
• Cloud builds: gs://<bucket>/<build_id>/

🔢 Versioning

We follow semantic versioning. The builder is available in several forms:

• GitHub Action: Use @v1.1.0 for latest 1.x version, or @v1.0.5 for specific versions
• Docker Image: Use main for latest, or version tags like v1.0.5
• Container Registry: ghcr.io/observiq/otel-distro-builder:main or ghcr.io/observiq/otel-distro-builder:v1.0.5

📚 Examples

Check out our example workflows in .github/workflows/examples/ for common use cases:

• Multi-platform builds
• Container publishing
• Custom package configurations

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

📄 License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

Made with ❤️ by the Bindplane team