Paggamit ng Camunda para sa madaling REST-based orchestration at Workflow Engine (walang Java)

Hello, Habr! Ipinakita ko sa iyong pansin ang isang pagsasalin ng artikulo "Gamitin ang Camunda bilang isang madaling gamitin na REST-based orchestration at workflow engine (nang hindi hinahawakan ang Java)" ni Bernd Rücker.

07.07.2020/XNUMX/XNUMX, pagsasalin Artikulo Bernd Rücker

Madalas kong talakayin ang arkitektura ng microservice sa mga taong hindi Java: C#, Node.JS/JavaScript developer, o Golang enthusiasts. Lahat sila ay nahaharap sa katotohanan na kailangan nila ng isang orkestrasyon na makina sa isang microservice architecture o isang tool lamang upang ma-optimize ang daloy ng trabaho at makakuha ng kakayahang mag-order, pangasiwaan ang mga timeout, Saga at mga pagbabayad na transaksyon.

BPM platform na may open source mula sa Camunda mahusay para sa gayong mga gawain. Ang pagiging kabaitan ng developer ay isa sa mga pangunahing tampok ng produkto. Ngunit kung titingnan mo ang dokumentasyon nito, maaari kang makakuha ng impresyon na ang pagiging kabaitan ni Camunda ay pangunahing nakatuon sa mga developer ng Java. Ang platform ay nagbibigay ng maraming pagkakataon upang ikonekta ang iyong sariling mga function at extension, ngunit lahat ito ay ginagawa sa Java. Talaga ba?

Hindi! Sa katunayan, madali mong mapatakbo ang Camunda nang walang anumang kaalaman sa Java at i-configure ang arkitektura upang mag-code sa anumang wika na iyong pinili. Sa artikulong ito titingnan natin ang:

• pangunahing arkitektura;
• REST API;
• payo sa mga kasalukuyang library ng kliyente para sa mga wika maliban sa Java;
• halimbawa ng paggamit ng C# at Node.JS;
• mga paraan upang patakbuhin ang server ng Camunda (Docker o Tomcat).

arkitektura

Ang Camunda ay nakasulat sa Java at nangangailangan ng Java Virtual Machine (JVM) upang tumakbo. Nagbibigay ang Camunda ng REST API na nagbibigay-daan sa iyo na magsulat sa anumang wika na gusto mo at gumamit ng REST sa Camunda:

Ang mga daloy ng trabaho sa Camunda ay tinukoy sa BPMN, na karaniwang isang XML file. Maaari itong i-modelo gamit ang Modeler ng Camunda.

Pagpapatakbo ng Camunda sa pamamagitan ng isang pre-built na imahe ng Docker

Ang pinakamadaling paraan upang patakbuhin ang Camunda ay ang paggamit ng Docker. Ang mga alternatibong paraan upang patakbuhin ang Camunda ay inilarawan sa ibang pagkakataon sa artikulong ito.

Sa kasong ito, tumakbo lang:

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

Hindi mo kailangang mag-alala tungkol sa Linux, Java Virtual Machines o Tomcats. Ang mga dockerfile at pangunahing dokumentasyon (halimbawa, mga tagubilin para sa pagkonekta sa mga kinakailangang database) ay makukuha sa Github.

Kung gusto mong patakbuhin ang Camunda Enterprise Edition, madali mong mababago dockerfile.

Gayunpaman, mayroong isang downside sa pagpapatakbo ng Camunda gamit ang Docker: magkakaroon ka ng isang bersyon ng Tomcat na hindi palaging kasama ang mga pinakabagong pag-aayos. Upang kahit papaano makayanan ito, maaari kang lumikha ng isang Docker na imahe sa iyong sarili batay sa nais na pamamahagi ng Tomcat, tulad ng ipinapakita sa halimbawang ito, o gumamit ng isa sa mga solusyon na inilarawan sa ibaba.

Pag-deploy ng Modelo ng Proseso

Tingnan natin ang isang halimbawa gamit ang template ng Saga para sa isang klasikong booking sa paglalakbay kung saan gusto mong mag-trigger ng tatlong magkakasunod na pagkilos at maayos na bayaran ang mga matagumpay na aksyon kung sakaling mabigo sa ibang pagkakataon. Iniharap sa BPMN form, ganito ang hitsura:

Ngayon ay maaari mong gamitin REST API para sa pag-deploy ng modelo ng proseso. Sabihin nating na-save mo ito bilang trip.bpmn at pinatakbo ang Camunda sa pamamagitan ng Docker kaya available ito sa localhost:8080:

  curl -w "n" 
-H "Accept: application/json" 
-F "deployment-name=trip" 
-F "enable-duplicate-filtering=true" 
-F "deploy-changed-only=true" 
-F "[email protected]" 
http://localhost:8080/engine-rest/deployment/creat

Ngayon ay maaari kang tumakbo bagong workflow instance gamit ang REST API at pagpasa ng data na gusto mong makita bilang mga variable ng instance ng daloy ng trabaho:

  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

Ang susunod na kawili-wiling tanong ay kung paano nag-trigger ang Camunda ng mga pamamaraan tulad ng pag-book ng kotse? Ang Camunda ay hindi lamang makakatawag kaagad ng mga serbisyo (Push-Principle), gamit ang ilang built-in mga konektor, ngunit ilagay din ang mga item sa trabaho sa isang uri ng built-in na pila. Ang manggagawa ay maaaring makatanggap ng mga item sa trabaho sa pamamagitan ng REST, gawin ang trabaho, at iulat ang pagkumpleto sa Camunda (Pull-Principle).

