Skip to content

Latest commit

 

History

History
1069 lines (898 loc) · 30.2 KB

docker.adoc

File metadata and controls

1069 lines (898 loc) · 30.2 KB
Raw

Docker

Creates Docker images.

The following artifact extensions are supported by this packager:

  • .jar

  • .zip

Distribution Support

Distribution Supported Buildx

concepts:distributions/binary.adoc

{icon_req_y}

{icon_req_n}

concepts:distributions/flat-binary.adoc

{icon_req_y}

{icon_req_y}

concepts:distributions/java-binary.adoc

{icon_req_y}

{icon_req_y}

concepts:distributions/jlink.adoc

{icon_req_y}

{icon_req_n}

concepts:distributions/native-image.adoc

{icon_req_y}

{icon_req_n}

concepts:distributions/native-package.adoc

{icon_req_n}

{icon_req_n}

concepts:distributions/single-jar.adoc

{icon_req_y}

{icon_req_y}
Important
 Building and publishing docker images requires the docker command and a running Docker deamon. JReleaser will not install these tools.
Note
 docker.io will be set as default registry (with "DEFAULT" as name) if no registries are configured. The chosen username will be set to match the Git username.
YAML
partial$packagers/yaml/common-head.adoc

partial$packagers/yaml/template-directory.adoc

partial$packagers/yaml/commitauthor.adoc

partial$packagers/yaml/tap.adoc

    # The base Docker image to use.
    # [dot circle] [file alt]
    baseImage: "alpine:latest"

    # A list of image names.
    # If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
    # will be created.
    # [dot circle] [file alt]
    imageNames:
      - "{{repoOwner}}/{{distributionName}}:{{tagName}}"
      - "duke/app:latest"

    # A list of build arguments.
    # [dot circle] [file alt]
    buildArgs:
      - "--pull"

    # Selects a Dockerfile template.
    # If `true` (default) then the Dockerfile will use the local distribution files.
    # If `false` then the Dockerfile expects the artifact to be downloaded from an URL.
    # [dot circle]
    useLocalArtifact: true

    # Dockerfile commands to run before the assembly.
    # [dot circle] [file alt]
    preCommands:
      - "RUN apt-get update -y"
      - "RUN apt-get install unzip"

    # Dockerfile commands to run after the assembly, before ENTRYPOINT.
    # [dot circle] [file alt]
    postCommands:
      - "VOLUME /workspace"

    # A map of Docker labels.
    # [dot circle]
    labels:
      foo: bar

    # Configure multi-arch image support.
    # [dot circle]
    buildx:

      # Enable buildx support.
      # Default is `false`.
      # [dot circle]
      enabled: true

      # Configure the buildx builder.
      # Defaults to `['--name', 'jreleaser', '--driver', 'docker-container', '--bootstrap', '--use']`.
      # [dot circle] [file alt]
      createBuilderFlags:
        - '--name'
        - 'jreleaser'
        - '--bootstrap'
        - '--use'

      # Configure platforms to be used.
      # [exclamation triangle] [file alt]
      platforms:
        - 'linux/amd64'
        - 'linux/arm64'

    # A list of docker registries where images will be published.
    # [dot circle]
    registries:

        # The name of the registry. Must be unique.
        # Use `DEFAULT` to match the default registry
        # provided by the Docker daemon.
        # [exclamation triangle]
      - serverName: myRegistry

        # The address of the docker registry.
        # [exclamation triangle] if `serverName != DEFAULT`.
        server: https://myregistry.com

        # The user that can publish images.
        # If left unspecified, the `JRELEASER_DOCKER_${serverName}_USERNAME`
        # environment variable must be defined.
        # Defaults to the same username as the release repository.
        # [dot circle] [eye slash]
        username: duke

        # Password for login into the registry
        # If left unspecified, the `JRELEASER_DOCKER_${serverName}_PASSWORD`
        # environment variable must be defined.
        # [dot circle] [eye slash]
        password: __DO_NOT_SET_HERE__

        # The name of the repository
        # Defaults to the same owner as the release repository.
        # [dot circle]
        repositoryName: duke
TOML
partial$packagers/toml/common-head.adoc

partial$packagers/toml/template-directory.adoc

partial$packagers/toml/commitauthor.adoc

