Skip navigation
All Places > Alfresco Process Services & Activiti (BPM) > Blog > 2018 > March
2018

Last week we manage to finally release to Maven Central and Docker Hub our Early Access Release 201802-EAartifacts. You can read more about this release and our updated Roadmap plans here. As stated in our Roadmap update we will now focus on getting things ready for a Beta1release which is intended to come by the end of April.

Updated Roadmap: https://github.com/Activiti/Activiti/wiki/Activiti-7-Roadmap

 

@MiguelRuizDevimplementing states to the Task Manager service pet project, as well as crafting methods to change and store properties of objects already present in the database

@igdianovworking on Web Sockets and Gateway integration.

@daisuke-yoshimotoworking on streams for BPMN signals. Also, he is working on reviewing the pull request (ACT-4316)

@constantin-ciobotaruinvestigated “delete task” and implement (still tests to add) #1812, investigated bug in “show process instance diagram” for “fixSystemFailure” process definition (related to #1808), started adding error handling in acceptance tests during implementing “try to activate a cancelled process instance

@lucianopreaworked on issues from runtime-bundle that are blocking the demo-ui development (#1803#1813)

@mteodoriadded temporary dependency check exclusion for CVE-2018-7489 #1838

@ffazziniinvestigation around possible issues on helm charts regarding remote env deployments

@ryandawsonukadded options to activiti-scripts (#3) to handle releasing of example repos and added a property to the examples so that json can be used over hal (#80) so as to finalise the release before attending a training workshop

@erdemedeiroswork with @ryandawsonukto get the release ready before attending a training workshop.

@salaboyworked on updating the roadmap plan and writing the release announcement in our gitbook and blog posts. There was a fair amount of testing and improvements on the acceptance tests which are now modularized and can be run independently.

 

We will appreciate help from the community in reviewing our Beta1 milestone and making sure that we are covering the things that you want to see included in this release.

Get in touch if you want to contribute: https://gitter.im/Activiti/Activiti7

We are looking forward to mentor people on the technologies that we are using to submit their first Pull Request ;)

Another Early Access Release (201802-EA) was pushed to Maven Central and our Docker Containers were tagged accordingly. You are encouraged to use these new Early Release artifacts to test inside your services, provide feedback and report issues. 

We are now heavily relying on our Acceptance Tests suite to make sure that each of our released building blocks deployed in Kubernetes (and local docker-compose) are behaving correctly. We haven't released these acceptance tests, but it is in our roadmap to provide these tests as part of our artifacts that you can use to build your scenarios.  

We are now switching to Beta mode, this means that we will work in refining the components that we have to make sure that they can be consumed to create real life implementations. There are a couple of RFCs coming, about Application Service and a new and cleaner Process Runtime Java API. We want to make sure that our Beta1release provides the basic set of functionality required to build scalable, microservices oriented applications. 

Most of the refining work that needs to happen is around REST endpoints, Data types and consistency between different alternatives from our building blocks. This is still a great time to get involved with the project, we want to hear about your distributed architectures and what would you expect from components like the ones that are being provided by Activiti Cloud. 

Check our current milestone for more details: https://github.com/Activiti/Activiti/milestone/9. We also created a new label for community contributors who want to get started with simple tasks called “community contributions”: https://github.com/Activiti/Activiti/labels/community-contribution

Our focus remains the same, but now we will concentrate on consistency across our services: 

  • Create RFCs for new Cloud Native components and services
    • New App Definition And Lifecycle Management Service RFC coming
    • New Java Process Runtime APIs RFC coming
  • Provide a clear specification (APIs) about our Services (REST/Message Based/Configurations). Make sure that these APIs have well defined responsibilities, single focused and can evolve over time without causing consumers any headaches.
    • We iterate each component to make it simpler, faster and better
  • Make sure that we use standard tools, patterns and development techniques widely adopted by other Open Source Projects/Communities. Spring, Spring Boot, Spring Cloud, Docker, Kubernetes falls into this category, and we are making sure that we provide the right integration with these frameworks/tools. Activiti Cloud is designed from the ground up to work with such technologies.
  • Create Industry Specific BluePrints to demonstrate common scenarios and use cases that represent what different industries requirements.
  • Engage and mentor partners and community members that wants to participate.
  • Doing it in the Open Source way (Transparency & Meritocracy are a must).

 

Milestone #7- February 2018 - Ended -

  • Digital Business Platform API Alignment (new module introduced)
  • Process Modelling Services next iteration
    • Process Modelling Validation Endpoint for BPMN models
  • Process Definition based security alignment in Runtime Bundle and Query
  • Kubernetes Service Registry, Kubernetes Discovery Client and ConfigMaps
  • Large POM refactorings required to improve project maintenance and dependency management
  • Activiti Scripts for speeding up the release process
  • Cloud Native BPMN Signal and Message Behaviours (initial draft/still under develop)
  • Web Socket for GraphQL subscriptions and integration with Gateway and Keycloak (still under develop)
  • Hardened our Acceptance Tests for Runtime and Modeling Services
  • Introduced a draft for our Performance Tests suite
  • Introduced Angular/ADF Demo UI Draft

As you can see we did a lot around making sure that our development process can be improved over time. The more repositories and services that we have inside our projects the more difficult is to go through release them and to keep them as consistent as possible. We also spend a substantial amount of time interacting with the Spring Cloud community around Spring Cloud Kubernetes[1] and we participated in the London Microservices Meetup[2] to make sure that we validate our path to the Cloud :) 

