Camunda modeler инструкция на русском

Основная работа по созданию и редактированию схем бизнес-процессов в системе Camunda производится средствами приложения Camunda Modeler. Это приложение является бесплатным и его можно просто скачать с сайта Camunda в любом из трех вариантов:

• под Windows (поддерживаются Windows 7/8/10, как 32-разрядные, так и 64-разрядные)
• MacOSX (версия 10.11 и более поздние)
• Ubuntu (версия 12.04 и более поздние). На других дистрибутивах Linux, таких, как Fedora и Debian, CamundaModeler тоже запускаться не отказывается. В CentOS 8 для запуска CamundaModeler потребовалась предварительная установка пакета libXScrnSaver-1.2.3-1.el8.x86_64.rpm.

Camunda Modeler не требует установки: в любой операционной системе достаточно разархивировать скачанный архив, а затем запустить ее при помощи соответствующего файла:

• в Windows— при помощи Camunda Modeler.exe;
• в Mac OS — при помощи Camunda Modeler.app;
• в Linux — при помощи файла camunda-modeler (для новичков в Linux — нужно перейти в каталог с этим файлом и выполнить команду ./camunda-modeler).

Под какой операционной системой вы бы не запустили Camunda Modeler, интерфейс и функциональные возможности этой программы будут одинаковы. Окно Camunda Modeler с простейшей диаграммой BPMN может выглядеть так, как представлено на рис.

Посмотрим на интерфейс Camunda Modeler внимательнее.

Вверху — обычное меню, при этом при помощи команды File | New File или аналогичной кнопки на панели инструментов у нас есть возможность создать диаграмму одного из четырех поддерживаемых типов:

• BPMN (Business Process Management Notation)— наиболее распространенный тип диаграмм, описывающий стандартизированные бизнес-процессы. В качестве примера можно, например, привести заведение нового поставщика у ритейлера со сбором необходимых документов или процесс утверждения заявки на кредит;
• CMMN (Case Management Model and Notation)— тип диаграммы для обработки кейсов (ситуаций). Стандарт CMMN во многом похож на BPMN (и отчасти взаимозаменяем). Обычно он используется тогда, когда на бизнес-процесс могут сильно влиять различные внешние факторы и нужен более гибкий подход (и с большим влиянием факторов внешней среды), чем в BPMN. В качестве примера можно привести, например, производственное предприятие, которое делает изделие под заказ. Это предприятие может принять один и тот же заказ от одного и того же заказчика, а может и не принять, если считает, что оборудование потребуется под более выгодные заказы. А может, наоборот, принять невыгодный заказ, чтобы установить отношения с важным заказчиком в надежде на получение более крупных заказов;
• DMN (Decision Making and Notation)— тип диаграммы (или таблицы), который используется для поддержки принятия решений. Можно считать этот тип диаграмм дополнением к BPMN, которое позволяет не перегружать диаграммы BPMN огромным количеством шлюзов. Представим, например, бизнес-процесс по одобрению кредитной заявки на потребительский кредит. В BPMN можно очень удобно нарисовать схему прохождения документов, но на этапе утверждения кредита кредитным инспектором ему нужно принять во внимание множество факторов: текущую кредитную нагрузку, кредитную нагрузку членов семьи, кредитную историю, уровень заработной платы, место работы и т.п. Если все эти факторы попытаться разместить при помощи шлюзов на диаграмме BPMN, то диаграмма выйдет очень сложной и перегруженной. Поэтому практичнее моменты, связанные с принятием решений, вынести в отдельную диаграмму или таблицу DMN.

CMMN и DMN — инструменты относительно новые и применяются на предприятиях редко, поэтому в большинстве случаев когда речь идет об описании бизнес-процессов, имеются ввиду именно диаграммы BPMN. Поэтому возможности Camunda мы будем рассматривать в основном применительно к BPMN.

Чтобы можно было рассмотреть возможности интерфейса Camunda, в меню File | New File выберем BPMN Diagram.

Диаграммы в Camunda Modeler можно просматривать в двух режимах: в обычном графическом режиме диаграммы и в режиме XML. Переключение между этими режимами производится при помощи ярлычков в нижнем левом углу (см. рис.)

