ការប្រើប្រាស់ Camunda ដើម្បីងាយស្រួលរៀបចំដោយផ្អែកលើ REST និង Workflow Engine (គ្មាន Java)

សួស្តី ហាប! ខ្ញុំសូមបង្ហាញជូនអ្នកនូវការបកប្រែអត្ថបទ "ប្រើ Camunda ជាម៉ាស៊ីន Orchestration និងដំណើរការការងារដែលមានមូលដ្ឋានលើ REST ដែលងាយស្រួលប្រើ (ដោយមិនប៉ះ Java)" ដោយ Bernd Rücker។

ថ្ងៃទី 07.07.2020/XNUMX/XNUMX, ការបកប្រែ អត្ថបទ Bernd Rücker

ជារឿយៗខ្ញុំពិភាក្សាអំពីស្ថាបត្យកម្មមីក្រូសេវាកម្មជាមួយមនុស្សដែលមិនមែនជាចាវ៉ា៖ C# អ្នកអភិវឌ្ឍន៍ Node.JS/JavaScript ឬអ្នកដែលចូលចិត្ត Golang ។ ពួកគេទាំងអស់ត្រូវប្រឈមមុខនឹងការពិតដែលថាពួកគេត្រូវការម៉ាស៊ីន orchestration នៅក្នុងស្ថាបត្យកម្មមីក្រូសេវាកម្ម ឬគ្រាន់តែជាឧបករណ៍ដើម្បីបង្កើនប្រសិទ្ធភាពលំហូរការងារ និងទទួលបានសមត្ថភាពក្នុងការបញ្ជាទិញ ដោះស្រាយការអស់ពេល Saga និងប្រតិបត្តិការទូទាត់សំណង។

វេទិកា BPM ជាមួយ ប្រភពបើកចំហពី Camunda អស្ចារ្យសម្រាប់ភារកិច្ចបែបនេះ។ ភាពស្និទ្ធស្នាលរបស់អ្នកអភិវឌ្ឍន៍គឺជាលក្ខណៈសំខាន់មួយនៃផលិតផល។ ប៉ុន្តែប្រសិនបើអ្នកក្រឡេកមើលឯកសាររបស់វា អ្នកអាចនឹងមានការចាប់អារម្មណ៍ថា ភាពរួសរាយរាក់ទាក់របស់ Camunda គឺផ្តោតសំខាន់ទៅលើអ្នកអភិវឌ្ឍន៍ Java។ វេទិកាផ្តល់ឱកាសជាច្រើនដើម្បីភ្ជាប់មុខងារ និងផ្នែកបន្ថែមផ្ទាល់ខ្លួនរបស់អ្នក ប៉ុន្តែវាត្រូវបានធ្វើទាំងអស់នៅក្នុង Java ។ តើវាពិតជាមែនទេ?

ទេ! ជាការពិត អ្នកអាចដំណើរការ Camunda យ៉ាងងាយស្រួលដោយមិនចាំបាច់មានចំណេះដឹង Java និងកំណត់រចនាសម្ព័ន្ធស្ថាបត្យកម្មទៅជាកូដជាភាសាណាមួយនៃជម្រើសរបស់អ្នក។ នៅក្នុងអត្ថបទនេះយើងនឹងពិនិត្យមើល:

• ស្ថាបត្យកម្មមូលដ្ឋាន;
• REST API;
• ដំបូន្មានលើបណ្ណាល័យអតិថិជនដែលមានស្រាប់សម្រាប់ភាសាផ្សេងក្រៅពី Java;
• ឧទាហរណ៍នៃការប្រើប្រាស់ C# និង Node.JS;
• វិធីដើម្បីដំណើរការម៉ាស៊ីនមេ Camunda (Docker ឬ Tomcat) ។

ស្ថាបត្យកម្ម

Camunda ត្រូវ​បាន​សរសេរ​ជា​ភាសា Java ហើយ​តម្រូវ​ឱ្យ​មាន Java Virtual Machine (JVM) ដើម្បី​ដំណើរការ។ Camunda ផ្តល់ REST API ដែលអនុញ្ញាតឱ្យអ្នកសរសេរជាភាសាណាមួយដែលអ្នកចូលចិត្ត និងប្រើ REST ជាមួយ Camunda៖

លំហូរការងារនៅក្នុង Camunda ត្រូវបានកំណត់នៅក្នុង BPMN ដែលជាឯកសារ XML ជាមូលដ្ឋាន។ វាអាចត្រូវបានធ្វើគំរូដោយប្រើ Camunda Modeler.

កំពុងដំណើរការ Camunda តាមរយៈរូបភាព Docker ដែលបង្កើតជាមុន

មធ្យោបាយងាយស្រួលបំផុតដើម្បីដំណើរការ Camunda គឺត្រូវប្រើ Docker ។ វិធីជំនួសដើម្បីដំណើរការ Camunda ត្រូវបានពិពណ៌នានៅពេលក្រោយនៅក្នុងអត្ថបទនេះ។

