Agent skill

gradle-docker-jib

Configures and builds optimized Docker images using Google's Jib plugin without Docker daemon or Dockerfile. Use when containerizing Spring Boot microservices, building multi-architecture images, or pushing to registries. Triggers on "setup Jib", "build Docker image", "containerize with Jib", or "multi-arch image". Works with build.gradle.kts and includes Jib plugin setup, multi-module configuration, and CI/CD integration.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/gradle-docker-jib

SKILL.md

Gradle Docker Jib Integration

Table of Contents

  • Purpose
  • When to Use
  • Quick Start
  • Instructions
  • Requirements
  • See Also

Purpose

Build Docker images efficiently using Google's Jib plugin without requiring Docker installation, Dockerfiles, or container knowledge. Jib automatically optimizes layers and handles multi-architecture builds for local and registry deployments.

When to Use

Use this skill when you need to:

  • Build Docker images without Docker daemon or Dockerfiles
  • Containerize Spring Boot microservices efficiently
  • Create multi-architecture images (amd64, arm64) for cloud deployment
  • Optimize Docker layer caching for faster builds
  • Push images to GCR, Docker Hub, or private registries
  • Integrate Docker image building in CI/CD pipelines

Quick Start

Add Jib plugin to build.gradle.kts:

kotlin
plugins {
    id("com.google.cloud.tools.jib") version "3.4.4"
}

jib {
    from {
        image = "eclipse-temurin:21-jre-alpine"
    }
    to {
        image = "gcr.io/my-project/my-app"
        tags = setOf("latest", project.version.toString())
    }
    container {
        jvmFlags = listOf("-Xmx512m", "-Xms256m")
        ports = listOf("8080")
        user = "nobody"
    }
}

Build to local Docker:

bash
./gradlew jibDockerBuild

Build and push to registry:

bash
./gradlew jib

Instructions

Step 1: Add Jib Plugin

Add to build.gradle.kts:

kotlin
plugins {
    id("com.google.cloud.tools.jib") version "3.4.4"
}

Or in build.gradle:

groovy
plugins {
    id 'com.google.cloud.tools.jib' version '3.4.4'
}

Step 2: Configure Base Image

Choose appropriate base image:

For Spring Boot (JRE only):

kotlin
jib {
    from {
        image = "eclipse-temurin:21-jre-alpine"
        // or for ARM support
        // image = "eclipse-temurin:21-jre"
    }
}

For distroless (minimal):

kotlin
jib {
    from {
        image = "gcr.io/distroless/java21-debian12"
    }
}

See references/detailed-guide.md for base image selection guide.

Step 3: Configure Target Registry

Google Container Registry (GCR):

kotlin
jib {
    to {
        image = "gcr.io/my-project/my-app"
        tags = setOf("latest", project.version.toString())
    }
}

Docker Hub:

kotlin
jib {
    to {
        image = "docker.io/myusername/my-app"
        auth {
            username = System.getenv("DOCKER_USERNAME")
            password = System.getenv("DOCKER_PASSWORD")
        }
    }
}

Private registry:

kotlin
jib {
    to {
        image = "registry.company.com/my-app"
        credHelper = "gcr"  // or "ecr-login", "docker-credential-gcr"
    }
}

Step 4: Configure Container Settings

JVM flags and ports:

kotlin
jib {
    container {
        jvmFlags = listOf(
            "-Xmx512m",
            "-Xms256m",
            "-Dspring.profiles.active=prod",
            "-XX:+UseContainerSupport"
        )
        ports = listOf("8080", "8081")
        labels = mapOf(
            "maintainer" to "team@company.com",
            "version" to project.version.toString()
        )
        user = "nobody"
        workingDirectory = "/app"
    }
}

Environment variables:

kotlin
jib {
    container {
        environment = mapOf(
            "PORT" to "8080",
            "ENV" to "production"
        )
    }
}

See references/detailed-guide.md for advanced container configuration.

Step 5: Configure Multi-Architecture Images

Build for multiple platforms:

kotlin
jib {
    from {
        image = "eclipse-temurin:21-jre"
        platforms {
            platform {
                architecture = "amd64"
                os = "linux"
            }
            platform {
                architecture = "arm64"
                os = "linux"
            }
        }
    }
}

Step 6: Set Up Authentication

Using credential helpers:

bash
# Install credential helper
gcloud auth configure-docker

# Or for Docker Hub
docker login

Using environment variables:

bash
export DOCKER_USERNAME=myuser
export DOCKER_PASSWORD=mypassword
./gradlew jib

In CI/CD:

yaml
# GitHub Actions
- name: Build and Push
  run: ./gradlew jib
  env:
    DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
    DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}

Step 7: Build Images

Build to local Docker daemon:

bash
./gradlew jibDockerBuild
docker images  # Verify image exists

Build and push to registry:

bash
./gradlew jib

Build OCI tar archive:

bash
./gradlew jibBuildTar
# Creates build/jib-image.tar

Step 8: Configure Multi-Module Projects

For multi-module projects, configure Jib in specific modules:

kotlin
// app/build.gradle.kts
plugins {
    id("com.google.cloud.tools.jib")
}

jib {
    to {
        image = "gcr.io/my-project/${project.name}"
    }
    container {
        mainClass = "com.example.app.MainKt"
    }
}

// service-a/build.gradle.kts
plugins {
    id("com.google.cloud.tools.jib")
}

jib {
    to {
        image = "gcr.io/my-project/${project.name}"
    }
}

See references/detailed-guide.md for complete multi-module setup.

Step 9: Optimize Build Performance

Enable caching:

kotlin
jib {
    // Use timestamp for better layer caching
    container {
        creationTime = "USE_CURRENT_TIMESTAMP"
    }
}

Skip unchanged layers: Jib automatically caches layers by content hash - no configuration needed.

Requirements

  • Gradle: 7.0+ (8.11+ recommended)
  • Java: JDK 11+ (21 recommended)
  • Jib Plugin: 3.4.4+
  • Authentication:
    • Docker credential helper (recommended)
    • Environment variables
    • Docker config (~/.docker/config.json)
  • For Local Docker:
    • Docker daemon running
    • jibDockerBuild command
  • For Registry Push:
    • Valid credentials
    • Network access to registry

See Also

  • references/detailed-guide.md - Comprehensive examples, commands reference, troubleshooting, and best practices
  • gradle-ci-cd-integration - Integrate Jib in CI/CD pipelines
  • Jib Documentation - Official Jib docs

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results