Стандарт BPMN 2.0 описывает не только графические элементы для диаграмм BPMN, но и их представление в формате XML (хотя в разных редакторах диаграмм BPMN могут использоваться свои дополнительные элементы и атрибуты, которые другими редакторами будут игнорироваться). Поэтому, если у вас есть диаграммы BPMN, подготовленные в другом редакторе, в большинстве ситуаций их вполне возможно перенести в Camunda Modeler.

Иногда приходится вносить изменения вручную прямо в код XML для диаграммы, но это требуется нечасто (и, по возможности, конечно, нужно этого избегать).

На Панели инструментов обратим внимание на кнопку Deploy Current Diagram (Развернуть текущую диаграмму) — см. рис.

Эта кнопка позволяет поместить диаграмму на сервер Camunda (тестовый или производственный) прямо из Camunda Modeler. При нажатии на нее откроется окно, аналогичное представленному на рис.

Конечно, можно пойти и обходным путем: сохранить диаграмму в файле формата BPMN и уже потом выложить ее на сервер, но выгрузка напрямую обычно удобнее.

Диаграмму можно сохранить и в графических форматах PNG/JPEG/SVG, если, например, вам потребовалось распечатать схему сложного бизнес-процесса для обсуждения.

В левой части Camunda Modeler находится Палитра элементов (Elements palette) — см. рис.

Разработчики диаграмм BPMN обычно берут элементы из этой палитры, перетаскивают в область диаграммы (центральную область окна Camunda Modeler) и настраивают. Заметим, что элементов, на первый взгляд, в палитре существенно меньше, чем предусмотрено стандартом BPMN. Связано это с тем, что в палитре присутствует лишь базовый набор элементов: другие элементы получаются из базовых путем преобразования их в области диаграммы. Например, в нашей диаграмме преобразовать стартовое событие в событие-сообщение можно так, если щелкнуть по объекту стартового события, нажать в контекстном наборе фигур на гаечный ключ и в списке типов сообщений выбрать Message Start Event (см. рис.).

Из этого же контекстного набора фигур очень удобно выбрать следующий элемент бизнес-процесса, вместо того, чтобы перетягивать его из палитры и затем связывать.

Пользовательских элементов в Camunda Modeler не предусмотрено. Их функциональность можно реализовывать при помощи шаблонов элементов/связанных классов Java (про эти возможности будет рассказано в следующих разделах). Можно также воспользоваться бесплатной альтернативой Camunda Modeler, которая называется BPMN.IO и в которой пользовательские элементы предусмотрены изначально.

Мастерство создателя диаграмм BPMN во многом заключается в том, насколько правильно он выбирает и расставляет элементы палитры (а также настраивает их свойства). Про работу с элементами диаграмм BPMN будет рассказано в следующих разделах.

В центральной части окна Camunda Modeler расположена сама диаграмма. Реальные рабочие процессы могут очень большими по размеру и включать в себя большое количество элементов, поэтому для комфортной работы разработчику бизнес-процессов рекомендуется большой монитор (а лучше — несколько). Чуть упростить навигацию по диаграмме позволит мини-карта (Minimap), кнопка для включения которой расположена в правом верхнем углу окна диаграммы.

В правой части окна Camunda Modeler расположена Панель свойств (Properties Panel) — см. рис.

В этом окне производится настройка свойств как самого процесса BPMN, так и его элементов.

Обычная последовательность работы с процессами BPMN (CMMN, DMN) в Camunda Modeler выглядит следующим образом:

1. Средствами Camunda Modeler создаем новый процесс (диаграмму BPMN) и настраиваем его свойства.
2. Размещаем на этой диаграмме элементы, меняем типы, связываем элементы.
3. Настраиваем свойства элементов (на этом этапе производится привязка программного кода и форм к элементам).
4. Публикуем процесс на тестовом сервере и запускаем его для проверки работоспособности (из самого Camunda Modeler запустить процесс, увы, нельзя).
5. Выявляем проблемы и вносим изменения в процесс. Чтобы не возникало ситуаций вида «починил одно — в результате отвалилось другое», очень рекомендуется использовать юнит-тесты.
6. Публикуем окончательную версию процесса на производственном сервере, предоставляем пользователям разрешения на этот процесс и интерфейс для его запуска.

Все эти моменты будут рассмотрены в следующих разделах.