ក្នុងករណីនេះគ្រាន់តែរត់៖

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

អ្នកមិនចាំបាច់ព្រួយបារម្ភអំពី Linux, Java Virtual Machines ឬ Tomcats ទេ។ Dockerfiles និងឯកសារមូលដ្ឋាន (ឧទាហរណ៍ ការណែនាំសម្រាប់ភ្ជាប់ទៅមូលដ្ឋានទិន្នន័យដែលត្រូវការ) មាននៅ Github.

ប្រសិនបើអ្នកចង់ដំណើរការ Camunda Enterprise Edition អ្នកអាចផ្លាស់ប្តូរបានយ៉ាងងាយស្រួល Dockerfile.

ទោះយ៉ាងណាក៏ដោយ មានគុណវិបត្តិមួយក្នុងការដំណើរការ Camunda ដោយប្រើ Docker៖ អ្នកនឹងបញ្ចប់ជាមួយនឹងកំណែរបស់ Tomcat ដែលមិនតែងតែរួមបញ្ចូលការជួសជុលចុងក្រោយបង្អស់។ ដើម្បីស្វែងយល់អំពីបញ្ហានេះ អ្នកអាចបង្កើតរូបភាព Docker ដោយខ្លួនឯងដោយផ្អែកលើការចែកចាយ Tomcat ដែលចង់បានដូចបានបង្ហាញក្នុងឧទាហរណ៍នេះ ឬប្រើដំណោះស្រាយមួយក្នុងចំណោមដំណោះស្រាយដែលបានពិពណ៌នាខាងក្រោម។

ការដាក់ពង្រាយគំរូដំណើរការ

សូមក្រឡេកមើលឧទាហរណ៍ដោយប្រើគំរូ Saga សម្រាប់ការកក់ការធ្វើដំណើរបែបបុរាណ ដែលអ្នកចង់ចាប់ផ្តើមសកម្មភាពបីជាប់ៗគ្នា ហើយផ្តល់សំណងយ៉ាងប្រណិតដល់សកម្មភាពជោគជ័យក្នុងករណីមានការបរាជ័យនៅពេលក្រោយ។ បង្ហាញក្នុងទម្រង់ BPMN វាមើលទៅដូចនេះ៖

ឥឡូវនេះអ្នកអាចប្រើ 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 បង្ក​ឱ្យ​មាន​នីតិវិធី​ដូច​ការ​កក់​រថយន្ត​យ៉ាង​ដូច​ម្តេច? Camunda មិនត្រឹមតែអាចហៅទៅសេវាភ្លាមៗ (Push-Principle) ប៉ុណ្ណោះទេ ដោយប្រើការភ្ជាប់មកជាមួយមួយចំនួន ឧបករណ៍ភ្ជាប់ប៉ុន្តែក៏ដាក់ធាតុការងារទៅក្នុងប្រភេទនៃជួរដែលភ្ជាប់មកជាមួយផងដែរ។ បន្ទាប់មក កម្មករអាចទទួលបានធាតុការងារតាមរយៈ REST អនុវត្តការងារ និងរាយការណ៍ពីការបញ្ចប់ទៅ Camunda (Pull-Principle)។

ដូច្នេះដំបូងអ្នកត្រូវធ្វើ 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

រួច​ប្រាប់ Camunda ហ្នឹង កម្មករបានបញ្ចប់ការងាររបស់ខ្លួន។ (ចំណាំថាអ្នកត្រូវតែបញ្ចូលលេខសម្គាល់កិច្ចការខាងក្រៅដែលទទួលបានក្នុងសំណើដំបូង)៖

  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៖ តំណ. គាំទ្រដោយ Camunda;
• ចាវ៉ា៖ តំណ. គាំទ្រដោយ Camunda;
• C #:តំណ и តំណ. គម្រោងទាំងពីរនេះស្ថិតក្នុងស្ថានភាពមធ្យម ហើយស្ទើរតែគ្មានសកម្មភាព ប៉ុន្តែអាចបម្រើជាចំណុចចាប់ផ្តើមដ៏ល្អ។
• កម្មវិធី PHP: តំណ មិន​មែន​ជា​បណ្ណាល័យ​ពេញលេញ​ទេ ហើយ​មិន​រួម​បញ្ចូល​ការ​ផ្លាស់ប្ដូរ API ចុងក្រោយ​បង្អស់​នោះ​ទេ ប៉ុន្តែ​ខ្ញុំ​ដឹង​អំពី​គម្រោង​ដែល​ប្រើ​វា។

