Benotzt Camunda fir einfach Orchestratioun baséiert op REST a Workflow Engine (keng Java)

Hey Habr! Ech presentéieren Iech d'Iwwersetzung vum Artikel "Benotzt Camunda als einfach ze benotzen REST-baséiert Orchester- a Workflowmotor (ouni Java ze beréieren)" vum Bernd Rücker.

07.07.2020/XNUMX/XNUMX, Iwwersetzung Artikelen Bernd Rucker

Ech diskutéieren dacks Mikroservicearchitektur mat Net-Java Leit: C # Entwéckler, Node.JS/JavaScript Entwéckler oder Golang Aficionados. All si konfrontéiert mat der Tatsaach datt se en Orchestermechanismus an enger Mikroservicearchitektur brauchen, oder just e Tool fir de Workflow ze streamline an d'Fäegkeet ze bestellen, Timeouts, Saga a Kompensatiounstransaktiounen ze bestellen.

BPM Plattform mat Open Source vu Camunda super fir esou Aufgaben. Entwécklerfrëndlechkeet ass ee vun de Schlësselmerkmale vum Produkt. Awer wann Dir seng Dokumentatioun kuckt, kënnt Dir den Androck kréien datt dem Camunda seng "Frëndlechkeet" haaptsächlech op Java Entwéckler riicht. D'Plattform bitt vill Méiglechkeeten fir Är eege Funktiounen an Extensiounen ze verbannen, awer et ass alles am Java gemaach. Ass et wierklech?

Nee! Tatsächlech kënnt Dir Camunda einfach ouni Java Wëssen lafen an d'Architektur fir Code an all Sprooch vun Ärer Wiel opsetzen. An dësem Artikel wäerte mir kucken:

• Basis Architektur;
• REST API
• Berodung iwwer existent Clientbibliothéike fir aner Sproochen wéi Java;
• Beispill benotzt C # an Node.JS;
• Weeër fir de Camunda Server (Docker oder Tomcat) ze starten.

Architektur

Camunda ass op Java geschriwwen a brauch eng Java Virtual Machine (JVM) fir ze lafen. Camunda bitt eng REST API déi Iech erlaabt an all Sprooch ze schreiwen déi Dir gären hutt a REST mat Camunda benotzt:

Workflows zu Camunda ginn an BPMN definéiert, wat am Fong eng XML Datei ass. Et kann mat modelléiert ginn Camunda Modeler.

Lafen Camunda duerch e pre-gebaut Docker Bild

Deen einfachste Wee fir Camunda ze lafen ass Docker ze benotzen. Alternativ Weeër fir Camunda ze starten gi méi spéit an dësem Artikel beschriwwen.

An dësem Fall, einfach lafen:

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

Dir musst Iech keng Suergen iwwer Linux, JVMs oder Tomcats maachen. Dockerfiles a Basisdokumentatioun (zum Beispill Instruktioune fir mat den erfuerderlechen Datenbanken ze verbannen) sinn op Github.

Wann Dir Camunda Enterprise Edition wëllt lafen, kënnt Dir einfach änneren dockerfile.

Wéi och ëmmer, Camunda mam Docker lafen huet een Nodeel: Dir wäert mat enger Versioun vum Tomcat ophalen, déi net ëmmer déi lescht Fixer enthält. Fir dëst ëmzegoen, kënnt Dir Äert eegent Docker-Bild erstellen op Basis vun der gewënschter Tomcat Verdeelung, wéi an dësem Beispill gewisen, oder eng vun de Léisungen hei ënnen beschriwwen benotzen.

Prozess Modell Deployment

Loosst eis e Beispill kucken mat der Saga Schabloun fir eng klassesch Reesbuchung wou Dir dräi Aktiounen hannertenee wëllt ausléisen a graziéis kompenséiert fir erfollegräich ofgeschloss Aktiounen am Fall vun engem spéideren Echec. A BPMN Form vertrueden, gesäit et esou aus:

Elo kënnt Dir benotzen REST API fir Prozessmodell Deployment. Loosst eis soen datt Dir et als trip.bpmn späichert a Camunda iwwer Docker leeft sou datt et op localhost verfügbar ass: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

Elo kënnt Dir lafen nei Workflow Instanzen mat der REST API a passéiert d'Donnéeën déi Dir als Workflow Instanzvariablen wëllt gesinn:

  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

Déi nächst interessant Fro ass: Wéi nennt Camunda Prozeduren wéi en Auto reservéieren? Camunda kann net nëmmen Servicer direkt Opruff (Push-Prinzip) benotzt e puer gebaut-an verbannen, awer och Aarbechtsartikelen an eng Aart agebauter Uerdnung setzen. Den Aarbechter kann dann Aarbechtsartikelen iwwer REST sichen, d'Aarbecht ausféieren an dem Camunda soen fir ze kompletéieren (Pull-Prinzip).