[1]: Spring Boot 2 and Sprint Cloud K8s: https://github.com/spring-cloud-incubator/spring-cloud-kubernetes/commit/1e71319f9f7baa73a378f16da37ad1ee5d976754

[2]: Videos and Slides:  https://salaboy.com/2018/03/19/activiti-cloud-introduction-at-mintelnews/ and https://salaboy.com/2018/03/12/activiti-london-uservices-meetup-7-3-18/

https://github.com/Activiti/Activiti/wiki/Activiti-7-Roadmap#beta1---marchapril-2018Beta1 - March/April 2018

  • Process Definition based security alignment in Audit
  • Cloud Native BPMN Signal and Message Behaviours
  • New Process Runtime Java APIs
  • Application Service (proposal and initial draft)
    • Definition
  • Kubernetes Service Brokers/Catalogs review
  • BluePrint improvements to use query & audit
  • Keycloak upgrade  https://github.com/keycloak/keycloak/pull/4976#issuecomment-375210355

If you take a look at our Beta1 milestone you will find that most of the development is focused around consistency and making sure that our services provide the basic set of functionality to be used in a real life scenario. Even though we are focused on improving our existing components there are to main initiatives that will see the light on Beta1: 

  • New Process Runtime Java APIs:java level APIs oriented to Process Runtimes, following the use cases that we are supporting in Cloud Native deployments. We want to make sure that this interfaces are completely decoupled from the Activiti Engine implementation and that they define a clear evolution process. This also allows consumers (of the API) to have clear guidelines for updating to new versions when we release them. These APIs will demarcate a line between what is going to be actively maintained and what might get deprecated in the future. 
  • Application Service:having a set of building blocks is not enough if you want a consistent view of how your applications are working. The application service provides this high level glue to consume a set of microservices as a logical Application. 

A small note about: Kubernetes Service Brokers/Catalogs which we consider an important piece on how we provision services to support our building blocks. We want to make sure that we review how the Kubernetes Service Catalog might affect our infrastructure and our services to make sure that we do not overlap with it. 

We consider these two initiatives required to make a public Beta1 release and we will be working hard with community members that are interested in such initiatives. 

https://github.com/Activiti/Activiti/wiki/Activiti-7-Roadmap#beta2---may-2018Beta2 - May 2018

  • Application Service (second iteration)
  • Istio.ioResearch and initial integration
  • Refinements and consistency improvements
  • JHipster Microservices Infrastructure Integration

https://github.com/Activiti/Activiti/wiki/Activiti-7-Roadmap#final----junejuly-2018Final - June/July 2018

  • BluePrint Trending Topics Campaigns User Interface and Dashboards
  • Security & SSO review (review Apache Shiro Wildcard Permissions)
  • Polyglot MicroProcessRuntime PoC Draft

After that Party time! 

We have a huge list of other things that are coming after our first final release for the Activiti Cloud initiative, but it is important for us to first release the basic set of building block and then think about what will come next. We will appreciate if you send us your ideas, so they can be included in our future plans. For now our commitment to these time frames is important to make sure that our community cadence is appropriate for our users needs. 

As always, if you want to participate on the development process of some of these components or examples get in touch. We are willing to collaborate with the open community and mentor people that want to learn about the project.

We look forward all community involvement, from comments, concerns, help with documentation, tests and component implementations. If you are looking into getting started with the Early Access Release we recommend to check our Getting Started Guide in Gitbook:[Getting Started · Activiti 7 & Activiti Cloud Developers Guide]

