Request for linux/arm64 docker image

[afh]

Currently only linux/amd64 images are available on hub.docker.com requiring the use of Rosetta on aarch64-darwin, which may be unacceptable for some folks including myself. Happy help with some guidance from the maintainers.

[hakanensari]

@claude, suggest a minimal setup for shipping multi-arch images and flag any potential pitfalls?

[claude]

Claude finished @hakanensari's task —— View job

---

📋 Analysis Complete

Todo List:

• Analyze current Docker setup in the repository
• Suggest minimal setup for multi-architecture images
• Flag potential pitfalls and considerations

---

Current Setup Analysis

Your repository currently uses:

• Dockerfile: Standard single-architecture setup with FROM ruby:3.4.6
• CI/CD: Using elgohr/Publish-Docker-Github-Action@v5 which doesn't support multi-arch builds

Minimal Multi-Architecture Setup

Option 1: Docker Buildx with GitHub Actions (Recommended)

Replace the publish job in .github/workflows/ci.yml with:

publish:
  needs: test
  if: ${{ github.event_name == 'push' }}
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v5
    
    - name: Set up QEMU
      uses: docker/setup-qemu-action@v3
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3
    
    - name: Log in to Docker Hub
      uses: docker/login-action@v3
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
    
    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v5
      with:
        images: lineofflight/frankfurter
        tags: |
          type=ref,event=branch
          type=ref,event=tag
          type=semver,pattern={{version}}
          type=raw,value=latest,enable={{is_default_branch}}
    
    - name: Build and push
      uses: docker/build-push-action@v6
      with:
        context: .
        platforms: linux/amd64,linux/arm64
        push: true
        tags: ${{ steps.meta.outputs.tags }}
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

Option 2: Using Docker's docker buildx CLI directly

If you prefer more control:

- name: Build and push multi-arch
  run: |
    docker buildx build \
      --platform linux/amd64,linux/arm64 \
      --tag lineofflight/frankfurter:${{ github.ref_name }} \
      --push \
      .

Potential Pitfalls to Watch For

1. Build Time Increase ⏰

• Multi-arch builds take 2-3x longer (QEMU emulation for arm64 on amd64 runners)
• Mitigation: Use GitHub Actions cache (cache-from/cache-to settings above)

2. Native Dependencies 🔧

• Your Ruby base image should handle this, but watch for gems with native extensions
• Test locally: docker buildx build --platform linux/arm64 --load .

3. Image Size 📦

• Multi-arch manifests create separate images per architecture
• Total repository size increases (not individual pull size)
• Monitor: Docker Hub has storage limits on free tier

4. Platform-Specific Issues 🐛

• Some Ruby gems or system packages might behave differently on arm64
• Recommendation: Add platform-specific testing in CI:

  test:
    strategy:
      matrix:
        platform: [ubuntu-latest, ubuntu-latest-arm64]  # if arm64 runners available

5. QEMU Performance 🐌

• Emulated builds (arm64 on amd64) are significantly slower
• Alternative: Use native arm64 runners if available (GitHub now offers them)

6. Cache Invalidation 🔄

• Different architectures need separate caches
• Initial builds after Dockerfile changes will be slow
• Solution: The suggested config uses GitHub Actions cache which handles this

7. Base Image Availability 🖼️

• Verify ruby:3.4.6 is available for arm64: ✅ (confirmed available)
• Always check base image platform support before committing

Quick Migration Path

1. Update .github/workflows/ci.yml with the buildx configuration
2. No Dockerfile changes needed (your current one is platform-agnostic)
3. Test the workflow on a branch first
4. Monitor first few builds for any architecture-specific issues

The setup above is production-ready and follows Docker's official recommendations for multi-platform builds. It's minimal yet robust, with proper caching to minimize build times.

[hakanensari]

@afh, thanks for the suggestion! Does the above look reasonable?

[afh]

Thanks for your response, @hakanensari and involving Claude. Glancing over Claude's response it does seem reasonable to me, yet building cross-architecture docker images isn't part of my day job. Happy to help with testing on aarch64-darwin.