partial$packagers/toml/tap.adoc

  # The base Docker image to use.
  # [dot circle] [file alt]
  baseImage = "alpine:latest"

  # A list of image names.
  # If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
  # will be created.
  # [dot circle] [file alt]
  imageNames = [
    "{{repoOwner}}/{{distributionName}}:{{tagName}}",
    "duke/app:latest"]

  # A list of build arguments.
  # [dot circle] [file alt]
  buildArgs = ["--pull"]

  # Selects a Dockerfile template.
  # If `true` (default) then the Dockerfile will use the local distribution files.
  # If `false` then the Dockerfile expects the artifact to be downloaded from an URL.
  # [dot circle]
  useLocalArtifact = true

  # Dockerfile commands to run before the assembly.
  # [dot circle] [file alt]
  preCommands = [
    "RUN apt-get update -y",
    "RUN apt-get install unzip"]

  # Dockerfile commands to run after the assembly, before ENTRYPOINT.
  # [dot circle] [file alt]
  postCommands = ["VOLUME /workspace"]

  # A map of Docker labels.
  # [dot circle]
  labels.foo = "bar"

  # Configure multi-arch image support.
  # [dot circle]

  # Enable buildx support.
  # Default is `false`.
  # [dot circle]
  buildx.enabled = true

  # Configure the buildx builder.
  # Defaults to `['--name', 'jreleaser', '--driver', 'docker-container', '--bootstrap', '--use']`.
  # [dot circle] [file alt]
  buildx.createBuilderFlags = ["--name", "jreleaser", "--driver", "docker-container", "--bootstrap", "--use"]

  # Configure platforms to be used.
  # [exclamation triangle] [file alt]
  buildx.platforms = ["linux/amd64", "linux/arm64"]

  # A list of docker registries where images will be published.
  # [dot circle]
  [[packagers.docker.registries]]
    # The name of the registry. Must be unique.
    # Use `DEFAULT` to match the default registry
    # provided by the Docker daemon.
    # [exclamation triangle]
    serverName = "myRegistry"

    # The address of the docker registry.
    # [exclamation triangle] if `serverName != DEFAULT`.
    server = "https://myregistry.com"

    # The user that can publish images.
    # If left unspecified, the `JRELEASER_DOCKER_${serverName}_USERNAME`
    # environment variable must be defined.
    # Defaults to the same username as the release repository.
    # [dot circle] [eye slash]
    username = "duke"

    # Password for login into the registry
    # If left unspecified, the `JRELEASER_DOCKER_${serverName}_PASSWORD`
    # environment variable must be defined.
    # [dot circle] [eye slash]
    password = "__DO_NOT_SET_HERE__"

    # The name of the repository
    # Defaults to the same owner as the release repository.
    # [dot circle]
    repositoryName = "duke"
JSON
partial$packagers/json/common-head.adoc

partial$packagers/json/template-directory.adoc

partial$packagers/json/commitauthor.adoc

partial$packagers/json/tap.adoc

      // The base Docker image to use.
      // [dot circle] [file alt]
      "baseImage": "alpine:latest",

      // A list of image names.
      // If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
      // will be created.
      // [dot circle] [file alt]
      "imageNames": [
        "{{repoOwner}}/{{distributionName}}:{{tagName}}",
        "duke/app:latest"
      ],

      // A list of build arguments.
      // [dot circle] [file alt]
      "buildArgs": [
        "--pull"
      ],

      // Selects a Dockerfile template.
      // If `true` (default) then the Dockerfile will use the local distribution files.
      // If `false` then the Dockerfile expects the artifact to be downloaded from an URL.
      // [dot circle]
      "useLocalArtifact": true,

      // Dockerfile commands to run before the assembly.
      // [dot circle] [file alt]
      "preCommands": [
        "RUN apt-get update -y",
        "RUN apt-get install unzip"
      ],

      // Dockerfile commands to run after the assembly, before ENTRYPOINT.
      // [dot circle] [file alt]
      "postCommands": [
        "VOLUME /workspace"
      ],

      // A map of Docker labels.
      // [dot circle]
      "labels": {
        "foo": "bar"
      },

      // Configure multi-arch image support.
      // [dot circle]
      "buildx": {

        // Enable buildx support.
        // Default is `false`.
        // [dot circle]
        "enabled": true,

        // Configure the buildx builder.
        // Defaults to `['--name', 'jreleaser', '--driver', 'docker-container', '--bootstrap', '--use']`.
        // [dot circle] [file alt]
        "createBuilderFlags": [
          "--name",
          "jreleaser",
          "--bootstrap",
          "--use"
        ],

        // Configure platforms to be used.
        // [exclamation triangle] [file alt]
        "platforms": [
          "linux/amd64",
          "linux/arm64"
        ]
      },

      // A list of docker registries where images will be published.
      // [dot circle]
      "registries": [

        {
          // The name of the registry. Must be unique.
          // Use `DEFAULT` to match the default registry
          // provided by the Docker daemon.
          // [exclamation triangle]
          "serverName": "someName",

          // The address of the docker registry.
          // [exclamation triangle] if `serverName != DEFAULT`.
          "server": "https://myregistry.com",

          // The user that can publish images.
          // If left unspecified, the `JRELEASER_DOCKER_${serverName}_USERNAME`
          // environment variable must be defined.
          // Defaults to the same username as the release repository.
          // [dot circle] [eye slash]
          "username": "duke",

          // Password for login into the registry
          // If left unspecified, the `JRELEASER_DOCKER_${serverName}_PASSWORD`
          // environment variable must be defined.
          // [dot circle] [eye slash]
          "password": "__DO_NOT_SET_HERE__",

          // The name of the repository
          // Defaults to the same owner as the release repository.
          // [dot circle]
          "repositoryName": "duke"
        }
      ]