You can always find us in the Gitter channel: [Activiti/Activiti7 – Gitter]

Because we are a world wide community you can always find someone online to chat with, no matter your timezone  

I’m happy to announce that Activiti & Activiti Cloud 7-201802-EA artifacts are out. We encourage our community members to try them out and provide feedback.

This release was focused on refining our services endpoints and how we deal with dependencies across all our repositories.
You can take a look at the issues that were closed during this period here.

As usual, refactoring POM files and how we deal with dependencies is painful, but after our third iteration, projects are maturing in the right direction. Now most of our projects are aligned following the same practices as Spring Boot and Spring Cloud projects and our activiti-scriptsrepository is being populated with the tools that will make our life easier.

As part of this release we aligned our artifacts with Spring Boot 2.0.0.RELEASEand Spring Cloud Finchley.M8. We included Synkand Meterianvulnerabilities check in our repositories and we improved our maven enforcer plugin usage across all the repositories that are released.

There were three main initiatives covered in this release:

  • Activiti Cloud Query Process Definition Restricted Views:the activiti cloud query module should be able to recieve configuration for different users and groups to see data that is related to them. This configuration can be provided as properties values, which can be then centralized in a configuration service. The mechanism used in our Query Services matches the one used in our Runtime Bundles for easy configuration and management.
  • Services Alignment with the Alfresco DBP initiative:we wanted to make sure that we follow the Alfresco REST API guidelines for our REST endpoints at the same time that we provide HAL Enabled REST Resources. We achieved this by introducing a new module: activiti-cloud-services-dbp-rest
  • Acceptance Tests Suite to validate our environments:we have improved our acceptance tests to cover a very basic scenario that interact with all the services going through the gateway component. It also validates that authentication happens against Keycloak (SSO and IDM). Acceptance Tests hasn't been released just yet, but they will be included in our Bete release. You can find the source code which include tests for our Runtime Building Blocks and our Modeling Backend Services here.

