Camunda is a vital Open Source Project. During the last 3.5 years more than 20 Camunda core developers as well as many external contributors have worked together on the open source codebase of Camunda. When you contrast Camunda with Activiti on OpenHub, this becomes very obvious, for instance when comparing the lines of code of the projects. This one-day workshop is aimed at Activiti users considering a migration to Camunda Platform. Together with a project-experienced Activiti consultant, you will discuss the similarities and differences between Activiti and Camunda Platform and decide whether a migration would benefit you. Camunda vs Flowable vs Activiti 7. Turn on suggestions. Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you. Bonita is ranked 11th in Business Process Design with 5 reviews while Camunda Platform is ranked 1st in Business Process Design with 20 reviews. Bonita is rated 7.8, while Camunda Platform is rated 8.2. The top reviewer of Bonita writes 'Helps us to create the process, pages, and forms and is easy to use'. On the other hand, the top reviewer of.
| Airflow | Azkaban | Conductor | Oozie | Step Functions | |
|---|---|---|---|---|---|
| Owner | Apache (previously Airbnb) | Netflix | Apache | Amazon | |
| Community | Very Active | Somewhat active | Active | Active | N/A |
| History | 4 years | 7 years | 1.5 years | 8 years | 1.5 years |
| Main Purpose | General Purpose Batch Processing | Hadoop Job Scheduling | Microservice orchestration | Hadoop Job Scheduling | General Purpose Workflow Processing |
| Flow Definition | Python | Custom DSL | JSON | XML | JSON |
| Support for single node | Yes | Yes | Yes | Yes | N/A |
| Quick demo setup | Yes | Yes | Yes | No | N/A |
| Support for HA | Yes | Yes | Yes | Yes | Yes |
| Single Point of Failure | Yes (Single scheduler) | Yes (Single web and scheduler combined node) | No | No | No |
| HA Extra Requirement | Celery/Dask/Mesos + Load Balancer + DB | DB | Load Balancer (web nodes) + DB | Load Balancer (web nodes) + DB + Zookeeper | Native |
| Cron Job | Yes | Yes | No | Yes | Yes |
| Execution Model | Push | Push | Poll | Poll | Unknown |
| Rest API Trigger | Yes | Yes | Yes | Yes | Yes |
| Parameterized Execution | Yes | Yes | Yes | Yes | Yes |
| Trigger by External Event | Yes | No | No | Yes | Yes |
| Native Waiting Task Support | Yes | No | Yes (external signal required) | No | Yes |
| Backfilling support | Yes | No | No | Yes | No |
| Native Web Authentication | LDAP/Password | XML Password | No | Kerberos | N/A (AWS login) |
| Monitoring | Yes | Limited | Limited | Yes | Limited |
| Scalability | Depending on executor setup | Good | Very Good | Very Good | Very Good |
Update
- (2018.11) Oozie has Kerberos auth over SPNEGO for web (thanks to Justin Miller for pointing it out)
Disclaimer
I’m not an expert in any of those engines.
I’ve used some of those (Airflow & Azkaban) and checked the code.
For some others I either only read the code (Conductor) or the docs (Oozie/AWS Step Functions).
As most of them are OSS projects, it’s certainly possible that I might have missed certain undocumented features,
or community-contributed plugins. I’m happy to update this if you see anything wrong.
Bottom line: Use your own judgement when reading this post.
Airflow
The Good
Airflow is a super feature rich engine compared to all other solutions.
Not only you can use plugins to support all kinds of jobs,
ranging from data processing jobs: Hive, Pig (though you can also submit them via shell command),
to general flow management like triggering by existence of file/db entry/s3 content,
or waiting for expected output from a web endpoint,
but also it provides a nice UI that allows you to check your DAGs (workflow dependencies) through code/graph,
and monitors the real time execution of jobs.
Airflow is also highly customizable with a currently vigorous community.
You can run all your jobs through a single node using local executor,
or distribute them onto a group of worker nodes through Celery/Dask/Mesos orchestration.
The Bad
Airflow by itself is still not very mature (in fact maybe Oozie is the only “mature” engine here).
The scheduler would need to periodically poll the scheduling plan and send jobs to executors.
This means it along would continuously dump enormous amount of logs out of the box.
As it works by “ticking”, your jobs are not guaranteed to get scheduled in “real-time” if that makes sense
and this would get worse as the number of concurrent jobs increases.
Meanwhile as you have one centralized scheduler, if it goes down or gets stuck, your running jobs won’t be
affected as that the job of executors, but no new jobs will get scheduled. This is especially confusing when
you run this with a HA setup where you have multiple web nodes, a scheduler, a broker
(typically a message queue in Celery case), multiple executors. When scheduler is stuck for whatever reason,
all you see in web UI is all tasks are running, but in fact they are not actually moving forward while executors
are happily reporting they are fine. In other words, the default monitoring is still far from bullet proof.
The web UI is very nice from the first look. However it sometimes is confusing to new users.
What does it mean my DAG runs are “running” but my tasks have no state? The charts are not search friendly either,
let alone some of the features are still far from well documented
(though the document does look nice, I mean, compared to Oozie, which does seem out-dated).
The backfilling design is good in certain cases but very error prone in others.
If you have a flow with cron schedules disabled and re-enabled later, it would try to play catch up,
and if your jobs is not designed to be idempotent, shit would happen for real.
Azkaban
The Good
Of all the engines, Azkaban is probably the easiest to get going out of the box.
UI is very intuitive and easy to use. Scheduling and REST APIs works just fine.
Limited HA setup works out of the box.
There’s no need for load balancer because you can only have one web node.
You can configure how it selects executor nodes to push jobs to and it generally seems to scale pretty nicely.
You can easily run tens of thousands of jobs as long as you have enough capacity for the executor nodes.
The Bad
It is not very feature rich out of the box as a general purpose orchestration engine,
but likely that’s not what’s originally designed for. It’s strength lies in native support for Hadoop/Pig/Hive,
though you can also achieve those using command line. But itself cannot trigger jobs through external resources like
Airflow, nor does it support job waiting pattern. Although you can do busy waiting through java code/scripts, that
leads to bad resource utilization.
The documentation and configuration are generally a bit confusing compared to others. It’s likely that it wasn’t supposed
to be OSed at the beginning. The design is okish but you better have a big data center to run the executors as scheduling
would get stalled when executors run out of resources without extra monitoring stuff. The code quality overall is a bit towards
the lower end compared to others so it generally only scales well when resource is not a problem.
The setup/design is not cloud friendly. You are pretty much supposed to have stable bare metal rather than dynamically
allocated virtual instances with dynamic IPs. Scheduling would go south if machines vanish.
The monitoring part is sort of acceptable through JMX (does not seem documented). But it generally doesn’t work well if your
machines are heavily loaded, unfortunately, as the endpoints may get stuck.
Conductor
The Good
It’s a bit unfair to put Conductor into this competition as it’s real purpose is for microservice orchestration, whatever that means.
It’s HA model involves a quorum of servers sitting behind load balancer putting tasks onto a message queue which the worker nodes would
poll from, which means it’s less likely you’ll run into stalled scheduling.
With the help of parameterized execution through API, it’s actually quite good at scheduling and scaling provided
that you set up your load balancer/service discovery layer properly.
The Bad
The UI needs a bit more love. There’s currently very limited monitoring there. Although for general purpose scheduling that’s probably
good enough.
It’s pretty bare-bone out of the box. There’s not even native support for running shell scripts, though it’s pretty easy to implement
a task worker through python to do the job with the examples provided.
Oozie
The Good
Oozie provides a seemingly reliable HA model through the db setup (seemingly b/c I’ve not dug into it).
It provides native support for Hadoop related jobs as it was sort of built for that eco system.
The Bad
Camunda And Activiti
Not a very good candidate for general purpose flow scheduling as the XML definition is quite verbose
and cumbersome for defining light weight jobs.
It also requires quite a bit of peripheral setup. You need a zookeeper cluster, a db, a load balancer
and each node needs to run a web app container like Tomcat. The initial setup also takes some time which is
not friendly to first time users to pilot stuff.
Step Functions
The Good
Step Functions is fairly new (launch in Dec 2016). However the future seems promising. With the HA nature of cloud
platform and lambda functions, it almost feels like it can easily scale infinitely (compared to others).
It also offers some useful features for general purpose workflow handling like waiting support and dynamic branching
based on output.
It’s also fairly cheap:
- 4,000 state transitions are free each month
- $0.025 per 1,000 state transitions thereafter ($0.000025 per state transition)
If you don’t run tens of thousands of jobs, this might be even better than running your own cluster of things.
The Bad
Can only be used by AWS users. Deal breaker if you are not one of them yet.
Lambda requires extra work for production level iteration/deployment.
There’s no UI (well there is but it’s really just a console).
So if you need any level of monitoring beyond that you need to build it using cloudwatch by yourself.
This is an update to my earlier article which was written in 2011 when jBPM 5 was still not available in its final release. We will try to compare the two process engines showing, besides the similarities, also the key differences between them.
jBPM€”is an open source process engine that initially (release 3.x) supported a custom language (named jPDL) to describe business processes. In the next release (4.x) jBPM offered both support for jPDL and the standard BPMN 2.0 which is the standard for business process modelling. The release 4.x of jBPM was never included into RedHat list of supported products and so was not clearly the choice for mission critical project.
The next version 5.x of jBPM supports BPMN 2.0, and the project has merged with the JBoss Drools project (an open source business-rule management framework) and replaced Drools Flow as the rule flowlanguage for the Drools framework.
The key features of jBPM 5 are:
- Native BPMN2 execution
- Highly configurable, embeddable, lightweight process engine using a generic process engine (PVM) underneath
- Domain-specific processes and rule / event integration via the Drools Rule engine and Drools Flow workflow
- Independent, human tasks service (using WS-HT)
- Web tooling for things like BPMN2 process creation, deployment, management, reporting (with BIRT) and human tasks
- Migration capabilities from jBPM 3 and 4 (jPDL 3, 4 to BPMN2)
Activiti, like jBPM, is a business process framework designed around the concept of a state machine. Backed by Alfresco company, Activiti has also the collaboration of many talented people from SpringSource as well.
Camunda Vs Flowable Vs Activiti
Some differences do exist, in particular:
- Activiti has native Spring support which allows using Spring Beans in your process and in data persistence (JPA) as well.
- Activiti has no native rule engine support but supports a basic integration with Drools to support the business Rule Task
- Activiti is a bit more friendly for Java developers providing a rich set of BPMN extensions to decorate the process
- Provides an advanced Web interface (Activiti Explorer) which can be used to start/manage processes and ad hoc task and forms support.
Camunda Vs Activities
So, in terms of comparison, we can argue that Activiti looks like the logical continuation of jBPM 3(and in fact was developer by the same jBPM 3 guys T. Baeyens, J. Barrez). It has a lower learning curve also due to a very well done documentation, including a quick start tutorial. Activiti platform is completely dedicated to process and workflow management and has some integration support with Rules systems (Drools Expert) and enterprise integration capabilities (Apache Camel and Mule ESB modules).
Camunda Vs Jbpm
On the other hand, jBPM 5 has a native built-in business Rules engine therefore, the process and workflow management and rule management capabilities are tightly integrated. In the latest (5.3) release the Eclipse editor has improved a lot its BPMN 2.0 process designer capabilities and a first release of the form editor has been released.