partial$packagers/json/common-footer.adoc
Maven
partial$packagers/maven/common-head.adoc

partial$packagers/maven/template-directory.adoc

partial$packagers/maven/commitauthor.adoc

partial$packagers/maven/tap.adoc

      <!--
        The base Docker image to use.
        [dot circle] [file alt]
      -->
      <baseImage>alpine:latest</baseImage>

      <!--
        A list of image names.
        If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
        will be created.
        [dot circle] [file alt]
      -->
      <imageNames>
        <imageName>{{repoOwner}}/{{distributionName}}:{{tagName}}</imageName>
        <imageName>duke/app:latest</imageName>
      </imageNames>

      <!--
        A list of build arguments.
        [dot circle] [file alt]
      -->
      <buildArgs>
        <buildArg>--pull</buildArg>
      </buildArgs>

      <!--
        Selects a Dockerfile template.
        If `true` (default) then the Dockerfile will use the local distribution files.
        If `false` then the Dockerfile expects the artifact to be downloaded from an URL.
        [dot circle]
      -->
      <useLocalArtifact>true</useLocalArtifact>

      <!--
        Dockerfile commands to run before the assembly.
        [dot circle] [file alt]
      -->
      <preCommands>
        <preCommand>RUN apt-get update -y</preCommand>
        <preCommand>RUN apt-get install unzip</preCommand>
      </preCommands>

      <!--
        Dockerfile commands to run after the assembly, before ENTRYPOINT.
        [dot circle] [file alt]
      -->
      <postCommands>
        <postCommand>VOLUME /workspace</postCommand>
      </postCommands>

      <!--
        A map of Docker labels.
        [dot circle]
      -->
      <labels>
        <foo>bar</foo>
      </labels>

      <!--
        Configure multi-arch image support.
        [dot circle]
      -->
      <buildx>
        <!--
          Enable buildx support.
          Default is `false`.
          [dot circle]
        -->
        <enabled>true</enabled>

        <!--
          Configure the buildx builder.
          Defaults to `['--name', 'jreleaser', '--driver', 'docker-container', '--bootstrap', '--use']`.
          [dot circle] [file alt]
        -->
        <createBuilderFlags>
          <createBuilderFlag>--name</createBuilderFlag>
          <createBuilderFlag>jreleaser</createBuilderFlag>
          <createBuilderFlag>--bootstrap</createBuilderFlag>
          <createBuilderFlag>--use</createBuilderFlag>
        </createBuilderFlags>

        <!--
          Configure platforms to be used.
          [exclamation triangle] [file alt]
        -->
        <platforms>
          <platform>linux/amd64</platform>
          <platform>linux/arm64</platform>
        </platforms>
      </buildx>

      <!--
        A list of docker registries where images will be published.
        [dot circle]
      -->
      <registries>
        <registry>
          <!--
             The name of the registry. Must be unique.
             Use `DEFAULT` to match the default registry
             provided by the Docker daemon.
             [exclamation triangle]
          -->
          <serverName>myRegistry</serverName>

          <!--
            The address of the docker registry.
            [exclamation triangle] if `serverName != DEFAULT`.
          -->
          <server>pass[https: myregistry.com]</server>

          <!--
            The user that can publish images.
            If left unspecified, the `JRELEASER_DOCKER_${serverName}_USERNAME`
            environment variable must be defined.
            Defaults to the same username as the release repository.
            [dot circle] [eye slash]
          -->
          <username>duke</username>

          <!--
            Password for login into the registry
            If left unspecified, the `JRELEASER_DOCKER_${serverName}_PASSWORD`
            environment variable must be defined.
            [dot circle] [eye slash]
          -->
          <password>__DO_NOT_SET_HERE__</password>

          <!--
            The name of the repository
            Defaults to the same owner as the release repository.
            [dot circle]
          -->
          <repositoryName>duke</repositoryName>
        </registry>
      </registries>