As part of all this work we have cleaned up our [activiti-cloud-examples](https://github.com/Activiti/activiti-cloud-examples/tree/develop) repository to only contain deployment scripts for Docker & Kubernetes. We have moved out our blueprint Trending Topic Campaignsto a separate repository: blueprint-trending-topic-campaigns. This BluePrint project can be deployed using Spring Boot, Docker Compose and Kubernetes deployment Descriptors and Helm Charts. We encourage our users to check this BluePrint project to understand more about new features and to help us to polish some rough edges.

We introduced also a new repository that contains a simple Angular/ADF NPM application which consumes the new set of APIs. We are calling this initiative Demo UI and it is the perfect place for community users to get involved: activiti-cloud-demo-ui

You might also find useful a couple of presentations that were done while we were working in this release:

You can find our published artifacts in Maven Central 
and our Docker Images have been tagged so you can use the 7-201802-EAtag for each of our images. You can find more details on Activiti in Docker Hub

Next Steps

Because we spent extra time on the 201802 Early Access release, we will concentrate into getting the first Beta1 out by the end of April. We would like to include the following main points, which will be reflected in our updated Roadmap wiki page:

  • New Java Process Runtime APIs
  • Cloud Native Async BPMN Signal/Messages
  • Application Service
  • Several refinements at service level
    • Unified REST resources, paths and operations
    • Unified Messaging/REST content bodies, error handling
    • Mongo/JPA Audit implementation refinements and alignment with restriction policies. 

Most of these topics will come with an RFC blog post, we encourage community people to review those Request For Comments articles and get in touch if you want to get involved in the conversations. 

Coming soon (probably tomorrow) a new update to our Roadmap Wiki. 

Ping us in Gitter if you want to contribute, give feedack, or if you need help reporting an issue: https://gitter.im/Activiti/Activiti7

Alfresco is happy to announce the availability of the second in our series: the AWS Quick Starts for Alfresco Process Services. This comes hot on the heels of a successful initial release of the AWS Quick Start for Alfresco Content Services. This new AWS Quick Start automatically deploys an Alfresco Process Services cluster on the AWS Cloud in about 25 minutes, making Alfresco the first ECM and BPM provider help accelerate your move to the cloud with the use of AWS Quick Starts.

 

AWS Quick Start reference architecture diagram for Alfresco Process Services.

Why should I use this Quick Start?

Quick Starts are automated reference deployments that use AWS CloudFormation templates to deploy key technologies on AWS, following AWS best practices.

The AWS Quick Start reference deployment for Alfresco Process Services was created by AWS in partnership with Alfresco, to integrate services from both companies. It is designed with your security and availability needs in mind. Here are some ways you can benefit from the AWS Quick Start for Alfresco Process Services:

  • To deploy a highly-available and scalable Alfresco Process Services environment on the AWS Cloud with the least amount of effort and time (≅25 min using m4.large EC2 type)
  • As a reference architecture for your Process Services implementations and proofs-of-concept (POC)
  • As AWS and Alfresco technical guidance on best practices for your IT teams
  • To speed up your deployments of Alfresco Process Services on the AWS Cloud. The Quick Starts are modular and customizable. You can choose to build from the ground up, or you can deploy the workload into an existing virtual private cloud (VPC)

 

Many organizations have successfully started their journey to the cloud using the AWS Quick Start for Alfresco Content Services. 

What is included in this Quick Start?

The AWS Quick Start for Alfresco Process Services includes:

  • A reference architecture of Alfresco Process Services on the AWS Cloud addressing the foundational scalability, high availability, and security requirements for production deployments.
  • A deployment guide which provides IT infrastructure decision-makers and system administrators with technical guidance on how to configure, deploy and run an Alfresco Process Services server cluster on the AWS Cloud.
  • The Alfresco Process Services CloudFormation template builds an Auto Scaling group with at least two process services instances. Each Process Services instance is based on the Amazon Machine Image (AMI) available on the AWS Marketplace. This Auto Scaling group connects to an Amazon Relational Database Service (Amazon RDS) DB instance. The Alfresco Process Services template uses the resources created in the AWS CloudFormation master template—private and public subnets, virtual private clouds, and security groups—for privacy and protection.

Why Alfresco Process Services and AWS?

Alfresco Process Services is used by organizations to automate and orchestrate a wide set of business activities and services that deliver value to people.

Because Alfresco Process Services takes advantage of the powerful native AWS services like AWS Relational Database Service (RDS) and Amazon Simple Storage Service (S3), to offer you a highly scalable solution with a modern architecture that naturally fits into the AWS ecosystem to drive your business automation workloads.

With Alfresco Process Services on AWS, you can also accomplish many things such as:

  • starting a customer service process over voice using Amazon Echo and AWS Lambda (link to blog post),
  • performing the business logic of your IoT devices using AWS IoT and AWS Lambda (link to presentation),
  • building advanced analytics using AWS Elasticsearch and Kibana (link to blog post),
  • Integrating with Amazon Simple Queue Service (SQS) to start new processes when new messages arrive in the queue (link to blog post),
  • leveraging AWS DynamoDB, the NoSQL database, to manage your business data outside of the process (link to blog post),
  • and many others.

Let’s get started!

To get started:

  1. Check out the reference architecture and details
  2. Read the deployment guide for step-by-step instructions
  3. Download the AWS CloudFormation templates that automate the deployment
  4. Launch the AWS Quick Start for Alfresco Process Services

 

Optional: if you don’t have a license to run Alfresco Process Services on AWS, you can request a 30-day trial license hereFor additional assistance, you can watch our step-by-step walkthrough. Enjoy, and feel free to share your feedback with us!

Last week we manage to merge two important PRs related to Query Service Security and our unification following the Alfresco API Guidelines. These two PRs are making sure that our services are unified across the whole Alfresco Digital Business Platform initiative, while we provide HAL endpoints for users that want to leverage default Spring REST endpoints. Now that we have these PRs merged in develop we are moving forward with the release process and you should hear about that soon.

 

@MiguelRuizDevstarted to set the basic components of a  “pet Project” based on a the idea of creating a simple task service, dealing with Spring Data REST annotations and H2 database. Repo: https://github.com/MiguelRuizDev/task-service

@igdianovworking on a prototype for GraphQL subscriptions mechanism integrated with the gateway component.

@daisuke-yoshimotoworking on streams for BPMN messages and signals.

@constantin-ciobotaruadded “delete process instance” endpoint #1809, added fix for missing fonts in alpine image #1808, started implementation for “delete task” endpoint #1812, small fixes in acceptance tests and audit for release

@lucianopreaadded in the runtime-bundle api for create standalone task #1803, started working on APIs to create a subtasks in runtime-bundle #1813

@mteodorifixed vulnerability related issues #1718#1823#1815#1820#1817, completed upgrade to Spring Boot 2.0 and Spring Cloud M8 #1810and worked on release support scripts in https://github.com/Activiti/activiti-scripts

@ryandawsonukFinalised the property-based access-control to tasks, process instances and variables on the runtime bundle and query services and reviewed some other pull requests before focusing on the release

@erdemedeirosreviewed pull requests; prepare the next release with @ryandawsonukand @mteodori.

@salaboyworked on finishing the Spring Cloud Kubernetes PR which was merged Friday afternoon. Now testing the published artifacts in our examples. Helped with some pom refactorings and reviewed pull requests that were needed for our Feb Release.

 

 

Get in touch if you want to contribute: https://gitter.im/Activiti/Activiti7

We are looking forward to mentor people on the technologies that we are using to submit their first Pull Request ;)

