Docker

Creates Docker images.

Only artifacts with .zip, .jar extension may be packaged with Docker.
Building and publishing docker images requires the docker command and a running Docker deamon. JReleaser will not install these tools.

Legend:

  • required

  • optional

  • may use environment variable

  • accepts Name Templates

  • YAML

  • TOML

  • JSON

  • Maven

  • Gradle

# 
packagers:
  # 
  docker:
    # Enables or disables Docker.
    # Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
    # Defaults to `NEVER`.
    # 
    active: ALWAYS

    # Let the release continue if the packager fails.
    # Defaults to `false`.
    # 
    continueOnError: true

    # Additional properties used when evaluating templates.
    #  
    extraProperties:
      # Key will be capitalized and prefixed with `docker`, i.e, `dockerFoo`.
      foo: bar

    # Directory with file templates used to prepare the Docker distribution.
    # Defaults to `src/jreleaser/distributions/${distribution.name}/docker`.
    # If specified, path must exist.
    # 
    templateDirectory: path/to/docker/templates

    # Git author used to commit to the repository.
    # 
    commitAuthor:
      # Name used when authoring commits.
      # Defaults to `jreleaserbot`.
      # 
      name: jreleaserbot

      # E-mail used when authoring commits.
      # Defaults to `jreleaser@kordamp.org`.
      # 
      email: jreleaser@kordamp.org

    # Git repository to push the Dockerfile to.
    # Defaults are shown.
    # 
    repository:
      # Enables or disables the repository.
      # Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
      # Defaults to `RELEASE`.
      # 
      active: ALWAYS

      # Stores files in a folder matching the image's version/tag.
      # Defaults to `false`.
      # 
      versionedSubfolders: true

      # The owner of the repository.
      # Defaults to the same owner as the release repository.
      # 
      owner: duke

      # The name of the repository.
      # Defaults to `app-docker`.
      # 
      name: app-docker

      # The target branch to use.
      # May define a `JRELEASER_DOCKER_${GIT}_BRANCH` environment variable instead.
      # Defaults to the branch pointed by HEAD.
      #  
      branch: HEAD

      # Username used for authoring commits. Must have write access to the repository.
      # If left unspecified, the `JRELEASER_DOCKER_${GIT}_USERNAME`
      # environment variable must be defined.
      # Defaults to the same username as the release repository.
      #  
      username: duke

      # Password or OAuth token with write access to the repository.
      # If left unspecified, the `JRELEASER_DOCKER_${GIT}_TOKEN`
      # environment variable must be defined.
      #  
      token: __DO_NOT_SET_HERE__

      # Message when committing to the repository.
      # If left unspecified, `{{distributionName}} {{tagName}}` will be used.
      #  
      commitMessage: '{{distributionName}} {{tagName}}'

    # The base Docker image to use.
    #  
    baseImage: "alpine:latest"

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

    # A list of build arguments.
    #  
    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.
    # 
    useLocalArtifact: true

    # Dockerfile commands to run before the assembly.
    #  
    preCommands:
      - "RUN apt-get update -y"
      - "RUN apt-get install unzip"

    # Dockerfile commands to run after the assembly, before ENTRYPOINT.
    #  
    postCommands:
      - "VOLUME /workspace"

    # A map of Docker labels.
    # 
    labels:
      foo: bar

    # A list of docker registries where images will be published.
    # Image publication will be disabled if no registries are configured.
    # 
    registries:

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

        # The address of the docker registry.
        #  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.
        #  
        username: duke

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

        # The name of the repository
        # Defaults to the same owner as the release repository.
        # 
        repositoryName: duke
