Add multi-architecture support for ARM64 and AMD64

- Updated tasks.py to use docker buildx for multi-platform builds
- Added new buildx task for efficient multi-arch building and pushing
- Created GitHub Actions workflows for multi-arch CI/CD
- Updated README with comprehensive multi-architecture documentation
- Implements feature requested in issue #171

🤖 Generated with Claude Code

Co-Authored-By: Claude <[email protected]>

Author: Hat Dao

.github/workflows/dockerimage.yml

@@ -9,6 +9,24 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - name: Build the latest Docker image
-        run: make build
+      - uses: actions/checkout@v4
+      
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install invoke requests
+          
+      - name: Build multi-architecture images
+        run: |
+          # Build for both amd64 and arm64
+          invoke buildx latest --push=False
+          
+      - name: Test the built image
+        run: |
+          docker run --rm grokzen/redis-cluster:${LATEST_VERSION:-7.2.5} redis-server --version

.github/workflows/release.yml

@@ -0,0 +1,68 @@
+name: Release Multi-Arch Images
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Redis version to build (e.g., 7.2, 7.2.5, latest, or all)'
+        required: true
+        default: 'latest'
+      push:
+        description: 'Push images to Docker Hub'
+        required: true
+        type: boolean
+        default: true
+  release:
+    types: [published]
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      
+      - 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
+        if: github.event.inputs.push == 'true' || github.event_name == 'release'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          
+      - name: Install Python dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install invoke requests
+          
+      - name: Build and push multi-architecture images
+        run: |
+          # Determine version from inputs or release tag
+          if [ "${{ github.event_name }}" == "release" ]; then
+            VERSION="${{ github.event.release.tag_name }}"
+          else
+            VERSION="${{ github.event.inputs.version }}"
+          fi
+          
+          # Determine if we should push
+          if [ "${{ github.event.inputs.push }}" == "true" ] || [ "${{ github.event_name }}" == "release" ]; then
+            PUSH_FLAG="--push=True"
+          else
+            PUSH_FLAG="--push=False"
+          fi
+          
+          echo "Building version: $VERSION with push flag: $PUSH_FLAG"
+          invoke buildx "$VERSION" $PUSH_FLAG
+          
+      - name: Update Docker Hub description
+        if: (github.event.inputs.push == 'true' || github.event_name == 'release') && github.event.inputs.version == 'latest'
+        uses: peter-evans/dockerhub-description@v4
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          repository: grokzen/redis-cluster
+          readme-filepath: ./README.md

.gitignore

@@ -0,0 +1 @@
+.claude/

README.md

@@ -222,6 +222,53 @@ To build a different redis version use the `--build-arg` argument.
     docker-compose build --build-arg "redis_version=6.0.11" redis-cluster
 
 
+## Multi-Architecture Support
+
+This project now supports building images for multiple architectures including `linux/amd64` (x86_64) and `linux/arm64` (ARM64/Apple Silicon).
+
+### Using Pre-built Multi-Arch Images
+
+All images on Docker Hub are now built for both AMD64 and ARM64 architectures. Docker will automatically pull the correct image for your platform:
+
+    docker pull grokzen/redis-cluster:latest
+    docker run grokzen/redis-cluster:latest
+
+### Building Multi-Arch Images Locally
+
+To build multi-architecture images locally, you need Docker Buildx (included in Docker Desktop 19.03+).
+
+#### Using invoke tasks (recommended)
+
+    # Build for both AMD64 and ARM64 (default)
+    invoke buildx 7.2.5
+    
+    # Build and push to Docker Hub
+    invoke buildx 7.2.5 --push=True
+    
+    # Build for specific platforms only
+    invoke buildx 7.2.5 --platforms="linux/amd64"
+    
+    # Build all versions for multi-arch
+    invoke buildx all
+
+#### Using docker buildx directly
+
+    # Create a buildx builder (only needed once)
+    docker buildx create --use --name redis-cluster-builder
+    
+    # Build for multiple platforms
+    docker buildx build --platform="linux/arm64,linux/amd64" \
+      --build-arg="redis_version=7.2.5" \
+      --tag="grokzen/redis-cluster:7.2.5" \
+      --push .
+
+### GitHub Actions
+
+The project includes GitHub Actions workflows that automatically build multi-architecture images:
+
+- **CI Build**: Builds multi-arch images on every push to master (without pushing)
+- **Release**: Builds and pushes multi-arch images when creating a release or manually triggered
+
 
 # Available tags
 