Here you have a quick intro to Activiti Cloud. On this presentation I covered the main building blocks in Activiti Cloud and the main reasons why we are going all in Kubernetes. It is a really short presentation and I'm quite rusty with my presentation skills, but the better the software gets the easier to present it becomes. 

 

Last week we spend most our energies in finalizing pending issues from February milestone. We are quite close to finish these issues and to proceed with the release almost 12 days after the deadline. We prioritized heavy changes in our POM structures which as usual introduced delays and impact how the release gets done. We were also focused on the London Microservices Meetuppresentations, which was a complete success, due the amount of attendees and the quality of feedback that we received.

This week will be all about getting the release out and planning for the most important bits that we want to include in our soon to come first Beta release. If there is something that you want to see in there get in touch, create an issue or jump in our Gitter channel so we can have a chat.

 

@igdianovwas working on security at the Gateway level to support websocket and graphql subscriptions at that layer instead of services behind the Gateway.

@daisuke-yoshimotowas working on signalling and messaging between processes in cloud architectures.

@constantin-ciobotaruadded query service layer to acceptance tests, closed https://github.com/Activiti/Activiti/issues/1747, implemented delete process instance rest endpoint (https://github.com/Activiti/Activiti/issues/1809)

@lucianopreafixed some issues between process-model-service and organization-service regarding the validation of a process-model, created a PR for #1770and start working on #1803

@mteodoripom refactorings and spring boot/spring cloud version upgrade

@ffazziniperformance tests based on gatling created https://github.com/Activiti/Activiti/issues/1735

@ryandawsonukrefined the PRs for access-restrictions functionality for the query-service module, added endpoints to query and runtime bundle with wider data visibility. The new endpoints can be made admin-only using a flag and the GraphQL endpoint can also be made admin-only in the same way (since it also has wide data visibility).

@erdemedeirosrefined Alfresco REST APIs guidelines PoC (https://github.com/Activiti/Activiti/issues/1419); Reviewed pull requests.

@salaboywas working on https://salaboy.com/2018/03/12/activiti-london-uservices-meetup-7-3-18/and https://github.com/spring-cloud-incubator/spring-cloud-kubernetes/pull/152

 

Get in touch if you want to contribute: https://gitter.im/Activiti/Activiti7

We are looking forward to mentor people on the technologies that we are using to submit their first Pull Request ;)

