ProHoster > Օրագիր > Վարչակազմը > Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Հե՜յ Հաբր։ Ձեր ուշադրությանն եմ ներկայացնում հոդվածի թարգմանությունը «Օգտագործեք Camunda-ն որպես հեշտ օգտագործվող REST-ի վրա հիմնված նվագախմբային և աշխատանքային հոսքի շարժիչ (առանց Java-ին դիպչելու)»: Բերնդ Ռյուքերի կողմից։

07.07.2020/XNUMX/XNUMX, թարգմանություն Հոդված Բերնդ Ռակեր

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Ես հաճախ քննարկում եմ միկրոծառայությունների ճարտարապետությունը ոչ Java մարդկանց հետ՝ C# մշակողների, Node.JS/JavaScript մշակողների կամ Golang-ի սիրահարների հետ: Նրանց բոլորին բախվում է այն փաստը, որ նրանց անհրաժեշտ է նվագախմբային մեխանիզմ միկրոսերվիսային ճարտարապետության մեջ, կամ պարզապես գործիք՝ աշխատանքային հոսքը պարզեցնելու և պատվիրելու, ժամանակի դադարեցման, Սագայի և փոխհատուցվող գործարքների կարողություն ձեռք բերելու համար:

BPM հարթակ հետ բաց կոդով Camunda-ից հիանալի է նման առաջադրանքների համար: Մշակողի բարեհամբույր լինելը ապրանքի հիմնական հատկանիշներից մեկն է: Բայց եթե նայեք դրա փաստաթղթերին, կարող եք տպավորություն ստեղծվել, որ Կամունդայի «բարյացակամությունը» հիմնականում ուղղված է Java ծրագրավորողներին: Պլատֆորմը տրամադրում է բազմաթիվ տարբերակներ՝ ձեր սեփական գործառույթներն ու ընդլայնումները միացնելու համար, բայց ամեն ինչ արվում է Java-ում: Իսկապե՞ս։

Ո՛չ։ Փաստորեն, դուք կարող եք հեշտությամբ գործարկել Camunda-ն առանց Java-ի իմացության և կարգավորել կոդերի ճարտարապետությունը ձեր ընտրած ցանկացած լեզվով: Այս հոդվածում մենք կանդրադառնանք.

  • հիմնական ճարտարապետություն;
  • REST API
  • խորհրդատվություն գոյություն ունեցող հաճախորդների գրադարանների վերաբերյալ Java-ից բացի այլ լեզուների համար.
  • օրինակ՝ օգտագործելով C# և Node.JS;
  • Camunda սերվերը գործարկելու եղանակներ (Docker կամ Tomcat):

ճարտարապետություն

Camunda-ն գրված է Java-ով և գործարկելու համար անհրաժեշտ է Java վիրտուալ մեքենա (JVM): Camunda-ն տրամադրում է REST API, որը թույլ է տալիս գրել ցանկացած լեզվով, որը ցանկանում եք և օգտագործել REST-ը Camunda-ի հետ.

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Camunda-ում աշխատանքային հոսքերը սահմանվում են BPMN-ում, որը հիմնականում XML ֆայլ է: Այն կարելի է մոդելավորել հետ Կամունդա Մոդելեր.

Կամունդայի վարում նախապես կառուցված Docker պատկերի միջոցով

Camunda-ն գործարկելու ամենադյուրին ճանապարհը Docker-ն օգտագործելն է: Camunda-ի գործարկման այլընտրանքային ուղիները նկարագրված են այս հոդվածում ավելի ուշ:

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Այս դեպքում պարզապես գործարկեք.

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

Պետք չէ անհանգստանալ Linux-ի, JVM-ների կամ Tomcats-ի մասին: Dockerfiles-ը և հիմնական փաստաթղթերը (օրինակ՝ պահանջվող տվյալների բազաներին միանալու հրահանգները) հասանելի են այստեղ Github.

Եթե ​​ցանկանում եք գործարկել Camunda Enterprise Edition-ը, կարող եք հեշտությամբ փոխել dockerfile.

Այնուամենայնիվ, Camunda-ն Docker-ի հետ գործարկելն ունի մեկ բացասական կողմ՝ դուք կհայտնվեք Tomcat-ի տարբերակով, որը միշտ չէ, որ ներառում է վերջին ուղղումները: Սրա շուրջ աշխատելու համար կարող եք ստեղծել ձեր սեփական Docker պատկերը՝ հիմնված Tomcat-ի ցանկալի բաշխման վրա, ինչպես ցույց է տրված այս օրինակում, կամ օգտագործել ստորև նկարագրված լուծումներից մեկը:

Գործընթացի մոդելի տեղակայում

Դիտարկենք օրինակ՝ օգտագործելով Saga ձևանմուշը դասական ուղևորությունների ամրագրման համար, որտեղ դուք ցանկանում եք գործարկել երեք գործողություն անընդմեջ և նրբագեղորեն փոխհատուցել հաջողությամբ կատարված գործողությունները՝ հետագայում ձախողման դեպքում: Ներկայացված BPMN ձևով, այն ունի հետևյալ տեսքը.

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Այժմ դուք կարող եք օգտագործել 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 "[email protected]" 
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-ն կարող է ոչ միայն անմիջապես զանգահարել ծառայություններ (Push-Principle)՝ օգտագործելով որոշ ներկառուցված միակցիչներ, այլև աշխատանքային իրերը մի տեսակ ներկառուցված կարգի մեջ դնել։ Այնուհետև աշխատողը կարող է REST-ի միջոցով վերցնել աշխատանքային իրերը, կատարել աշխատանքը և ասել Կամունդային, որ ավարտի (Pull-Principle):

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Այսպիսով, նախ դուք պետք է կատարեք fetchAndLock (քանի որ մյուս աշխատողները կարող են միաժամանակ առաջադրանքներ ստանալ՝ համակարգը մեծացնելու համար).

  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