tasks.py

@@ -72,19 +72,23 @@ def _docker_build(config):
     """
     Internal multiprocess method to run docker build command
     """
-    c, version = config
-    print(f" -- Starting docker build for version : {version}")
-    build_command = f"docker build --build-arg redis_version={version} -t grokzen/redis-cluster:{version} ."
+    c, version, platforms = config
+    print(f" -- Starting docker build for version : {version} on platforms: {platforms}")
+    # Create buildx builder if it doesn't exist
+    c.run("docker buildx create --use --name redis-cluster-builder || docker buildx use redis-cluster-builder", warn=True)
+    build_command = f"docker buildx build --platform={platforms} --build-arg redis_version={version} -t grokzen/redis-cluster:{version} --load ."
     c.run(build_command)
 
 
 def _docker_push(config):
     """
-    Internal multiprocess method to run docker push command
+    Internal multiprocess method to run docker push command with multi-arch support
     """
-    c, version = config
-    print(f" -- Starting docker push for version : {version}")
-    build_command = f"docker push grokzen/redis-cluster:{version}"
+    c, version, platforms = config
+    print(f" -- Starting docker push for version : {version} with platforms: {platforms}")
+    # Use buildx to build and push multi-arch images
+    c.run("docker buildx create --use --name redis-cluster-builder || docker buildx use redis-cluster-builder", warn=True)
+    build_command = f"docker buildx build --platform={platforms} --build-arg redis_version={version} -t grokzen/redis-cluster:{version} --push ."
     c.run(build_command)
 
 
@@ -103,33 +107,65 @@ def pull(c, version, cpu=None):
 
 
 @task
-def build(c, version, cpu=None):
-    print(f" -- Docker building version : {version}")
+def build(c, version, cpu=None, platforms="linux/amd64,linux/arm64"):
+    print(f" -- Docker building version : {version} for platforms : {platforms}")
 
     pool = Pool(get_pool_size(cpu))
     pool.map(
         _docker_build,
         [
-            [c, version]
+            [c, version, platforms]
             for version in version_name_to_version(version)
         ],
     )
 
 
 @task
-def push(c, version, cpu=None):
-    print(f" -- Docker push version to docker-hub : {version}")
+def push(c, version, cpu=None, platforms="linux/amd64,linux/arm64"):
+    print(f" -- Docker push version to docker-hub : {version} for platforms : {platforms}")
 
     pool = Pool(get_pool_size(cpu))
     pool.map(
         _docker_push,
         [
-            [c, version]
+            [c, version, platforms]
+            for version in version_name_to_version(version)
+        ],
+    )
+
+
+@task
+def buildx(c, version, cpu=None, platforms="linux/amd64,linux/arm64", push=True):
+    """
+    Build multi-architecture images using docker buildx.
+    This is more efficient than separate build and push commands for multi-arch.
+    """
+    print(f" -- Docker buildx for version : {version} on platforms : {platforms} (push={push})")
+    
+    # Create buildx builder if it doesn't exist
+    c.run("docker buildx create --use --name redis-cluster-builder || docker buildx use redis-cluster-builder", warn=True)
+    
+    pool = Pool(get_pool_size(cpu))
+    pool.map(
+        _docker_buildx,
+        [
+            [c, version, platforms, push]
             for version in version_name_to_version(version)
         ],
     )
 
 
+def _docker_buildx(config):
+    """
+    Internal multiprocess method to run docker buildx command
+    """
+    c, version, platforms, push = config
+    action = "--push" if push else "--load"
+    print(f" -- Starting docker buildx for version : {version} on platforms: {platforms} with action: {action}")
+    build_command = f"docker buildx build --platform={platforms} --build-arg redis_version={version} -t grokzen/redis-cluster:{version} {action} ."
+    c.run(build_command)
+
+
 @task
 def list(c):
     from pprint import pprint