partial$packagers/maven/common-footer.adoc
Gradle
partial$packagers/gradle/common-head.adoc

partial$packagers/gradle/template-directory.adoc

partial$packagers/gradle/commitauthor.adoc

partial$packagers/gradle/tap.adoc

      // The base Docker image to use.
      // [dot circle] [file alt]
      baseImage = 'alpine:latest'

      // A list of image names.
      // If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
      // will be created.
      // [dot circle] [file alt]
      imageName('{{repoOwner}}/{{distributionName}}:{{tagName}}')
      imageName('duke/app:latest')

      // A list of build arguments.
      // [dot circle] [file alt]
      buildArg('--pull')

      // Selects a Dockerfile template.
      // If `true` (default) then the Dockerfile will use the local distribution files.
      // If `false` then the Dockerfile expects the artifact to be downloaded from an URL.
      // [dot circle]
      useLocalArtifact = true

      // Dockerfile commands to run before the assembly.
      // [dot circle] [file alt]
      preCommand('RUN apt-get update -y')
      preCommand('RUN apt-get install unzip')

      // Dockerfile commands to run after the assembly, before ENTRYPOINT.
      // [dot circle] [file alt]
      postCommand('VOLUME /workspace')

      // A map of Docker labels.
      // The key `openjdk@${java.version}` will be added automatically if not defined.
      // [dot circle]
      label('foo', 'bar')

      // Configure multi-arch image support.
      // [dot circle]
      buildx {

        // Enable buildx support.
        // Default is `false`.
        // [dot circle]
        enabled = true

        // Configure the buildx builder.
        // Defaults to `['--name', 'jreleaser', '--driver', 'docker-container', '--bootstrap', '--use']`.
        // [dot circle] [file alt]
        createBuilderFlag('--name')
        createBuilderFlag('jreleaser')
        createBuilderFlag('--bootstrap')
        createBuilderFlag('--use')

        // Configure platforms to be used.
        // [exclamation triangle] [file alt]
        platform('linux/amd64')
        platform('linux/arm64')
      }

      // A list of docker registries where images will be published.
      // [dot circle]
      registries {

        // The name of the registry. Must be unique.
        // Use `DEFAULT` to match the default registry
        // provided by the Docker daemon.
        // [exclamation triangle]
        someName {

          // The address of the docker registry.
          // [exclamation triangle] if `serverName != DEFAULT`.
          server = 'https://myregistry.com'

          // The user that can publish images.
          // If left unspecified, the `JRELEASER_DOCKER_${serverName}_USERNAME`
          // environment variable must be defined.
          // Defaults to the same username as the release repository.
          // [dot circle] [eye slash]
          username = 'duke'

          // Password for login into the registry
          // If left unspecified, the `JRELEASER_DOCKER_${serverName}_PASSWORD`
          // environment variable must be defined.
          // [dot circle] [eye slash]
          password = '__DO_NOT_SET_HERE__'

          // The name of the repository
          // Defaults to the same owner as the release repository.
          // [dot circle]
          repositoryName = 'duke'
        }
      }
partial$packagers/gradle/common-footer.adoc

Example

Assuming the current version is 1.2.3, and a distribution named app, the above configuration will generate a Dockerfile like the following one:

FROM azul/zulu-openjdk-alpine:8-jre

LABEL "org.opencontainers.image.title"="app"
LABEL "org.opencontainers.image.description"="Awesome App"
LABEL "org.opencontainers.image.url"="https://acme.com/app"
LABEL "org.opencontainers.image.licenses"="Apache-2.0"
LABEL "org.opencontainers.image.version"="1.2.3"
LABEL "org.opencontainers.image.revision"="de0266d314b91dd201765616e207d0a8706d0b99"