Հետո դա ասա Կամունդային աշխատողն ավարտեց աշխատանքը (նշեք, որ դուք պետք է մուտքագրեք առաջին հարցման մեջ ստացված արտաքին առաջադրանքի ID-ն):

  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: ՈՒղեցույց. Կամունդայի աջակցությամբ;
  • Java: ՈՒղեցույց. Կամունդայի աջակցությամբ;
  • C #:ՈՒղեցույց и ՈՒղեցույց. Այս երկու նախագծերն էլ միջանկյալ վիճակում են և գործնականում քնած վիճակում են, բայց կարող են լավ ելակետ ծառայել.
  • PHP: ՈՒղեցույց - ոչ շատ ամբողջական և չի ներառում API-ի վերջին փոփոխությունները, բայց ես գիտեմ նախագծեր, որոնք օգտագործում են այն:

Բացառությամբ JavaScript-ի և Java-ի, հաճախորդի գրադարանները բուն Camunda արտադրանքի մաս չեն: Մի ակնկալեք, որ նրանք կաջակցեն Camunda-ի REST API-ի բոլոր հնարավորությունները: Միայն այն պատճառով, որ գրադարանը չի ապահովում որոշակի գործառույթ, չի նշանակում, որ այն այնտեղ չէ, միշտ ստուգեք Camunda-ի REST API-ն: Հղման նախագծերը գրադարաններն օգտագործում են որպես ելակետ և ձևանմուշ:

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» հետ

Որպես Camunda-ից նախապես կառուցված Docker պատկերի այլընտրանք, դուք կարող եք ինքներդ պատրաստել Tomcat-ը (օրինակ՝ հիմնվելով Docker Tomcat-ի պաշտոնական պատկերների վրա), այնուհետև պատճենել Camunda-ն դրա մեջ՝ որպես այսպես կոչված WAR ֆայլերից մեկը:

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Եթե ​​դուք ունեք բազմաթիվ լրացուցիչ պահանջներ և կարող եք ստեղծել Java build միջավայր, կարող եք նաև ստեղծել Camunda Standalone War: Ստեղծեք Maven build, ինչպես այս օրինակներում. build Maven պատերազմի կոնֆիգուրացիայով կամ ժողով Maven հետ Overlay.

Սկսվում է Camunda Tomcat-ի բաշխումը

Մեկ այլ տարբերակ պարզապես ներբեռնելն է Camunda Tomcat-ի բաշխումը, unzip-ը և գործարկել այն: Սա պահանջում է միայն ձեր համակարգչում տեղադրված Java Runtime Environment (JRE): Դա կարող է հեշտությամբ լինել բեռնել այստեղից.

Օգտագործելով Camunda-ն՝ REST-ի և Workflow Engine-ի վրա հիմնված հեշտ նվագախմբի համար (առանց Java)

Տվյալների բազան փոխելու կամ որևէ այլ բան անելու համար հարկավոր է կարգավորել Tomcat-ի նմանը նկարագրված է փաստաթղթերում. Ես գիտեմ, որ Tomcat-ը կարող է բարդ թվալ, բայց իրականում դա շատ պարզ է: Եվ Google-ը գիտի այն ամենի պատասխանները, որոնք կարող են պահանջվել գործընթացում:

Վազում Camunda-ն Tomcat-ի միջոցով

Վերջին այլընտրանքն այն է, որ ինքներդ ստեղծեք Tomcat-ը և տեղադրեք Camunda-ն դրա մեջ, հետևելով տեղադրման նկարագրությանը. Սա ձեզ հնարավորություն կտա օգտագործել Tomcat-ի ցանկացած տարբերակը, որը դուք նախընտրում եք, կամ տեղադրել այն որպես Windows ծառայություն, օրինակ:

Camunda-ի թողարկումը արտադրության մեջ

Սա սովորաբար կպահանջի վերջնական կարգավորում՝ Camunda-ն գործարկելու համար: Camunda-ում կան ուղեցույցներ, որոնք նկարագրում են դա շատ մանրամասն, բայց ես չեմ անդրադառնա դրանց այս հոդվածում. ես կնշեմ միայն մեկ օրինակ. բաշխման REST API-ն լռելյայն կազմաձևված չէ նույնականացման համար: Դուք կարող եք փոխել սա:

Ամփոփելով-up

Ինչպես տեսնում եք, Camunda-ի հետ սկսելը շատ հեշտ է, անկախ նրանից, թե որ լեզվից եք օգտագործում: Հիմնական կետն այն է, որ բոլոր փոխազդեցությունները կատարվում են REST API-ի միջոցով: Տեղադրումը նույնպես բավականին հեշտ է, հատկապես Docker-ի օգտագործման ժամանակ:

Source: www.habr.com

Добавить комментарий