Various operational processes are mapped and orchestrated using shell scripts. However, this approach does not allow to easily trace the process flows and thus makes it difficult to track errors. So far, the PTA has supported the client in mapping the processes as a BPMN model using Signavio to provide a better understanding of the processes. The next step is to orchestrate and track processes using Camunda to gradually replace the shell scripts. For this purpose, the PTA is working on a showcase with Camunda 8 in which the creation of a user and the associated connections to internal systems and databases are tested.
The Camunda BPMN Workflow Engine enables processes that are modelled in BPMN to be orchestrated. The Camunda engine is implemented in Java and is provided via SaaS or self-hosted. For the showcase, Camunda is started via Docker. This reduces the deployment effort as the configurations provided by Camunda can be used as a starting point. In addition to orchestration, Camunda 8 offers a graphical user interface. This offers among other things a task list as well as an interface for starting, stopping and tracking individual processes. Thus both, running and completed instances can be evaluated. PTA is working on setting up Camunda 8 on a customer VM. Java workers are implemented, which connect to the Camunda engine via HTTP, e.g. to send error messages to the orchestration. Thus, orchestration and individual tasks are separated from each other.
The chosen process user creation makes it necessary to interact with various servers and databases. Currently, this is done by calling shell scripts. In the first step, the orchestration of the script calls is implemented in Camunda, the individual scripts remain unchanged. The corresponding worker calls the scripts on the corresponding servers via SSH. In the next step, the scripts are divided into individual sub-steps, but remain stored as shell scripts. This division makes it easier to follow the course of a single process in Camunda. In the third step, the sub-processes are implemented in Java code and the shell scripts are replaced. Now it is possible to interact with the Camunda engine after each step and, for example, catch errors in time or use global variables across processes. This increases the traceability of the processes.