Camunda — это отличный бесплатный BPM-движок для автоматизации бизнес-процессов. В этой статье я расскажу как по шагам сделать первую заготовку проекта с использованием языка Kotlin и Camunda. Уровень сложности материала низкий — статья снабжена скриншотами и видеоверсией. Вам нужно просто пройти по инструкции.

Вот видеоверсия статьи, кому-то может быть удобнее:

Как вообще можно использовать Camunda

Camunda можно использовать в двух вариантах:

• Standalone-сервер — в этом случае вы ставите приложение с сервером отдельно и заливаете на него свои процессы с помощью .war-файлов. База общая, исполнители задач общие, админка общая.

Я разбирал такой вариант подробно на видео.

• Библиотека внутри приложения — в этом случае вы разрабатывает обычное Java-приложение (в нашем случае Kotlin), и в зависимостях указываете Camunda. База своя, задачи свои, админка своя, исполнители свои.

Первый вариант удобнее для эксплуатации — следить нужно только за одной базой и одной камундой, но создает проблему “шумных соседей” — если кто-то из коллег сделает кривой процесс, то лягут все.

Второй способ удобнее полной независимостью, но создает сложности в администрировании и управлении задачами. Какой вариант выбирать каждая компания сама решает, но я за второй: все проблемы решаются, а вот в первом с шумными соседями ничего не сделать. И это ОЧЕНЬ больно и неприятно на проде, когда вы начинаете падать из-за коллег.

Предварительная подготовка рабочего места

Для создания первого проекта на Camunda вам потребуется:

