Batches mit Micronaut CLA und Docker

von Tobias Kraft

In beinahe jedem Unternehmen gibt es Aufgaben, die in regelmäßigen Abständen automatisiert auszuführen sind. Aufgaben solcher Batches können zum Beispiel das Importieren von Daten oder auch die Durchführung von komplexen Berechnungen sein. In vielen Fällen ist schon eine Server-Applikation vorhanden und die Batches werden in der Server-Applikation über ein Scheduling Framework wie Quartz gesteuert.

Mit dem JVM Framework Micronaut können neben Server-Applikationen auch klassische Programme erstellt werden, die über die Kommandozeile aufgerufen werden. Dieser Applikations-Typ kann natürlich auch für die Ausführung von Batchlogik genutzt werden.

Welche Vorteile ergeben sich dadurch?

Eigenständige Programme für Batches, die nur bei Bedarf gestartet werden
Separierung der Logik von Server- und Batch-Applikationen
Bessere Skalierungsmöglichkeiten

Batches mit Micronaut

Zur Umsetzung von Programmen, die über die Kommandozeile angestoßen werden, nutzt Micronaut das Framework Picocli. Picocli stellt unter anderem Möglichkeiten zum einfachen Übergeben und Auswerten von Kommandozeilen-Parametern zur Verfügung. Die run()-Methode ist die zentrale Ausgangsbasis für die Steuerung der Programme. Den prinzipiellen Aufbau der Hauptklasse zeigt das nachfolgende Code-Snippet:

@Command(name = "dockercli", description = "some description", mixinStandardHelpOptions = true)
public class DockercliCommand implements Runnable {

    private static final Logger log = LoggerFactory.getLogger(DockercliCommand.class);

    @Value("${myconfig.value}")
    private String value;

    @Option(names = {"-v", "--verbose"}, description = "...")
    boolean verbose;

    public static void main(String[] args) throws Exception {
        PicocliRunner.run(DockercliCommand.class, args);
    }

    public void run() {
        log.info("--- start cli test batch ---");

        // put business logic here
        if (verbose) {
            log.info("This is verbose mode");
        }
        log.info("value: " + value);

        log.info("--- end cli test batch ---");
    }
}

Das Betreiben von Applikationen mithilfe von Containern, wie docker, ist weit verbreitet. Für Batch-Applikationen ist die Verwendung dieser Technologie natürlich ebenfalls eine wünschenswerte Option.

Eine mit Micronaut erstellte Applikation bringt die Unterstützung zur Generierung und Erstellung von docker Images von Haus mit. Es gibt auch andere Möglichkeiten wie beispielsweise die Nutzung von jib. Für unseren Fall werden jedoch die mitgebrachten Bord-Mittel genutzt. Wird gradle für den Build eingesetzt, kann über den Befehl ./gradlew dockerfile zunächst eine Datei Dockerfile erzeugt werden und mit ./gradlew dockerBuild erfolgt die Erstellung eines Docker Images. In unserem Fall wird die Generierung der Docker-Datei über die folgenden Einstellungen auf unsere Bedürfnisse angepasst.

dockerfile {
    baseImage("openjdk:17-alpine")
    // custom arguments for production docker file
    args("-Dmicronaut.config.files=/home/app/application.yml", "-Dlog_folder=./logs")
}

Steuerung mit cron

Nachdem die Applikation in ein Image gepackt wurde, stellt sich die Frage der Umsetzung einer zeitgesteuerten Ausführung. Im Idealfall sollte die Applikation und damit der docker-Container nur laufen, wenn er Arbeit zu verrichten hat.

Eine Möglichkeit ist die Nutzung des docker-crontab Images. Dieses Image fungiert als ein Wrapper für CronJobs, die in anderen Container ausgeführt werden. Hierfür werden in einer Konfigurationsdatei die einzelnen Jobs verwaltet. Der nachfolgende Auszug zeigt die Einstellungen zum Ausführen der Micronaut CLA Applikation.

[
  {
    "comment": "trigger every 1 minute",
    "schedule": "@every 1m",
    "command": "",
    "image": "exensio/clitest",
    "dockerargs": "--rm -v /clitest/application-prod.yml:/home/app/application.yml:rw -v /clitest/logs:/home/app/logs:rw"
  }
]

Mit der cron Syntax werden über das Attribut schedule die Ausführungszeiten definiert. Das Attribut image referenziert das auszuführende docker Image. Durch das Argument --rm in dockerargs stellen wir sicher, dass der Container sofort nach der Ausführung entfernt wird. Andernfalls sammeln sich im Laufe der Zeit zahlreiche docker Container an, die nicht mehr genutzt werden.

Zusammengefasst ergibt sich folgender Ablauf:

Der crontab Container erstellt zum Ausführungszeitpunkt aus dem für den CronJob hinterlegten docker Image einen Container, der gestartet wird.
Der gestartete Container führt wiederum die Micronaut Applikation aus
Nach der Ausführung der Applikation wird der Container gestoppt und gelöscht

Auf welche Details sollte geachtet werden?

Da der erzeugte Container zur Durchführung des CronJobs sofort nach der Ausführung wieder gelöscht wird, sind auch die Logging-Meldungen nicht mehr über den Container mit dem Befehl docker logs abrufbar. Allerdings wird der für die Steuerung zuständige docker Container nicht gelöscht und über diesen Container sind sämtliche Logging-Meldungen aller konfigurierten CronJobs verfügbar. Falls dies zu unübersichtlich wird und eine Separierung bevorzugt wird, so kann dies durch Konfiguration von klassischen Log-Dateien mithilfe von logback erfolgen.

Neben den Ausführungszeiten von Batches gibt es in der Regel weitere Parameter (z.B. Datenbankverbindung), die ohne neues Bauen der Software, angepasst werden sollten. Dies kann bei Micronaut CLA über Konfigurations-Dateien wie die application.yml erfolgen. Ein möglicher Weg ist, die Konfigurations-Datei auf dem Hostsystem abzulegen und über Docker in den Container einzuhängen.

Fazit

Die beschriebene Vorgehensweise ermöglicht es Batch-Applikationen, als kleine unabhängige Module bereitzustellen. Mit der durchgehenden Nutzung von docker können sämtliche Vorteile dieser Technologie genutzt werden.

Der Quell-Code für die einfache Demo-Applikation ist auf github einsehbar.

Zurück