COPY assembly/* /

RUN unzip app-1.2.3.zip && \
    rm app-1.2.3.zip && \
    chmod +x app-1.2.3/bin/app

ENV PATH="${PATH}:/app-1.2.3/bin"

ENTRYPOINT ["/app-1.2.3/bin/app"]

Base Images

Different values for the default base image will be used depending on the distribution type:

  • azul/zulu-openjdk-alpine:${distribution.java.version}-jre for JAVA_BINARY and SINGLE_JAR distributions.

  • ubuntu:latest for JLINK distributions when the artifact has a linux platform.

  • alpine:latest for JLINK distributions when the artifact has a linux_musl platform.

  • scratch for NATIVE_IMAGE distributions.

Default Labels

JReleaser will add the following labels if they are not explicitly defined:

  • org.opencontainers.image.title = {{distributionName}}

  • org.opencontainers.image.description = {{projectDescription}}

  • org.opencontainers.image.url = {{projectWebsite}}

  • org.opencontainers.image.licenses = {{projectLicense}}

  • org.opencontainers.image.version = {{projectVersion}}

  • org.opencontainers.image.revision = {{commitFullHash}}

You may use any reference:name-templates.adoc as part of the label value.

Generic Image Names

Some users might want to keep their image name as generic as possible. That can be accomplished simply by adding a template to the imageNames field.

YAML
project:
  name: app

packagers:
  docker:
    active: ALWAYS
    imageNames:
      - "myuser/{{projectName}}"
TOML
[project]
  name = "app"

[packagers.docker]
  active = "ALWAYS"
  imageNames = ["myuser/{{projectName}}"]
JSON
{
  "project": {
    "name": "app"
  },

  "packagers": {
    "docker": {
      "active": "ALWAYS",
      "imageNames": [
        "myuser/{{projectName}}"
      ]
    }
  }
}
Maven
<!-- project.artifactId = app -->
<jreleaser>
  <packagers>
    <docker>
      <active>ALWAYS</active>
      <imageNames>
        <imageName>myuser/{{projectName}}</imageName>
      </imageNames>
    </docker>
  </packagers>
</jreleaser>
Gradle
// project.name = app
jreleaser {
  packagers {
    docker {
      active = 'ALWAYS'
      imageName('myuser/{{projectName}}')
    }
  }
}

This will build the following images:

  • myuser/app

Prerelease Image Names

A different set of images names will be automatically configured when the project is snapshot, to avoid possible clashes with production images.

JReleaer will look for the first image name that ends with :{{tagName}} and discard the rest.

It will use {{repoOwner}}/{{distributionName}}:{{tagName}} if no matching image name is found.

Keeping docker images updated for current major

Some users might want to when version to push docker tags :v1, :v1.6, :v1.6.4 and :latest when v1.6.4 (for example) is built. That can be accomplished by using multiple image names:

YAML
project:
  name: app

packagers:
  docker:
    active: ALWAYS
    imageNames:
    - "myuser/myimage:{{tagName}}"
    - "myuser/myimage:v{{projectVersionMajor}}"
    - "myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}"
    - "myuser/myimage:latest"
TOML
[project]
  name = "app"

[packagers.docker]
  active = "ALWAYS"
  imageNames = [
    "myuser/myimage:{{tagName}}",
    "myuser/myimage:v{{projectVersionMajor}}",
    "myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}",
    "myuser/myimage:latest"]
JSON
{
  "project": {
    "name": "app"
  },

  "packagers": {
    "docker": {
      "active": "ALWAYS",
      "imageNames": [
        "myuser/myimage:{{tagName}}",
        "myuser/myimage:v{{projectVersionMajor}}",
        "myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}",
        "myuser/myimage:latest"
      ]
    }
  }
}
Maven
<!-- project.artifactId = app -->
<jreleaser>
  <packagers>
    <docker>
      <active>ALWAYS</active>
      <imageNames>
        <imageName>myuser/myimage:{{tagName}}</imageName>
        <imageName>myuser/myimage:v{{projectVersionMajor}}</imageName>
        <imageName>myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}</imageName>
        <imageName>myuser/myimage:latest</imageName>
      </imageNames>
    </docker>
  </packagers>
</jreleaser>
Gradle
// project.name = app
jreleaser {
  packagers {
    docker {
      active = 'ALWAYS'
      imageName('myuser/myimage:{{tagName}}')
      imageName('myuser/myimage:v{{projectVersionMajor}}')
      imageName('myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}')
      imageName('myuser/myimage:latest')
    }
  }
}

This will build the following images:

  • myuser/myimage:v1.6.4

  • myuser/myimage:v1

  • myuser/myimage:v1.6

  • myuser/myimage:latest

Additional Files

Any files placed inside ${docker.templateDirectory}/assembly will be copied into the container at the root.

Multiple Dockerfile per Distribution

The previous sections explain how a single or multiple Docker images may be created for a single distribution using the same Dockerfile. However, should you need to use several Dockerfiles with the same distribution then just add a specs section and configure each spec to your liking. Each spec takes the same arguments as the docker section plus an extra element named matchers that determines which distribution artifact should be used with that particular spec.

Matchers are key/value pairs that can match the artifact’s platform property and any of its extraProperties.

This feature is useful when paired with an assembled Jlink distribution that defines more than one artifact that may be packaged with Docker. Here’s for example how JReleaser handles the case of generating cross-platform Java Runtimes with Jlink; there are 2 artifacts (the linux variants) that may be distributed with Docker, each one requiring different settings:

YAML
environment:
  properties:
    jdkPathPrefix: 'apps/jreleaser/build/jdks/zulu11.48.21-ca-jdk11.0.11'

assemble:
  jlink:
    jreleaser-standalone:
      active: always
      java:
        version: 11
        mainClass: 'org.jreleaser.cli.Main'
      imageName: '{{distributionName}}-{{projectEffectiveVersion}}'
      executable: 'jreleaser'
      moduleNames:
        - java.base
        - java.desktop
        - java.management
        - java.naming
        - java.rmi
        - java.security.jgss
        - java.sql
      targetJdks:
        - path: '{{jdkPathPrefix}}-macosx_x64/zulu-11.jdk/Contents/Home'
          platform: 'osx'
        - path: '{{jdkPathPrefix}}-linux_x64'
          platform: 'linux'
        - path: '{{jdkPathPrefix}}-linux_musl_x64'
          platform: 'linux_musl'
        - path: '{{jdkPathPrefix}}-win_x64'
          platform: 'windows'
      mainJar:
        path: 'apps/jreleaser/build/libs/jreleaser-{{projectVersion}}.jar'
      jars:
        - directory: 'apps/jreleaser/build/dependencies/flat'
          include: '*.jar'

distributions:
  # name must match!
  jreleaser-standalone:
    docker:
      # inherited by specs
      active: always
      # inherited by specs
      registries:
        - serverName: DEFAULT
      # inherited by specs
      labels:
        'org.opencontainers.image.title': 'jreleaser'
      # inherited by specs
      postCommands:
        - 'VOLUME /workspace'
      # configure 2 specs
      specs:
        slim:
          imageNames:
            - 'jreleaser/jreleaser-{{dockerSpecName}}:{{tagName}}'
            - 'jreleaser/jreleaser-{{dockerSpecName}}:latest'
          # match by platform
          matchers:
            platform: 'linux'
          preCommands:
            - 'RUN apt-get update -y'
            - 'RUN apt-get install unzip'
        alpine:
          imageNames:
            - 'jreleaser/jreleaser-{{dockerSpecName}}:{{tagName}}'
            - 'jreleaser/jreleaser-{{dockerSpecName}}:latest'
          # match by platform
          matchers:
            platform: 'linux_musl'
          preCommands:
            - 'RUN apk add unzip'

This generates two different images:

  • jreleaser/jreleaser-slim:<tag> with ubuntu:latest as base image. Packages jreleaser-standalone-<version>-linux.zip because of the matching platform.

  • jreleaser/jreleaser-alpine:<tag> with alpine:latest as base image. Packages jreleaser-standalone-<version>-linux_musl.zip because of the matching platform.

Skip Artifacts

If there is more than one matching artifact in a given distribution you may add a skipDocker extra property to the target artifact to mark it as skipped for packaging with Docker.

Templates

The default location for templates is:

src/jreleaser/distributions/<distribution-name>/docker

The default location for spec templates is:

src/jreleaser/distributions/<distribution-name>/docker/<spec>

You may place common files to all specs at

src/jreleaser/distributions/<distribution-name>/docker/ROOT

The following list shows the filenames that may be used to override default templates:

  • Dockerfile.tpl

  • Dockerfile-remote.tpl

Any additional files found in the template directories will be copied as is unless their filename ends with .tpl in which case name-templates.adoc substitution will take place.

Templates may be initialized using the template command

{icon_cli_s} template, {icon_maven_s} jreleaser:template, {icon_gradle_s} jreleaserTemplate, {icon_ant_s} jreleaser-template

Skip Templates

You may skip any template files by defining a set of skip rules in the skipTemplates property. For example, you may use any of these expressions to skip a template named README.md.tpl:

  • README.md.tpl: matches the full template name

  • README.md: matches the transformed template name

  • README.*: matches using a regex