• Среда разработки — IntelliJ Idea (https://www.jetbrains.com/idea/download/#section=windows). В этой штуке мы будем программировать.
• Сама Java — https://java.com/ru/download/ . Эта штука позволит среде разработки понять, что мы написали и обьяснить компьютеру.
• Postgresql https://www.postgresql.org/download/windows/ . Это база данных, Camunda будет сохранять туда информацию о всём происходящем.
• Excamad — https://github.com/KotskinKotskin/camunda-excamad/releases . Это дополнительная админка, которая позволит нам лучше понимать что происходит в Camunda.
• Camunda modeler — https://camunda.com/products/modeler/ . Эта штука поможет нам создавать диаграммы в BPMN и решения в DMN.

Поставьте всё себе на компьютер,сложностей не должно возникнуть. Если возникли, то пишите в комментарии, разберемся.

Почему Kotlin и Spring(boot)

Вместо Java мы будем использовать язык Kotlin — это статически типизированный язык программирования, работающий поверх JVM. Он более лаконичный и безопасный, чем Java. И порог входа в него немного ниже, что в этом случае нам очень важно.

Еще мы будем использовать Spring — это набор библиотек для Java, которые делают жизнь проще. А Spring boot — это еще одна штука, которая делает жизнь разработчика со Spring еще проще 🙂 В ообщем, программерская магия, которая не имеет отношения к статье.

Создаем приложение

1. Создаем приложение —  воспользуемся сайтом https://start.spring.io/, он сформирует для нас структуру проекта и добавит нужные зависимости. Установите такие параметры:
2. Скачиваем  папку с приложением.
3. Запускаем IDEA и откройте в ней папку с приложением:
   В параметрах укажите что разрешаете авто-импорт зависимостей.
4. Создаем базу данных в postgres: запустите приложение PgAdmin, войдите в него с логином и паролем, которое указывали при установке.Подключитесь к локальному серверу и создайте базу camundabpmn2
5. Указываем данные для подключения к базе в файле application.properties
   
   

logging.level.org.springframework.web=DEBUG
spring.datasource.url=jdbc:postgresql://localhost/camundabpmn2
spring.datasource.username=postgres
spring.datasource.password=mypassword
spring.jpa.generate-ddl=true
spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true

Вы получили работающее приложение, давайте проверим что всё ок. Запустите его:Переходим по адресу в браузере http://localhost:8080. Если вы видите такую картину, то вы красавчик! У вас есть пустое работающее spring приложение.

Запускаем пустую Camunda

Для запуска камунды нам нужно добавить зависимости в файл pom.xml. В этом файле хранится информация о том, какие внешние библиотеки мы используем. Добавим много библиотек — для тестирования, логирования, саму Camunda, REST интерфейсы, работа c JSON. За что отвечает каждая из библиотек понятно из названия. В итоге раздел в pom.xml должен выглядеть так:

<dependencies>
  <dependency>
    <groupId>io.github.microutils</groupId>
    <artifactId>kotlin-logging</artifactId>
    <version>1.6.24</version>
  </dependency>
  <dependency>
    <groupId>org.camunda.bpm.springboot</groupId>
    <artifactId>camunda-bpm-spring-boot-starter-webapp</artifactId>
    <version>3.2.0</version>
  </dependency>
  <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-csv</artifactId>
    <version>1.6</version>
  </dependency>
  <dependency>
    <groupId>org.camunda.bpm.springboot</groupId>
    <artifactId>camunda-bpm-spring-boot-starter-rest</artifactId>
    <version>3.2.0</version>
  </dependency>
  <dependency>
    <groupId>org.camunda.bpm.extension.springboot</groupId>
    <artifactId>camunda-bpm-spring-boot-starter-test</artifactId>
    <version>2.2.0</version>
  </dependency>
  <dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>2.6.0</version>
  </dependency>

  <dependency>
    <groupId>org.camunda.bpm.assert</groupId>
    <artifactId>camunda-bpm-assert</artifactId>
    <version>3.0.0-alpha1</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.camunda.bpm.assert</groupId>
    <artifactId>camunda-bpm-assert</artifactId>
    <version>3.0.0</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.camunda.spin</groupId>
    <artifactId>camunda-spin-dataformat-json-jackson</artifactId>
    <version>1.6.7</version>
  </dependency>
  <dependency>
    <groupId>org.camunda.spin</groupId>
    <artifactId>camunda-spin-core</artifactId>
    <version>1.6.7</version>
  </dependency>
  <dependency>
    <groupId>org.camunda.bpm</groupId>
    <artifactId>camunda-engine-plugin-spin</artifactId>
    <version>7.10.0</version>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>com.fasterxml.jackson.module</groupId>
    <artifactId>jackson-module-kotlin</artifactId>
  </dependency>
  <dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-reflect</artifactId>
  </dependency>
  <dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-stdlib-jdk8</artifactId>
  </dependency>

  <dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

Ждём, пока скачаются все зависимости (полоска в правом нижнем углу).

• В главный класс дописываем аннотацию @EnableProcessApplication

• Добавляем проект excamad в папку static, для того чтобы заработала моя дополнительная админка
• Запускаем приложение, перейдем по ссылке http://localhost:8080/. Если видим приглашение зарегистрироваться, делаем учетную запись demo/ demo
• Заходим по ссылке http://localhost:8080/index.html, видим котиков — значит excamad работает. В разделе settings пропишем http://localhost:8080/rest/

Если вы сделали всё правильно, то у вас готова чистая Camunda на Kotlin. Теперь её можно наполнять вашими бизнес-процессами, этим займемся в других статьях.

В итоге

Как вы видите, сделать подготовительную работу  для последующей автоматизации на Camunda совсем не сложно. Проще, чем развернуть кластер IBM BPM. У вас получилось? Напишите о вашем опыте в статье.

Продолжение статьи.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

ТэгиCamunda

Вам так же понравится

Время на прочтение
7 мин

Количество просмотров 18K

Привет, Хабр! Представляю вашему вниманию перевод статьи «Use Camunda as an easy-to-use REST-based orchestration and workflow engine (without touching Java)» автора Bernd Rücker.

07.07.2020 г., перевод статьи Bernd Rücker

Я часто обсуждаю микросервисную архитектуру с людьми, далекими от Java: разработчиками C#, Node.JS/JavaScript или приверженцами Golang. Все они сталкиваются с тем, что им нужен механизм оркестровки в микросервисной архитектуре или просто инструмент для оптимизации рабочего процесса и получения возможности упорядочения, обработки тайм-аутов, Saga и компенсирующих транзакций.

BPM-платформа с открытым исходным кодом от Camunda отлично подходит для таких задач. Дружелюбие по отношению к разработчику — одна из ключевых особенностей продукта. Но если взглянуть на его документацию, может сложиться впечатление, что в основном «дружелюбие» Camunda направлено на Java-разработчиков. Платформа предоставляет множество возможностей для подключения собственных функций и расширений, но все это делается на Java. Так ли это на самом деле?

Нет! На самом деле, можно легко запустить Camunda без каких-либо знаний Java и настроить архитектуру для кода на любом языке, по вашему выбору. В этой статье мы рассмотрим:

• базовую архитектуру;
• REST API;
• советы по существующим клиентским библиотекам для языков, отличных от Java;
• пример использования C # и Node.JS;
• способы запуска сервера Camunda (Docker или Tomcat).

Архитектура

Camunda написана на Java и для запуска нуждается в виртуальной машине Java (JVM). Camunda предоставляет REST API, который позволяет вам писать на любом языке, который вам нравится, и использовать REST с Camunda:

Рабочие процессы в Camunda определяются в BPMN, который в основном представляет собой XML-файл. Его можно смоделировать с помощью Camunda Modeler.

Запуск Camunda через предварительно созданный образ Docker

Самый простой способ запустить Camunda — это использовать Docker. Альтернативные способы запуска Camunda описаны далее в этой статье.

В этом случае достаточно просто запустить:

  docker run -d -p 8080:8080 camunda/camunda-bpm-platform:latest

Вам не нужно волноваться о Linux, виртуальных машинах Java или Tomcats. Dockerfiles и основная документация (например, инструкция по подключению к нужным базам данных) доступны на Github.

Если вы хотите запустить Camunda Enterprise Edition, вы можете легко изменить Dockerfile.

Однако у запуска Camunda с помощью Docker есть один недостаток: вы получите версию Tomcat, которая не всегда включает последние исправления. Чтобы как-то обойти это, вы можете самостоятельно создать Docker-образ на основе нужного дистрибутива Tomcat, как показано в этом примере, либо воспользоваться одним из решений, описанных ниже.

Развертывание модели процесса

Давайте рассмотрим пример, используя шаблон Saga для классического бронирования поездок, где вы хотите вызвать три действия подряд и корректно компенсировать успешно выполненные действия в случае более позднего сбоя. Представленный в форме BPMN он выглядит следующим образом:

Теперь вы можете использовать REST API для развертывания модели процесса. Предположим, вы сохранили его с именем trip.bpmn и запустили Camunda через Docker, чтобы он был доступен на localhost: 8080:

  curl -w "\n" \
-H "Accept: application/json" \
-F "deployment-name=trip" \
-F "enable-duplicate-filtering=true" \
-F "deploy-changed-only=true" \
-F "trip.bpmn=@trip.bpmn" \
http://localhost:8080/engine-rest/deployment/creat

Теперь вы можете запускать новые экземпляры рабочего процесса с помощью REST API и передавать данные, которые вы хотите видеть в качестве переменных экземпляра рабочего процесса:

  curl \
-H "Content-Type: application/json" \
-X POST \
-d '{"variables":{"someData" : {"value" : "someValue", "type": "String"}},"businessKey" : "12345"}}' \
http://localhost:8080/engine-rest/<!-- -->process-definition/key/<!-- -->FlowingTripBookingSaga<!-- -->/start

Следующий интересный вопрос: как Camunda вызывает процедуры, подобные бронированию автомобиля? Camunda может не только сразу вызывать сервисы (Push-Principle), используя некоторые встроенные коннекторы, но и помещать рабочие элементы в своего рода встроенную очередность. После чего worker может получить рабочие элементы через REST, выполнить работу и сообщить Camunda о завершении (Pull-Principle).

Итак, сначала вам нужно выполнить fetchAndLock (поскольку другие worker могут получать задачи одновременно для масштабирования системы):

  curl \
-H "Content-Type: application/json" \
-X POST \
-d <!-- -->'{"workerId":"worker123","maxTasks":1,"usePriority":true,"topics":[{"topicName": "reserve-car"}, "lockDuration": 10000, "variables": ["someData"]}]}'<!-- --> \
http://localhost:8080/engine-rest/external-task/fetchAndLock

Затем сообщите Camunda, что worker завершил работу (обратите внимание, что вы должны ввести идентификатор external task, полученный в первом запросе):

  curl \
-H "Content-Type: application/json" \
-X POST \
-d <!-- -->'{"workerId":"worker123", "variables": {}}'<!-- --> \
http://localhost:8080/engine-rest/<!-- -->external-task/EXTERNAL_TASK_ID/complete

Вот и все — вам до сих пор не потребовалось никакой Java, верно? И этого достаточно для начала работы!

Клиентские библиотеки

Вызвать REST API легко в любом языке программирования. В JavaScript это удобно делать с помощью JQuery, а в C# — задействовать System.Net.Http и Newtonsoft.Json. Но на это потребуется время. Поэтому вы можете просто воспользоваться какой-нибудь клиентской библиотекой.

На данный момент доступно несколько готовых клиентских библиотек:

• JavaScript: ссылка. Поддерживается Camunda;
• Java: ссылка. Поддерживается Camunda;
• C#:ссылка и ссылка. Оба этих проекта находятся в промежуточном состоянии и практически бездействуют, но могут послужить хорошей отправной точкой;
• PHP: ссылка — не слишком полная и не включающая последние изменения API библиотека, но я знаю проекты, использующие её.

За исключением JavaScript и Java, клиентские библиотеки не являются частью самого продукта Camunda. Не ожидайте, что они будут поддерживать все возможности REST API Camunda. Если библиотека не предоставляет определенной функции, это не значит, что ее там нет, всегда проверяйте REST API Camunda. Типовые проекты используют библиотеки в качестве отправной точки и шаблона.

Пример с C#

Используя указанную выше клиентскую библиотеку, мы можем просто написать:

  var camunda = new CamundaEngineClient("http://localhost:8080/engine-rest/engine/default/", null, null);
  // Deploy the BPMN XML file from the resources
  camunda.RepositoryService.Deploy("trip-booking", new List<object> {
        FileParameter.FromManifestResource(Assembly.GetExecutingAssembly(), "FlowingTripBookingSaga.Models.FlowingTripBookingSaga.bpmn")
     });
  
  // Register workers
  registerWorker("reserve-car", externalTask => {
    // here you can do the real thing! Like a sysout :-)
    Console.WriteLine("Reserving car now...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  registerWorker("cancel-car", externalTask => {
    Console.WriteLine("Cancelling car now...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  registerWorker("book-hotel", externalTask => {
    Console.WriteLine("Reserving hotel now...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  // Register more workers...
  
  StartPolling();
  
  string processInstanceId = camunda.BpmnWorkflowService.StartProcessInstance("FlowingTripBookingSaga", new Dictionary<string, object>()
    {
      {"someBookingData", "..." }
    });

Полностью рабочий исходный код можно найти в Интернете: ссылка. Другой пример доступен по адресу ссылка.

Пример с Node.js

  var Workers = require('camunda-worker-node');
  var workers = Workers('http://localhost:8080/engine-rest', {
    workerId: 'some-worker-id'
  });
  
  workers.registerWorker('reserve-car', [ 'someData' ], function(context, callback) {
    var someNewData = context.variables.someData + " - added something";
    callback(null, {
      variables: {
        someNewData: someNewData
      }
    });
  });
  
  workers.shutdown();

Более подробную информацию можно найти на сайте github.com

Альтернативные способы запуска Camunda

Пользовательский образ Docker с «Camunda standalone WAR»

В качестве альтернативы готовому образу Docker из Camunda вы можете самостоятельно подготовить Tomcat (например, на основе официальных образов Docker Tomcat), а затем скопировать в него Camunda как один из так называемых WAR-файлов.

Если у вас имеется много дополнительных требовании и вы можете настроить среду сборки Java, вы также можете настроить Camunda Standalone war. Настройте сборку Maven как в этих примерах: сборка Maven с конфигурацией war или сборка Maven с Overlay.

Запуск дистрибутива Camunda Tomcat

Еще один вариант — просто скачать дистрибутив Camunda Tomcat, разархивировать его и запустить. Для этого потребуется только Java Runtime Environment (JRE), установленная на вашем компьютере. Её можно легко скачать отсюда.

Чтобы изменить базу данных или сделать что-то еще, вам нужно настроить Tomcat, как описано в документации. Я знаю, что Tomcat может показаться сложным, но на самом деле это очень просто. И Google знает ответы на все, что может потребоваться в процессе.

Запуск Camunda с использованием Tomcat

Последняя альтернатива — это самостоятельно настроить Tomcat и установить в него Camunda, следуя описанию установки. Это даст возможность использовать любую версию Tomcat, которую вы предпочитаете, или, например, установить ее в качестве службы Windows.

Запуск Camunda в производство

Как правило, для этого будет необходимо выполнить какие-то окончательные настройки для запуска Camunda. В Camunda есть рекомендации, очень подробно это описывающие, но я не стану затрагивать их в этой статье — назову только один пример: REST API дистрибутива по умолчанию не настроен на проверку подлинности. Возможно, вы захотите изменить это.

Подведение итогов

Как вы могли заметить, начать работать с Camunda очень просто, независимо от языка, который вы используете. Ключевой момент состоит в том, что все взаимодействие осуществляется через REST API. Установка тоже довольно проста, особенно при использовании Docker.

Цели — научиться:

• Настраивать проект Camunda при помощи Camunda Boot Starter
• Создавать и разворачивать процесс
• Создавать Java код и связывать его с Camunda
• Работать с данными в процессе
• Обрабатывать события BPMN

Шаг 1: Сгенерировать проект Camunda с использованием Camunda BPM Initialzr

Необходимо открыть страницу по ссылке: https://start.camunda.com.
Задать настройки проекта и нажать Generate Project.

Полученный архив с именем приложения распаковать и открыть в IDE. Например в IDEA — Import project — as Maven project.
После открытия проекта — дождаться, пока Maven скачает зависимости. После, запустить приложение:

src/main/java/имя_приложения/Application.java > нажать правой кнопкой > >

Имя пользователя: demo
Пароль: demo

Шаг 2: Внести изменения в описание процесса и реализовать Java Delegate

Спроектируем процесс под названием «Половцы vs Печенеги» в котором смоделируем битву. Для начала создадим новый delegate класс под названием PrepareToBattle.
Взаимодействие процессного движка Camunda с кодом осуществляется посредством делегатного когда, другими словами наш класс должен имплементировать интерфейс JavaDelegate.
Для корректной имплементации необходимо реализовать метод execute, кроме этого к классу добавим аннотацию Component.
После чего можем наполнять процесс данными — количество вражеских воинов и статус битвы. Чтобы присвоить эти переменные переменным процесса используем метод setVariable():

package com.reunico.demo;
 
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import org.springframework.stereotype.Component;
 
@Component
public class PrepareToBattle implements JavaDelegate {
 
    @Override
    public void execute(DelegateExecution delegateExecution) throws Exception {
        int enemyWarriors = (int) (Math.random() * 100);
        String battleStatus = "Undefined";
         
        delegateExecution.setVariable("enemyWarriors", enemyWarriors);
        delegateExecution.setVariable("battleStatus", battleStatus);
    }
}

Теперь немного поменяем наш процесс.
В первую очередь поменяем его имя,
для этого нажимаем на пустое пространство и видим id процесса — app-process,
который выступает в роли ключа процесса и name — «Печенеги vs Половцы». Задача «Perform battle!» — это сервисная задача, которая наполнит процесс данными.
Из этой задачи вызовем созданный нами класс.
Нажимаем два раза на сервисный таск, после чего в поле Implementation выбираем Delegate Expression.
В качестве Delegate Expression записываем название созданного класса (spring bean), но с маленькой буквой с использованием синтаксиса JUEL.
После этого можем перезапустить приложение и убедиться в работоспособности процесса в Camunda Task List.

Усложним процесс, добавив в него больше вариативности.
Добавим возможность ввести количество наших воинов, которых мы отправим в бой, модифицируем PrepareToBattle.
Чтобы получить переменную из процесса достаточно использовать метод getVariable(«warriors»).
Также добавим условие победы или поражения битвы. Не забываем поместить обратно в процесс переменную, содержащую эту информацию:

package com.reunico.demo;
 
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import org.springframework.stereotype.Component;
 
@Component
public class PrepareToBattle implements JavaDelegate {
 
    @Override
    public void execute(DelegateExecution delegateExecution) throws Exception {
        int warriors = (int) delegateExecution.getVariable("warriors");
        int enemyWarriors = (int) (Math.random() * 100);
        String battleStatus = "Undefined";
        boolean isWin = false;
 
 
        if ((warriors - enemyWarriors) > 0) {
            isWin = true;
            battleStatus = "Victory!";
        } else {
            battleStatus = "Fail :(";
        }
 
 
        delegateExecution.setVariable("enemyWarriors", enemyWarriors);
        delegateExecution.setVariable("battleStatus", battleStatus);
        delegateExectution.setVariable("isWin", isWin);
    }
}

Что касается самого процесса — удалим пользовательскую задачу и добавим шлюз.
Чтобы определить по какому маршруту пойдет процесс необходимо кликнуть на стрелочку, соединяющую шлюз и пользовательскую задачу, и в Condition Type выбрать пункт Expression.
В самом поле Expression в зависимости от пути написать ${isWin} — для маршрута «Celebrate victory» и ${!isWin} — для поражения.

После чего можем протестировать процесс.
Обратите внимание, что если мы при старте процесса не зададим переменную warriors — количество наших воинов, то выработается exeption «The process could not be started. : Unsuccessful HTTP response».
По логам видно, что это null pointer exection.

Шаг 3: Добавить в описание процесса boundary error event и шлюз

Теперь добавим обработку событий в наш процесс. Для этого на сервисную задачу прикрепим Error Boundary Event, заполним его параметры.
Добавим пользовательскую задачу, которая будет вызвана при срабатывании ошибки, чтобы заставить пользователя ввести число воинов:

Чтобы обработать ошибку в код делегата допишем условие:

package com.reunico.demo;
 
import org.camunda.bpm.engine.delegate.DelegateExecution;
import org.camunda.bpm.engine.delegate.BpmnError;
import org.camunda.bpm.engine.delegate.JavaDelegate;
import org.springframework.stereotype.Component;
 
@Component
public class PrepareToBattle implements JavaDelegate {
 
    @Override
    public void execute(DelegateExecution delegateExecution) throws Exception {
        int warriors = (int) delegateExecution.getVariable("warriors");
        int enemyWarriors = (int) (Math.random() * 100);
        String battleStatus = "Undefined";
        boolean isWin = false;
 
 
        if ((warriors - enemyWarriors) > 0) {
            isWin = true;
 
            battleStatus = "Victory!";
 
        } else {
            battleStatus = "Fail :(";
 
        }
 
 
        if (warriors < 1 || warriors > 100) {
            throw new BpmnError("warriorsError");
        }
 
 
        delegateExecution.setVariable("enemyWarriors", enemyWarriors);
        delegateExecution.setVariable("battleStatus", battleStatus);
        delegateExectution.setVariable("isWin", isWin);
    }
}

Исходный код проекта на GitHub: https://github.com/mstislavm/camundaBattle.

Полное описание в видеоматериале на YouTube:

Design and deploy a process​

In Camunda 8, you have two options to design and deploy a process, but for the purposes for this guide you will find instructions for Web Modeler.

1. To create a BPMN diagram, navigate to Web Modeler via the Modeler tab, and click New project.
2. Name your project and select New > BPMN Diagram > + Create blank.
   
3. Give your model a descriptive name, and then give your model a descriptive id within the General tab inside the properties panel on the right side of the screen.
4. Create a task by dragging the rectangular task icon from the palette, or by clicking the existing start event and clicking the task icon. Make sure there is an arrow connecting the start event to the task.
5. Name the task by double-clicking the task or using the properties panel.
6. Create an end event by dragging the end event icon from the palette, or by clicking the existing start event and clicking the end event icon.
7. No need to save. Web Modeler will autosave every change you make.

You can share read-only models with teammates and other stakeholders via a link. To do this, follow the steps below:

1. From your diagram, click the Share icon located above the properties panel.
2. The Create share link modal will appear. Click Create link to generate a sharable link.
3. Your Link URL will appear along with a blue Copy button. Note other options and features available when sharing a diagram, such as sharing via email.
4. Send your link to your stakeholder to allow them to view the process. They do not need a Camunda account to view the process.

Collaborate on a process​

If you want to invite collaborators to work on your process together, you’ll need to first make sure they have the proper permissions and roles.

1. First, add your colleague to the Organization. Click your account name then Organization Management.
2. Navigate to Users > Add New User. Add your colleague’s email and assign them an appropriate role — Developer is likely a good default option here as the user will have full access to Console, Operate, and Tasklist without deletion privileges. See all roles and permissions for additional details.
3. Click Add. An email will be sent to the email you provided. Your colleague must hit Join to finish adding them to the organization.
4. Now that they’re added to the organization, you can add them to a project. Open Modeler, navigate to your project and open the Collaborators panel on the right side.
5. Click Add user and find your colleague you added to your organization. Assign their role with the dropdown and click Send invites.
   
6. After your colleague clicks Accept invitation, they will have access to the project based on the role you assigned.