Last week (Wednesday), the Activiti team presented at the London Microservices Meetup. We did 3 sessions: 2 lighting talks and one full session. All the content was all about our Journey from being a simple Java Framework to a set of Cloud Native building blocks. This big change in architecture and technology stack pushed us to learn and deal with new challenges which are proving to be focal points if you want to provide solutions which targets "Planet Scale" (sic. from http://kubernetes.io).

 

As part of our work as Open Source enthusiasts and Activiti project members, our duty is to share with the wider community our path to the cloud and our solutions to the most common problems that you will face if you decide to take the same road. 

 

@RyanDawson started with a quick intro about Kubernetes for Java Developers, you can find the article that he published in Dzone about this, if you are interested in getting a simple example up and running in 5 minutes: https://dzone.com/articles/minions-in-minikube-a-kubernetes-intro-for-java-de

You can find the recording of the session here: https://skillsmatter.com/skillscasts/11623-kubernetes-for-java-developers

I followed up with an introduction to the Spring Cloud Kubernetes project, where we are participating with contributions and PRs. We believe that this project is the glue between the Spring Cloud and Kubernetes communities. 

 

You can find the session recordings here:

https://skillsmatter.com/skillscasts/11624-spring-cloud-kubernetes-incubator#video

and the slides here: 

 

[slideshare id=90013545&doc=spring-cloud-k8s-180308081716]

 

I've extended Ryan's minions example to use the Spring Cloud Kubernetes Discovery service and Feign in order to consume those services without knowing where those services are living inside the Kubernetes cluster. 

You can find the code of my example here:

https://github.com/Salaboy/minions/tree/spring-cloud-k8s

 

Then we jumped into the main session titled Lessons Learned: Spring Cloud -> Docker -> Kubernetes in the context of an OSS Project.

 

Here you can find the slides:

[slideshare id=90030804&doc=lessons-learned-sc-docker-k8s-180308120739]

And the recording of the main session here:

https://skillsmatter.com/skillscasts/11672-spring-cloud-kubernetes-incubator

As we mention at the end of our presentations, if you are interested in these topics, get in touch (https://gitter.im/Activiti/Activiti7), we want to hear your journey to the cloud and see if we can collaborate to solve common challenges that we might have. 

We are also looking forward to mentor people on the technologies that we are using to submit their first Pull Request ;)

Last week we spend a lot of time working and reshaping our maven structure to improve how dependencies are managed across our repositories. This is our third iteration around this topic and it is always painful but it is getting better. @mteodorialso introduced a new repository called “activiti-scripts”which includes some handy scripts to clone and build all our repositories at once.

 

@diegonayalazoworking on acceptance tests for our Trending Topic Campaigns BluePrint.

@igdianovexposing our notifications mechanisms right into our gateway component, which makes the architecture and security mechanisms much more simple.

@daisuke-yoshimotois working on refactoring the pull requests about Signal Throw Event Cloud Behavior.https://github.com/Activiti/Activiti/pull/1783https://github.com/Activiti/activiti-cloud-runtime-bundle-service/pull/38

@constantin-ciobotaruadded acceptance tests scenarios: “create a group”, “create a subgroup”, “create a project”, “create a process model in a project”, “create the second version of an existing version of a process model”

@lucianopreadid some changes on the validation endpoint for Process Model Service to be available in Organization Service and looked over the issues that are currently blocking the development demo-ui app.

@mteodoriPOM cleanup https://github.com/Activiti/Activiti/issues/1675, update to Spring Cloud M7  https://github.com/Activiti/Activiti/issues/1790and fixing demo UI client for ADF https://github.com/Activiti/Activiti/issues/1805

@ffazzinihttps://github.com/Activiti/Activiti/issues/1698

@balsaroriCreated pull request to move MQServiceTaskBehvior dependency (via expression) outside engine (Acitiviti/Activiti) and another pull request to include it in runtime bundle.

@ryandawsonukcreated pull requests to send task candidate events to the query module (https://github.com/Activiti/activiti-cloud-runtime-bundle-service/pull/39) and use them to add access-restrictions (https://github.com/Activiti/activiti-cloud-query-service/pull/25)

@erdemedeirosfixed pagination metadata Alfresco REST APIs guidelines PoC (https://github.com/Activiti/Activiti/issues/1419).

@salaboyworked on the spring cloud kubernetes PR for Spring Boot 2: https://github.com/spring-cloud-incubator/spring-cloud-kubernetes/pull/152still adding refining and adding examples. Also published a couple of videos about Activiti Cloud Overview and the Trending Topic Campaigns BluePrint

 

This week we will be presenting at the London Microservices Meetup, if you are around try to join us. After the meetup we will start our Early Access release process for our February milestone.

 

Get in touch if you want to contribute: https://gitter.im/Activiti/Activiti7

We are looking forward to mentor people on the technologies that we are using to submit their first Pull Request ;)

We’re pleased to share with you an interview with Ryan Dawson, Activiti Core Developer, and Raphael Allegre, Senior Product Marketing Manager at Alfresco. Here, they talk about  how the BPM and software development industry is moving ahead as well as  how Alfresco is innovating in this space through the Activiti open source project. We invite you to join the conversation on Gitter or Twitter, @alfresco, @activiti, @RaphaelAllegre

Q: What is your take on the BPM industry and its evolution in 2018?

Raphael Allegre: I have been part of the BPM software industry for more than 5 years and each year I have been finding articles predicting the death of BPM. This year is no exception to the famous “BPM is dead…long live BPM!” mantra. It is a commonly accepted fact that traditional BPM software failed at delivering on its promise--instead providing too complicated and expensive platforms as well as poor user and developer experience. As a result, customers who had adopted these legacy BPMS report that it takes too long to see first business benefits. Many of the BPM players are aware that the wider development community is showing signs of falling out of love with traditional BPM. You can read some of their comments at: https://bpm.com/the-year-ahead-for-bpm-2018.


Nevertheless, bringing speed, agility and greater consistency into your business operations and processes for the benefit of your customers, employees, partners or citizens remain more than ever a priority for many business executives. Additionally, with the significant progress of many interesting new topics such as AI, blockchain, RPA, microservices, voice-enabled services, analytics, IoT and many more, business process management and business automation technologies have the potential to evolve into a much broader market.

 

Our view on this at Alfresco is quite simple: digital transformation initiatives are opportunities for renewed and modernized BPM solutions focused on solving key business challenges in a cost-effective way and at speed. Traditional BPM software solutions fail at listening to the wider development community and embracing modern software development methods and cloud-based infrastructures. This is a key ingredient for BPM to succeed and deliver measurable business value. At Alfresco, we are focusing on making sure organizations can leverage our process and content technologies to deploy their first application in a matter of a few hours, not months, and all at no upfront cost.


Q: From an Activiti developer standpoint what is your view on this?

Ryan Dawson Dawson: The developer experience is key. We have a great community of developers that are using Activiti at the coal-face, solving real-world problems and driving the business forward. Activiti aims to give developers tools that empower them to solve problems and that feel great in a sustainable modern solution. If there is something developers want Activiti to do, not to do or something that needs to be done differently, then we’re interested; this has always been our approach.

With Activiti Cloud we are making a break from tradition in providing some opinionated ways to use Activiti for microservices-based projects. Traditionally, Activiti has focused on making great engines and exposing hooks and interfaces so that developers can do what they want with them. Providing specific ways of using Activiti has normally been of less importance.

At this moment we think the industry's move towards cloud-native development practices is very important. We are big fans of the cloud-native ethos and the way it is being embraced in the Java and Spring communities. (For a good overview we’d recommend “Cloud Native Java” by Josh Long and Kenny Bastani.)

Cloud Native Java

To do cloud-native development well, developers need to use Activiti in ways different from how it has traditionally been used and some of this could, without Activiti Cloud, involve a lot of work. You’ll want your cloud-native microservices to do distinct jobs in different ways, use different tooling, run in separate run-times and be properly isolated from one another. But they also need to converse freely with each other. Activiti Cloud provides a set of tools that do as much of the work as possible out of the box. We think the future of cloud-native Java development will center on Kubernetes and Spring Cloud so we're making them central to Activiti Cloud.

Activiti can still be used as it always has and we're still exposing hooks and interfaces- making it as flexible as the community would expect. Activiti Cloud is being added to the family because it's the best way for Activiti to serve the wider software development community and to keep attracting new developers to Activiti by better supporting different kinds of use-cases.

The community is at the center of this, so do share any thoughts (either on Activiti or the present and future of BPM) here or on the Activiti Gitter chat.

 

Q: Is the thought behind this move that everyone will soon be doing microservices?

Ryan Dawson: We are monitoring the technologies being used to develop microservices closely and we see some of the barriers to adoption coming down. The complexity of developing microservices projects and getting them to production is being reduced as Kubernetes becomes more easily available and the tools around it grow. That’s why we’re making sure Activiti is ready and fits in easily with these tools. We’re collaborating with other projects like the Spring Cloud Kubernetes project to help shape the way the space develops and keeping a close eye on new developments like the growth of service meshes.

 

Raphael Allegre: The digital transformation movement is continuing at a fast pace. Digital businesses generate more and more data and they want their systems to handle it reliably to achieve business insights and drive their business forward. Microservices architectures are a key part of handling large amounts of incoming data at scale and required to meet the demands of higher-frequency lower-risk software deployments. Microservices architectures are also most suitable for cloud infrastructures as they, for example, help to build fault-tolerant and highly available enterprise applications without high upfront investment costs. If you are interested in exploring more about microservices, cloud infrastructures and what it all means for BPM, take a look at Sandy Kemsley’s guest blog post. In short, microservices are on one hand challenging traditional BPM products, and on the other are an opportunity for new kind of BPM products that can embrace modern technologies designed for the ongoing data explosion.

 

Q: What can we expect from Activiti?

Ryan Dawson: Tools that empower developers to use Activiti for cloud-native Business Automation. Activiti Cloud uses the latest innovations from the Spring and Java communities to provide new options that give developers the microservices benefits of scalability and fault-tolerance out of the box. Developers will have more control over what parts of their Activiti-built applications are scaled in the cloud, including running more replicas of the components (including service tasks) and adding computing resources.

 

Activiti Cloud doesn’t only offer new cloud-native ways of using the engine. It also has new features such as more flexible querying capabilities, including a GraphQL module to help create more dynamic user interfaces. There’s also a scalable audit implementation that is separate from the engine. The tools should fit naturally into an organisation’s microservices ecosystem and provide the interfaces you’d expect to get the right data in and out of Activiti.

 

I can only mention some of the changes here - explaining all the changes in Activiti would be a topic in its own right. The best ways to learn about Activiti’s new features and how Activiti Cloud enables cloud-native BPM are to go to the developer guide gitbook or to speak to the team on Gitter.

 

Q: What does cloud native mean and why does it matter?

Raphael Allegre: First of all, let’s start by a common misconception of what cloud native means. For an application or a platform to be “cloud native” doesn’t necessarily mean it has to run in the cloud. You can be cloud native and stay on your own servers. As an example, check out the BlaBlaCar case study shared in the Cloud Native Computing Foundation (CNCF) October 2017 newsletter. In a nutshell, they could not make their website scale to address their exponential customer growth. They didn’t want to move to the cloud yet and they knew that buying more servers and hiring more resources would have significantly impacted both cost and team efficiency without solving the root cause. The solution they used was to incrementally containerize their entire platform and then used Kubernetes to dynamically orchestrate all these containers. The gains were significant: they went from 1 or 2 day deployment time for new services in a matter of minutes.

 

Cloud native is not just about technology. Joe Beda, the co-founder of the Kubernetes project, shares his broader definition in his blog series:

Cloud Native is structuring teams, culture and technology to utilize automation and architectures to manage complexity and unlock velocity”.

Therefore, it’s not just a technology solution, it’s a movement that has cultural implications and benefits. He is also reminding companies that are at the very beginning of their cloud-native journey that

these techniques can be applied incrementally as appropriate and should help smooth any transition to the cloud”.

This is a very important point knowing that the vast majority of today’s enterprise applications are not cloud native and that more and more companies are moving to the cloud. Based on this 2017 research project, the proportion of new enterprise apps that are cloud-native will more than double by 2020 jumping from 15% in 2017 to 32%.

 

To make Activiti cloud native, the Activiti team built a new architecture composed of containerized microservices that are dynamically orchestrated using Kubernetes, the most popular open source container-orchestration platform.

For more details on the Activiti microservices architecture check out our developer guide and the overview video from Mauricio Salatino, the Activiti Tech Lead at Alfresco.

 

The benefits of this cloud-native architecture are that you have the full flexibility to allocate the appropriate resources to different services and allow autonomous teams to work on independent components that have their own lifecycle. In a matter of minutes, they can build and deploy a domain-specific process application that is fault-tolerant, highly scalable and out-of-the-box. To get started now and deploy your first Activiti cloud-native application, please check out the Activiti Cloud BluePrint example here and share your feedback on the Gitter channel.

 

Q: What can we expect from  Alfresco Process Services powered by Activiti?

Raphael Allegre: Activiti has always been the leading open source BPM project since its creation back in 2010. Based on its BPM heritage, Activiti evolves to serve as an umbrella for a set of cloud-native building blocks focused on business automation for highly distributed environments. The main cloud providers are increasingly supporting Kubernetes and choosing to provide platforms on top of it (e.g AWS EKS, PKS, GKE, etc...), meaning that portability between platforms should increase. With Activiti being ready to go for Kubernetes, the next version of Alfresco Process Services will have a strong foundation for helping organizations scale up and go cloud-native without being locked into a particular vendor.

 

In terms of timing, the first microservices-based version of Alfresco Process Services based on the new Activiti will be released later this year. It will nicely integrate with the Alfresco Digital Business Platform that intelligently activates process, content, and governance together by giving developers the tools they need to easily build and deploy unique cloud-native applications that drive digital transformation. To support your global cloud-native journey, the Alfresco Process Services subscription will provide a unique combination of tools and expertise delivered wherever you are by Alfresco support engineers and technical experts.

 

What are you most excited to experience with the Activiti open source project? Chime in with your questions and thoughts on Gitter or Twitter, @alfresco, @activiti, @RaphaelAllegre

The Activiti OSS team will be presenting 2 lighting talks and a full session on the technology stacks that we are using to build Activiti Cloud. 

The agenda for the evening will be:

  • Kubernetes for Java Developers (lighting talk)
  • Spring Cloud Kubernetes (lighting talk)
  • Lessons learned in Spring Cloud, Docker & Kubernetes (full session)

During these sessions we will cover some important topics about how these technology stacks allow us to build Cloud Native Building blocks that are ready to be used at global scale. 

Make sure that you reserve your spot there are 137 people already registered: https://www.meetup.com/London-Microservices-User-Group/events/tngzjlyxfbkb/