Our setup at a glance:

• Use tools.deps to manage dependencies and build class paths
• AOT compile sources (and possibly some dependencies) to class files in classes
• Place all dependency jars in lib
• Package classes and lib in a Docker container
• Run the app with java -cp "classes:lib/*" our-app.core

It is a very simple setup that requires very little additional tooling. We use only one library on top of tools.deps, badigeon. Badigeon has a very nice bundler that can collect all kinds of dependencies supported by tools.deps for further packaging. Importantly, this helps us with git libs, which we use for internal libraries and more. Since we already have it on the classpath, we also use Badigeon's AOT compiler, which is a thin wrapper over Clojure's that provides a few niceties like ensuring that the target directory exists before putting files in it.

Now you can stage classes and jars like this:

clojure -A:build -m package

The Dockerfile uses a specific version of the relevant JDK image. Never use fleeting tags like latest for a production build - you want those to be predictable and repeatable:

FROM openjdk:11.0.2-slim

ADD target/lib/lib /app/lib
ADD target/classes /app/classes

WORKDIR /app

CMD java $JAVA_OPTS -cp "classes:lib/*" our-app.core

Externalizing JVM parameters with $JAVA_OPTS allows us to tweak runtime characteristics without building a new artifact. Here's an example of setting it from a Kubernetes deployment descriptor to configure JMX and heap memory:

containers:
  - name: our-service
    image: our.repo.com/our-app:ae31ade5ba
    env:
      - name: JAVA_OPTS
        value: "-Dcom.sun.management.jmxremote.rmi.port=9090
                -Dcom.sun.management.jmxremote=true
                -Dcom.sun.management.jmxremote.port=9090
                -Dcom.sun.management.jmxremote.ssl=false
                -Dcom.sun.management.jmxremote.authenticate=false
                -Dcom.sun.management.jmxremote.local.only=false
                -Djava.rmi.server.hostname=localhost
                -Xms128m
                -Xmx128m"

¶Tying it all together

We use a Makefile to tie everything together, so we can do things like:

make docker # AOT compiles first if sources have changed

Here's something to get you started:

VERSION:=$(shell git rev-parse --short=10 HEAD)

target:
    mkdir -p target

target/classes/our_app/core.class: deps.edn src/**/* target
    clojure -A:build -m package

build: target/classes/our_app/core.class

docker: target/classes/our_app/core.class
    docker build -t our-app:$(VERSION) .

clean:
    rm -fr target

.PHONY: build docker clean

This is a very straight-forward approach that uses little tooling, has few concepts to understand, no runtime component, and starts quickly.