# 
[packagers.docker]
  # Enables or disables Docker.
  # Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
  # Defaults to `NEVER`.
  # 
  active = "ALWAYS"

  # Let the release continue if the packager fails.
  # Defaults to `false`.
  # 
  continueOnError = true

  # Additional properties used when evaluating templates.
  #  
  extraProperties.foo = "bar"
  # Key will be capitalized and prefixed with `docker`, i.e, `dockerFoo`.

  # Directory with file templates used to prepare the Docker distribution.
  # Defaults to `src/jreleaser/distributions/${distribution.name}/docker`.
  # If specified, path must exist.
  # 
  templateDirectory = "path/to/docker/templates"

  # Git author used to commit to the repository.

  # Name used when authoring commits.
  # Defaults to `jreleaserbot`.
  # 
  commitAuthor.name = "jreleaserbot"

  # E-mail used when authoring commits.
  # Defaults to `jreleaser@kordamp.org`.
  # 
  commitAuthor.email = "jreleaser@kordamp.org"

  # Git repository to push the Dockerfile to.
  # Defaults are shown.

  # Enables or disables the repository.
  # Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
  # Defaults to `RELEASE`.
  # 
  repository.active = "ALWAYS"

  # Stores files in a folder matching the image's version/tag.
  # Defaults to `false`.
  # 
  repository.versionedSubfolders = true

  # The owner of the repository.
  # Defaults to the same owner as the release repository.
  # 
  repository.owner = "duke"

  # The name of the repository.
  # Defaults to `app-docker`.
  # 
  repository.name = "app-docker"

  # The target branch to use.
  # May define a `JRELEASER_DOCKER_${GIT}_BRANCH` environment variable instead.
  # Defaults to the branch pointed by HEAD.
  #  
  repository.branch = "HEAD"

  # Username used for authoring commits. Must have write access to the repository.
  # If left unspecified, the `JRELEASER_DOCKER_${GIT}_USERNAME`
  # environment variable must be defined.
  # Defaults to the same username as the release repository.
  #  
  repository.username = "duke"

  # Password or OAuth token with write access to the repository.
  # If left unspecified, the `JRELEASER_DOCKER_${GIT}_TOKEN`
  # environment variable must be defined.
  #  
  repository.token = "__DO_NOT_SET_HERE__"

  # Message when committing to the repository.
  # If left unspecified, `{{distributionName}} {{tagName}}` will be used.
  #  
  repository.commitMessage = "{{distributionName}} {{tagName}}"

  # The base Docker image to use.
  #  
  baseImage = "alpine:latest"

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

  # A list of build arguments.
  #  
  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.
  # 
  useLocalArtifact = true

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

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

  # A map of Docker labels.
  # 
  labels.foo = "bar"

  # A list of docker registries where images will be published.
  # Image publication will be disabled if no registries are configured.
  # 
  [[packagers.docker.registries]]
    # The name of the registry. Must be unique.
    # Use `DEFAULT` to match the default registry
    # provided by the Docker daemon.
    # 
    serverName = "myRegistry"

    # The address of the docker registry.
    #  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.
    #  
    username = "duke"

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

    # The name of the repository
    # Defaults to the same owner as the release repository.
    # 
    repositoryName = "duke"
{
  // 
  "packagers": {
    // 
    "docker": {
      // Enables or disables Docker.
      // Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
      // Defaults to `NEVER`.
      // 
      "active": "ALWAYS",

      // Let the release continue if the packager fails.
      // Defaults to `false`.
      // 
      "continueOnError": true,

      // Additional properties used when evaluating templates.
      //  
      "extraProperties": {
        // Key will be capitalized and prefixed with `docker`, i.e, `dockerFoo`.
        "foo": "bar"
      },

      // Directory with file templates used to prepare the Docker distribution.
      // Defaults to `src/jreleaser/distributions/${distribution.name}/docker`.
      // If specified, path must exist.
      // 
      "templateDirectory": "path/to/docker/templates",

      // Git author used to commit to the repository.
      // 
      "commitAuthor": {
        // Name used when authoring commits.
        // Defaults to `jreleaserbot`.
        // 
        "name": "jreleaserbot",

        // E-mail used when authoring commits.
        // Defaults to `jreleaser@kordamp.org`.
        // 
        "email": "jreleaser@kordamp.org"
      },

      // Git repository to push the Dockerfile to.
      // Defaults are shown.
      // 
      "repository": {
        // Enables or disables the repository.
        // Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
        // Defaults to `RELEASE`.
        // 
        "active": "ALWAYS",

        // Stores files in a folder matching the image's version/tag.
        // Defaults to `false`.
        // 
        "versionedSubfolders": true,

        // The owner of the repository.
        // Defaults to the same owner as the release repository.
        // 
        "owner": "duke",

        // The name of the repository.
        // Defaults to `app-docker`.
        // 
        "name": "app-docker",

        // The target branch to use.
        // May define a `JRELEASER_DOCKER_${GIT}_BRANCH` environment variable instead.
        // Defaults to the branch pointed by HEAD.
        //  
        "branch": "HEAD",

        // Username used for authoring commits. Must have write access to the repository.
        // If left unspecified, the `JRELEASER_DOCKER_${GIT}_USERNAME`
        // environment variable must be defined.
        // Defaults to the same username as the release repository.
        //  
        "username": "duke",

        // Password or OAuth token with write access to the repository.
        // If left unspecified, the `JRELEASER_DOCKER_${GIT}_TOKEN`
        // environment variable must be defined.
        //  
        "token": "__DO_NOT_SET_HERE__",

        // Message when committing to the repository.
        // If left unspecified, `{{distributionName}} {{tagName}}` will be used.
        //  
        "commitMessage": "{{distributionName}} {{tagName}}"
      },

      // The base Docker image to use.
      //  
      "baseImage": "alpine:latest",

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

      // A list of build arguments.
      //  
      "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.
      // 
      "useLocalArtifact": true,

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

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

      // A map of Docker labels.
      // 
      "labels": {
        "foo": "bar"
      },

      // A list of docker registries where images will be published.
      // Image publication will be disabled if no registries are configured.
      // 
      "registries": [

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

          // The address of the docker registry.
          //  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.
          //  
          "username": "duke",

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

          // The name of the repository
          // Defaults to the same owner as the release repository.
          // 
          "repositoryName": "duke"
        }
      ]
    }
  }
}
<jreleaser>
  <!--
    
  -->
  <packagers>
    <!--
      
    -->
    <docker>
      <!--
        Enables or disables Docker.
        Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
        Defaults to `NEVER`.
        
      -->
      <active>ALWAYS</active>

      <!--
        Let the release continue if the packager fails.
        Defaults to `false`.
        
      -->
      <continueOnError>true</continueOnError>

      <!--
        Additional properties used when evaluating templates.
         
      -->
      <extraProperties>
        <!--
          Key will be capitalized and prefixed with `docker`, i.e, `dockerFoo`.
        -->
        <foo>bar</foo>
      </extraProperties>

      <!--
        Directory with file templates used to prepare the Docker distribution.
        Defaults to `src/jreleaser/distributions/${distribution.name}/docker`.
        If specified, path must exist.
        
      -->
      <templateDirectory>path/to/docker/templates</templateDirectory>

      <!--
        Git author used to commit to the repository.
        
      -->
      <commitAuthor>

        <!--
           Name used when authoring commits.
          Defaults to `jreleaserbot`.
          
        -->
        <name>jreleaserbot</name>

        <!--
          E-mail used when authoring commits.
          Defaults to `jreleaser@kordamp.org`.
          
        -->
        <email>jreleaser@kordamp.org</email>
      </commitAuthor>

      <!--
        Git repository to push the Dockerfile to.
        Defaults are shown.
        
      -->
      <repository>
        <!--
          Enables or disables the repository.
          Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
          Defaults to `RELEASE`.
          
        -->
        <active>ALWAYS</active>

        <!--
          Stores files in a folder matching the image's version/tag.
          Defaults to `false`.
          
        -->
        <versionedSubfolders>true</versionedSubfolders>

        <!--
          The owner of the repository.
          Defaults to the same owner as the release repository.
          
        -->
        <owner>duke</owner>

        <!--
          The name of the repository.
          Defaults to `app-docker`.
          
        -->
        <name>app-docker</name>

        <!--
          The target branch to use.
          May define a `JRELEASER_DOCKER_${GIT}_BRANCH`` environment variable instead.
          Defaults to the branch pointed by HEAD.
           
        -->
        <branch>HEAD</branch>

        <!--
          Username used for authoring commits. Must have write access to the repository.
          If left unspecified, the `JRELEASER_DOCKER_${GIT}_USERNAME`
          environment variable must be defined.
          Defaults to the same username as the release repository.
           
        -->
        <username>duke</username>

        <!--
          Password or OAuth token with write access to the repository.
          If left unspecified, the `JRELEASER_DOCKER_${GIT}_TOKEN`
          environment variable must be defined.
           
        -->
        <token>__DO_NOT_SET_HERE__</token>

        <!--
          Message when committing to the repository.
          If left unspecified, `{{distributionName}} {{tagName}}` will be used.
           
        -->
        <commitMessage>{{distributionName}} {{tagName}}</commitMessage>
      </repository>

      <!--
        The base Docker image to use.
         
      -->
      <baseImage>alpine:latest</baseImage>

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

      <!--
        A list of build arguments.
         
      -->
      <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.
        
      -->
      <useLocalArtifact>true</useLocalArtifact>

      <!--
        Dockerfile commands to run before the assembly.
         
      -->
      <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.
         
      -->
      <postCommands>
        <postCommand>VOLUME /workspace</postCommand>
      </postCommands>

      <!--
        A map of Docker labels.
        
      -->
      <labels>
        <foo>bar</foo>
      </labels>

      <!--
        A list of docker registries where images will be published.
        Image publication will be disabled if no registries are configured.
        
      -->
      <registries>
        <registry>
          <!--
             The name of the registry. Must be unique.
             Use `DEFAULT` to match the default registry
             provided by the Docker daemon.
             
          -->
          <serverName>myRegistry</serverName>

          <!--
            The address of the docker registry.
             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.
             
          -->
          <username>duke</username>

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

          <!--
            The name of the repository
            Defaults to the same owner as the release repository.
            
          -->
          <repositoryName>duke</repositoryName>
        </registry>
      </registries>
    </docker>
  </packagers>
</jreleaser>
jreleaser {
  // 
  packagers {
    // 
    docker {
      // Enables or disables Docker.
      // Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
      // Defaults to `NEVER`.
      // 
      active = 'ALWAYS'

      // Let the release continue if the packager fails.
      // Defaults to `false`.
      // 
      continueOnError = true

      // Additional properties used when evaluating templates.
      // Key will be capitalized and prefixed with `docker`, i.e, `dockerFoo`.
      //  
      extraProperties.put('foo', 'bar')

      // Directory with file templates used to prepare the Docker distribution.
      // Defaults to `src/jreleaser/distributions/${distribution.name}/docker`.
      // If specified, path must exist.
      // 
      templateDirectory = 'path/to/docker/templates'

      // Git author used to commit to the repository.
      // 
      commitAuthor {
        // Name used when authoring commits.
        // Defaults to `jreleaserbot`.
        // 
        name = 'jreleaserbot'

        // E-mail used when authoring commits.
        // Defaults to `jreleaser@kordamp.org`.
        // 
        email = 'jreleaser@kordamp.org'
      }

      // Git repository to push the Dockerfile to.
      // Defaults are shown.
      // 
      repository {
        // Enables or disables the repository.
        // Valid values are [`NEVER`, `ALWAYS`, `RELEASE`, `SNAPSHOT`].
        // Defaults to `RELEASE`.
        // 
        active = 'ALWAYS'

        // Stores files in a folder matching the image's version/tag.
        // Defaults to `false`.
        // 
        versionedSubfolders = true

        // The owner of the repository.
        // Defaults to the same owner as the release repository.
        // 
        owner = 'duke'

        // The name of the repository.
        // Defaults to `app-docker`.
        // 
        name = 'app-docker'

        // The target branch to use.
        // May define a `JRELEASER_BRANCH` environment variable instead.
        // Defaults to the branch pointed by HEAD.
        //  
        branch = 'HEAD'

        // Username used for authoring commits. Must have write access to the repository.
        // If left unspecified, the `JRELEASER_DOCKER_${GIT}_USERNAME`
        // environment variable must be defined.
        // Defaults to the same username as the release repository.
        //  
        username = 'duke'

        // Password or OAuth token with write access to the repository.
        // If left unspecified, the `JRELEASER_DOCKER_${GIT}_TOKEN`
        // environment variable must be defined.
        //  
        token = '__DO_NOT_SET_HERE__'

        # Message when committing to the repository.
        # If left unspecified, `{{distributionName}} {{tagName}}` will be used.
        #  
        commitMessage = '{{distributionName}} {{tagName}}'
      }

      // The base Docker image to use.
      //  
      baseImage = 'alpine:latest'

      // A list of image names.
      // If unspecified, a single image `{{repoOwner}}/{{distributionName}}:{{tagName}}`
      // will be created.
      //  
      addImageName('{{repoOwner}}/{{distributionName}}:{{tagName}}')
      addImageName('duke/app:latest')

      // A list of build arguments.
      //  
      addBuildArg('--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.
      // 
      useLocalArtifact = true

      // Dockerfile commands to run before the assembly.
      //  
      addPreCommand('RUN apt-get update -y')
      addPreCommand('RUN apt-get install unzip')

      // Dockerfile commands to run after the assembly, before ENTRYPOINT.
      //  
      addPostCommand('VOLUME /workspace')

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

      // A list of docker registries where images will be published.
      // Image publication will be disabled if no registries are configured.
      // 
      registries {

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

          // The address of the docker registry.
          //  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.
          //  
          username = 'duke'

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

          // The name of the repository
          // Defaults to the same owner as the release repository.
          // 
          repositoryName = 'duke'
        }
      }
    }
  }
}

Template files may be initialized using the template command.

The repository token environment variable must match with the chosen Release service, that is, it must be one of [JRELEASER_DOCKER_GITHUB_TOKEN, JRELEASER_DOCKER_GITLAB_TOKEN, JRELEASER_DOCKER_GITEA_TOKEN].

Assuming that 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 Name Templates 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

  • TOML

  • JSON

  • Maven

  • Gradle

project:
  name: app

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

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

  "packagers": {
    "docker": {
      "active": "ALWAYS",
      "imageNames": [
        "myuser/{{projectName}}"
      ]
    }
  }
}
<!-- project.artifactId = app -->
<jreleaser>
  <packagers>
    <docker>
      <active>ALWAYS</active>
      <imageNames>
        <imageName>myuser/{{projectName}}</imageName>
      </imageNames>
    </docker>
  </packagers>
</jreleaser>
// project.name = app
jreleaser {
  packagers {
    docker {
      active = 'ALWAYS'
      addImageName('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

  • TOML

  • JSON

  • Maven

  • Gradle

project:
  name: app

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

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

  "packagers": {
    "docker": {
      "active": "ALWAYS",
      "imageNames": [
        "myuser/myimage:{{tagName}}",
        "myuser/myimage:v{{projectVersionMajor}}",
        "myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}",
        "myuser/myimage:latest"
      ]
    }
  }
}
<!-- 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>
// project.name = app
jreleaser {
  packagers {
    docker {
      active = 'ALWAYS'
      addImageName('myuser/myimage:{{tagName}}')
      addImageName('myuser/myimage:v{{projectVersionMajor}}')
      addImageName('myuser/myimage:v{{projectVersionMajor}}.{{projectVersionMinor}}')
      addImageName('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:
  jlinks:
    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.

Templates

The default location for templates is:

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

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 substitution will take place.

Templates may be initialized using the template command