Also als éischt musst Dir ausféieren fetchAndLock (well aner Aarbechter kënnen Aufgaben zur selwechter Zäit kréien fir de System ze skaléieren):

  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

Dann sot dem Camunda dat Aarbechter ofgeschloss Aarbecht (Notéiert datt Dir déi extern Task-ID an der éischter Ufro kritt hutt aginn):

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

Dat ass et - Dir hutt nach ëmmer kee Java gebraucht, richteg? An dat ass genuch fir unzefänken!

Client Bibliothéiken

Eng REST API ruffen ass einfach an all Programméierungssprooch. A JavaScript gëtt dëst bequem mat JQuery gemaach, an am C #, mat System.Net.Http an Newtonsoft.Json. Mä dëst wäert Zäit huelen. Also kënnt Dir just eng Clientbibliothéik benotzen.

Am Moment sinn e puer fäerdeg Clientbibliothéike verfügbar:

• javascript: ze verschécken. Ënnerstëtzt vum Camunda;
• Java: ze verschécken. Ënnerstëtzt vum Camunda;
• C #:ze verschécken и ze verschécken. Béid vun dëse Projete sinn an engem Zwëschenstand a praktesch dormant, awer kënnen als gudde Startpunkt déngen;
• PHP: ze verschécken - net ze komplett an enthält net déi lescht API Ännerungen, mee ech weess Projeten déi et benotzen.

Mat Ausnam vu JavaScript an Java sinn d'Clientbibliothéike net Deel vum Camunda Produkt selwer. Erwaart net datt se all Camunda's REST API Feature ënnerstëtzen. Just well eng Bibliothéik keng bestëmmte Funktioun ubitt heescht net datt se net do ass, kuckt ëmmer dem Camunda seng REST API. Referenzprojete benotzen d'Bibliothéiken als Ausgangspunkt a Schabloun.

C# Beispill

Mat der uewe genannter Clientbibliothéik kënne mir einfach schreiwen:

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

De komplett funktionnéierende Quellcode kann online fonnt ginn: ze verschécken. En anert Beispill ass verfügbar op ze verschécken.

Beispill mat 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();

Méi Informatioun kann op der Websäit fonnt ginn github.com

Alternativ Weeër fir Camunda ze starten

Benotzerdefinéiert Docker Bild mat "Camunda Standalone WAR"

Als Alternativ zu engem pre-built Docker Bild vu Camunda kënnt Dir Tomcat selwer virbereeden (zum Beispill, baséiert op den offiziellen Docker Tomcat Biller) an dann de Camunda als ee vun de sougenannte WAR Dateien kopéieren.

Wann Dir vill zousätzlech Ufuerderunge hutt a kann e Java Build-Ëmfeld opbauen, kënnt Dir och Camunda Standalone Krich opstellen. Setzt e Maven Build op wéi an dëse Beispiller: bauen Maven mat Krichskonfiguratioun oder Assemblée Maven mat Overlay.

Start der Camunda Tomcat Verdeelung

Eng aner Optioun ass einfach d'Camunda Tomcat Verdeelung erofzelueden, se unzip, a lafen se. Dëst erfuerdert nëmmen d'Java Runtime Environment (JRE) op Ärem Computer installéiert. Et kann einfach sinn download vun hei.

Fir d'Datebank z'änneren oder soss eppes ze maachen, musst Dir Tomcat konfiguréieren wéi an der Dokumentatioun beschriwwen. Ech weess datt Tomcat komplizéiert kléngt, awer et ass tatsächlech ganz einfach. A Google weess d'Äntwerten op alles wat am Prozess erfuerderlech ass.

Lafen Camunda benotzt Tomcat

Déi lescht Alternativ ass den Tomcat selwer opzestellen an de Camunda dran z'installéieren, no der Installatioun Beschreiwung. Dëst gëtt Iech d'Méiglechkeet fir eng Versioun vum Tomcat ze benotzen déi Dir léiwer hutt, oder zB als Windows Service z'installéieren.

Lancéiere Camunda an Produktioun

Dëst erfuerdert normalerweis e finalen Setup fir Camunda ze lafen. Et gi Richtlinnen am Camunda déi dëst am Detail beschreiwen, awer ech ginn net an dësem Artikel an - ech wäert nëmmen ee Beispill nennen: d'REST API vun der Verdeelung ass net standardiséiert fir Authentifikatioun konfiguréiert. Dir wëllt vläicht dëst änneren.

Ze summéieren

Wéi Dir gesitt, ass et ganz einfach mat Camunda unzefänken, onofhängeg vun der Sprooch déi Dir benotzt. De Schlësselpunkt ass datt all Interaktioun duerch d'REST API gemaach gëtt. Installatioun ass och zimlech einfach, besonnesch wann Dir Docker benotzt.

Source: will.com