ជាមួយនឹងករណីលើកលែងនៃ JavaScript និង Java បណ្ណាល័យអតិថិជនមិនមែនជាផ្នែកនៃផលិតផល Camunda ខ្លួនឯងនោះទេ។ កុំរំពឹងថាពួកគេនឹងគាំទ្រមុខងារ REST API ទាំងអស់របស់ Camunda ។ ដោយសារបណ្ណាល័យមិនផ្តល់មុខងារជាក់លាក់មិនមានន័យថាវាមិននៅទីនោះទេ សូមពិនិត្យមើល 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"

ជាជម្រើសមួយសម្រាប់រូបភាព Docker ដែលបង្កើតមុនពី Camunda អ្នកអាចរៀបចំ Tomcat ដោយខ្លួនឯង (ឧទាហរណ៍ ដោយផ្អែកលើរូបភាព Docker Tomcat ផ្លូវការ) ហើយបន្ទាប់មកចម្លង Camunda ចូលទៅក្នុងវាជាផ្នែកមួយនៃអ្វីដែលគេហៅថាឯកសារ WAR ។

ប្រសិនបើអ្នកមានតម្រូវការបន្ថែមជាច្រើន ហើយអាចប្ដូរបរិយាកាសបង្កើត Java តាមបំណង អ្នកក៏អាចកំណត់រចនាសម្ព័ន្ធ Camunda Standalone war ផងដែរ។ រៀបចំ Maven build ដូចក្នុងឧទាហរណ៍ទាំងនេះ៖ build Maven ជាមួយនឹងការកំណត់រចនាសម្ព័ន្ធសង្រ្គាម ឬការជួបប្រជុំគ្នា។ Maven ជាមួយ Overlay.

បើកដំណើរការការចែកចាយ Camunda Tomcat

ជម្រើសមួយទៀតគឺគ្រាន់តែទាញយកការចែកចាយ Camunda Tomcat រួចពន្លាវា ហើយដំណើរការវា។ ដើម្បីធ្វើដូចនេះអ្នកគ្រាន់តែត្រូវការ Java Runtime Environment (JRE) ដែលបានដំឡើងនៅលើកុំព្យូទ័ររបស់អ្នក។ វាអាចមានភាពងាយស្រួល ទាញយកពីទីនេះ.

ដើម្បីផ្លាស់ប្តូរមូលដ្ឋានទិន្នន័យ ឬធ្វើអ្វីផ្សេងទៀត អ្នកត្រូវកំណត់រចនាសម្ព័ន្ធ Tomcat ដូច បានពិពណ៌នានៅក្នុងឯកសារ. ខ្ញុំដឹងថា Tomcat ហាក់ដូចជាស្មុគស្មាញ ប៉ុន្តែតាមពិតវាសាមញ្ញណាស់។ ហើយ Google មានចម្លើយចំពោះអ្វីគ្រប់យ៉ាងដែលអ្នកប្រហែលជាត្រូវការនៅក្នុងដំណើរការនេះ។

ដំណើរការ Camunda ដោយប្រើ Tomcat

ជម្រើសចុងក្រោយគឺកំណត់រចនាសម្ព័ន្ធ Tomcat ដោយខ្លួនឯង ហើយដំឡើង Camunda នៅក្នុងវា បន្ទាប់ពីការពិពណ៌នាការដំឡើង. វានឹងផ្តល់ឱ្យអ្នកនូវឱកាសដើម្បីប្រើកំណែណាមួយនៃ Tomcat ដែលអ្នកចូលចិត្ត ឬឧទាហរណ៍ ដំឡើងវាជាសេវាកម្មវីនដូ។

ការ​ចាប់​ផ្ដើម​ផលិត​កម្ម Camunda

ជាធម្មតា វានឹងតម្រូវឱ្យអ្នកធ្វើការដំឡើងចុងក្រោយមួយចំនួន ដើម្បីដំណើរការ Camunda ។ Camunda មានការណែនាំដែលពិពណ៌នាអំពីរឿងនេះយ៉ាងលម្អិត ប៉ុន្តែខ្ញុំនឹងមិនប៉ះពួកវានៅក្នុងអត្ថបទនេះទេ - ខ្ញុំនឹងផ្តល់ឧទាហរណ៍មួយ៖ REST API នៃការចែកចាយមិនត្រូវបានកំណត់សម្រាប់ការផ្ទៀងផ្ទាត់តាមលំនាំដើមទេ។ អ្នកប្រហែលជាចង់ផ្លាស់ប្តូរវា។

សង្ខេប

ដូចដែលអ្នកប្រហែលជាបានកត់សម្គាល់ ការចាប់ផ្តើមជាមួយ Camunda គឺងាយស្រួលណាស់ ដោយមិនគិតពីភាសាដែលអ្នកប្រើ។ ចំណុចសំខាន់គឺថាទំនាក់ទំនងទាំងអស់ត្រូវបានធ្វើតាមរយៈ REST API ។ ការដំឡើងក៏សាមញ្ញផងដែរ ជាពិសេសនៅពេលប្រើ Docker ។

ប្រភព: www.habr.com