Kaya kailangan mo munang gawin fetchAndLock (dahil ang ibang mga manggagawa ay maaaring makatanggap ng mga gawain sa parehong oras upang sukatin ang system):

  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

Pagkatapos ay sabihin sa Camunda na natapos ng manggagawa ang kanyang trabaho (tandaan na dapat mong ilagay ang panlabas na task ID na natanggap sa unang kahilingan):

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

Iyon lang - hindi mo pa kailangan ng anumang Java sa ngayon, tama? At sapat na iyon para makapagsimula!

Mga Aklatan ng Kliyente

Ang pagtawag sa REST API ay madali sa anumang programming language. Sa JavaScript ito ay maginhawang gawin ito gamit ang JQuery, at sa C# maaari mong gamitin ang System.Net.Http at Newtonsoft.Json. Ngunit ito ay magtatagal. Kaya maaari ka lamang gumamit ng ilang library ng kliyente.

Kasalukuyang mayroong ilang handa na mga library ng kliyente na magagamit:

• JavaScript: link. Sinusuportahan ng Camunda;
• Java: link. Sinusuportahan ng Camunda;
• C #:link и link. Pareho sa mga proyektong ito ay nasa isang intermediate na estado at halos walang aktibidad, ngunit maaaring magsilbi bilang isang magandang panimulang punto;
• PHP: link ay hindi isang kumpletong library at hindi kasama ang pinakabagong mga pagbabago sa API, ngunit may alam akong mga proyektong gumagamit nito.

Maliban sa JavaScript at Java, ang mga library ng kliyente ay hindi bahagi ng produkto mismo ng Camunda. Huwag asahan na susuportahan nila ang lahat ng feature ng REST API ng Camunda. Dahil lang sa hindi nagbibigay ng partikular na feature ang isang library ay hindi ito nangangahulugan na wala ito, palaging suriin ang Camunda REST API. Ang mga karaniwang proyekto ay gumagamit ng mga aklatan bilang panimulang punto at template.

Halimbawa sa C#

Gamit ang library ng kliyente sa itaas, maaari nating isulat ang:

  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", "..." }
    });

Ang buong gumaganang source code ay matatagpuan online: link. Ang isa pang halimbawa ay makukuha sa link.

Halimbawa sa 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();

Higit pang impormasyon ay matatagpuan sa website github.com

Mga alternatibong paraan upang simulan ang Camunda

Custom na larawan ng Docker na may "Camunda standalone WAR"

Bilang kahalili sa pre-built na imahe ng Docker mula sa Camunda, maaari mong ihanda ang Tomcat mismo (halimbawa, batay sa mga opisyal na larawan ng Docker Tomcat) at pagkatapos ay kopyahin ang Camunda dito bilang isa sa mga tinatawag na WAR file.

Kung marami kang karagdagang kinakailangan at maaaring i-customize ang isang Java build environment, maaari mo ring i-configure ang Camunda Standalone war. Mag-set up ng isang Maven build tulad ng sa mga halimbawang ito: build Maven na may configuration ng digmaan o pagpupulong Maven na may Overlay.

Inilunsad ang pamamahagi ng Camunda Tomcat

Ang isa pang pagpipilian ay ang pag-download lamang ng pamamahagi ng Camunda Tomcat, i-unzip ito at patakbuhin ito. Upang gawin ito, kailangan mo lamang na naka-install ang Java Runtime Environment (JRE) sa iyong computer. Maaari itong maging madali i-download mula dito.

Upang baguhin ang database o gumawa ng anumang bagay na kailangan mong i-configure tulad ng Tomcat inilarawan sa dokumentasyon. Alam kong ang Tomcat ay maaaring mukhang kumplikado, ngunit ito ay talagang napaka-simple. At nasa Google ang mga sagot sa lahat ng maaaring kailanganin mo sa proseso.

Pagpapatakbo ng Camunda gamit ang Tomcat

Ang huling alternatibo ay ang i-configure ang Tomcat sa iyong sarili at i-install ang Camunda dito, pagsunod sa paglalarawan ng pag-install. Bibigyan ka nito ng pagkakataong gumamit ng anumang bersyon ng Tomcat na gusto mo, o, halimbawa, i-install ito bilang isang serbisyo ng Windows.

Paglunsad ng Camunda sa produksyon

Karaniwan, kakailanganin mong gawin ang ilang panghuling pag-setup upang mapatakbo ang Camunda. Ang Camunda ay may mga alituntunin na naglalarawan dito nang detalyado, ngunit hindi ko papansinin ang mga ito sa artikulong ito - Magbibigay lang ako ng isang halimbawa: ang REST API ng pamamahagi ay hindi naka-configure para sa pagpapatunay bilang default. Baka gusto mong baguhin ito.

Summing-up

Tulad ng maaaring napansin mo, ang pagsisimula sa Camunda ay napakadali, anuman ang wikang iyong ginagamit. Ang pangunahing punto ay ang lahat ng komunikasyon ay ginagawa sa pamamagitan ng REST API. Ang pag-install ay medyo simple din, lalo na kapag gumagamit ng Docker.

Pinagmulan: www.habr.com