REST, വർക്ക്ഫ്ലോ എഞ്ചിൻ എന്നിവയെ അടിസ്ഥാനമാക്കി എളുപ്പത്തിൽ ഓർക്കസ്ട്രേഷനായി കാമുണ്ട ഉപയോഗിക്കുന്നു (ജാവ ഇല്ല)

ഹേ ഹബർ! ലേഖനത്തിന്റെ വിവർത്തനം ഞാൻ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തുന്നു "ഉപയോഗിക്കാൻ എളുപ്പമുള്ള REST-അധിഷ്‌ഠിത ഓർക്കസ്‌ട്രേഷനും വർക്ക്‌ഫ്ലോ എഞ്ചിനും (ജാവയിൽ തൊടാതെ) കാമുണ്ട ഉപയോഗിക്കുക" ബെർൻഡ് റൂക്കർ എഴുതിയത്.

07.07.2020/XNUMX/XNUMX, വിവർത്തനം ലേഖനങ്ങൾ ബെർൻഡ് റക്കർ

ജാവ അല്ലാത്ത ആളുകളുമായി ഞാൻ മൈക്രോ സർവീസ് ആർക്കിടെക്ചറിനെ കുറിച്ച് ചർച്ച ചെയ്യാറുണ്ട്: C# ഡവലപ്പർമാർ, Node.JS/JavaScript ഡവലപ്പർമാർ, അല്ലെങ്കിൽ Golang ആരാധകർ. ഒരു മൈക്രോസർവീസ് ആർക്കിടെക്ചറിൽ ഒരു ഓർക്കസ്ട്രേഷൻ മെക്കാനിസം അല്ലെങ്കിൽ വർക്ക്ഫ്ലോ കാര്യക്ഷമമാക്കാനും ഓർഡർ ചെയ്യാനും ടൈംഔട്ടുകൾ കൈകാര്യം ചെയ്യാനും സാഗ ചെയ്യാനും നഷ്ടപരിഹാര ഇടപാടുകൾ നടത്താനുമുള്ള കഴിവ് നേടാനുമുള്ള ഒരു ഉപകരണം മാത്രമാണോ അവർക്കെല്ലാം ആവശ്യമുള്ളത്.

കൂടെ BPM പ്ലാറ്റ്ഫോം കാമുണ്ടയിൽ നിന്നുള്ള ഓപ്പൺ സോഴ്സ് അത്തരം ജോലികൾക്ക് മികച്ചതാണ്. ഡവലപ്പർ സൗഹൃദമാണ് ഉൽപ്പന്നത്തിന്റെ പ്രധാന സവിശേഷതകളിലൊന്ന്. എന്നാൽ നിങ്ങൾ അതിന്റെ ഡോക്യുമെന്റേഷൻ നോക്കിയാൽ, കാമുണ്ടയുടെ "സൗഹൃദം" പ്രധാനമായും ജാവ ഡെവലപ്പർമാരെ ലക്ഷ്യം വച്ചുള്ളതാണെന്ന് നിങ്ങൾക്ക് തോന്നാം. നിങ്ങളുടെ സ്വന്തം ഫംഗ്‌ഷനുകളും വിപുലീകരണങ്ങളും ബന്ധിപ്പിക്കുന്നതിന് പ്ലാറ്റ്‌ഫോം ധാരാളം ഓപ്ഷനുകൾ നൽകുന്നു, പക്ഷേ ഇതെല്ലാം ജാവയിലാണ് ചെയ്യുന്നത്. അത് ശരിക്കും ആണോ?

ഇല്ല! വാസ്തവത്തിൽ, നിങ്ങൾക്ക് ജാവ പരിജ്ഞാനമില്ലാതെ എളുപ്പത്തിൽ Camunda പ്രവർത്തിപ്പിക്കാനും നിങ്ങൾക്ക് ഇഷ്ടമുള്ള ഏത് ഭാഷയിലും കോഡിനായി ആർക്കിടെക്ചർ സജ്ജീകരിക്കാനും കഴിയും. ഈ ലേഖനത്തിൽ, ഞങ്ങൾ നോക്കും:

• അടിസ്ഥാന വാസ്തുവിദ്യ;
• REST API
• ജാവ ഒഴികെയുള്ള ഭാഷകൾക്കായി നിലവിലുള്ള ക്ലയന്റ് ലൈബ്രറികളെക്കുറിച്ചുള്ള ഉപദേശം;
• C#, Node.JS എന്നിവ ഉപയോഗിച്ചുള്ള ഉദാഹരണം;
• കാമുണ്ട സെർവർ (ഡോക്കർ അല്ലെങ്കിൽ ടോംകാറ്റ്) ആരംഭിക്കുന്നതിനുള്ള വഴികൾ.

വാസ്തുവിദ്യ

ജാവയിലാണ് കാമുണ്ട എഴുതിയിരിക്കുന്നത്, പ്രവർത്തിക്കാൻ ഒരു ജാവ വെർച്വൽ മെഷീൻ (ജെവിഎം) ആവശ്യമാണ്. Camunda നിങ്ങൾക്ക് ഇഷ്ടമുള്ള ഏത് ഭാഷയിലും എഴുതാനും Camunda ഉപയോഗിച്ച് REST ഉപയോഗിക്കാനും അനുവദിക്കുന്ന ഒരു REST API നൽകുന്നു:

കാമുണ്ടയിലെ വർക്ക്ഫ്ലോകൾ അടിസ്ഥാനപരമായി ഒരു XML ഫയലായ BPMN-ൽ നിർവചിച്ചിരിക്കുന്നു. ഉപയോഗിച്ച് മാതൃകയാക്കാം കാമുണ്ട മോഡലർ.

മുൻകൂട്ടി നിർമ്മിച്ച ഡോക്കർ ചിത്രത്തിലൂടെ കാമുണ്ട പ്രവർത്തിപ്പിക്കുന്നു

കാമുണ്ട പ്രവർത്തിപ്പിക്കാനുള്ള ഏറ്റവും എളുപ്പ മാർഗം ഡോക്കർ ഉപയോഗിക്കുക എന്നതാണ്. Camunda വിക്ഷേപിക്കുന്നതിനുള്ള ഇതര മാർഗങ്ങൾ ഈ ലേഖനത്തിൽ പിന്നീട് വിവരിച്ചിരിക്കുന്നു.

ഈ സാഹചര്യത്തിൽ, ലളിതമായി പ്രവർത്തിപ്പിക്കുക:

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

നിങ്ങൾ Linux, JVMs അല്ലെങ്കിൽ Tomcats എന്നിവയെക്കുറിച്ച് വിഷമിക്കേണ്ടതില്ല. ഡോക്കർഫയലുകളും അടിസ്ഥാന ഡോക്യുമെന്റേഷനും (ഉദാഹരണത്തിന്, ആവശ്യമായ ഡാറ്റാബേസുകളിലേക്ക് ബന്ധിപ്പിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ) ലഭ്യമാണ് സാമൂഹികം.

നിങ്ങൾക്ക് കാമുണ്ട എന്റർപ്രൈസ് പതിപ്പ് പ്രവർത്തിപ്പിക്കണമെങ്കിൽ എളുപ്പത്തിൽ മാറ്റാനാകും Dockerfile.

എന്നിരുന്നാലും, ഡോക്കറിനൊപ്പം കാമുണ്ട പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരു പോരായ്മയുണ്ട്: ഏറ്റവും പുതിയ പരിഹാരങ്ങൾ ഉൾപ്പെടുത്താത്ത ടോംകാറ്റിന്റെ ഒരു പതിപ്പ് നിങ്ങൾക്ക് ലഭിക്കും. ഇത് പരിഹരിക്കുന്നതിന്, ഈ ഉദാഹരണത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, ആവശ്യമുള്ള ടോംകാറ്റ് വിതരണത്തെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം ഡോക്കർ ഇമേജ് സൃഷ്ടിക്കാം അല്ലെങ്കിൽ ചുവടെ വിവരിച്ചിരിക്കുന്ന പരിഹാരങ്ങളിലൊന്ന് ഉപയോഗിക്കുക.

പ്രോസസ് മോഡൽ വിന്യാസം

ഒരു ക്ലാസിക് ട്രിപ്പ് ബുക്കിംഗിനായി സാഗ ടെംപ്ലേറ്റ് ഉപയോഗിച്ച് ഒരു ഉദാഹരണം നോക്കാം, അവിടെ നിങ്ങൾക്ക് തുടർച്ചയായി മൂന്ന് പ്രവർത്തനങ്ങൾ ട്രിഗർ ചെയ്യാനും പിന്നീട് പരാജയപ്പെട്ടാൽ വിജയകരമായി പൂർത്തിയാക്കിയ പ്രവർത്തനങ്ങൾക്ക് മനോഹരമായി നഷ്ടപരിഹാരം നൽകാനും ആഗ്രഹിക്കുന്നു. BPMN രൂപത്തിൽ പ്രതിനിധീകരിക്കുന്നു, ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

ഇപ്പോൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം പ്രോസസ്സ് മോഡൽ വിന്യാസത്തിനുള്ള REST API. നിങ്ങൾ ഇത് trip.bpmn ആയി സംരക്ഷിച്ച് ഡോക്കർ വഴി Camunda പ്രവർത്തിപ്പിക്കുക, അതിനാൽ ഇത് ലോക്കൽ ഹോസ്റ്റിൽ ലഭ്യമാണ്: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

അടുത്ത രസകരമായ ചോദ്യം ഇതാണ്: ഒരു കാർ ബുക്ക് ചെയ്യുന്നത് പോലുള്ള നടപടിക്രമങ്ങളെ കാമുണ്ട എങ്ങനെ വിളിക്കും? ചില ബിൽറ്റ്-ഇൻ ഉപയോഗിച്ച് സേവനങ്ങളെ ഉടനടി വിളിക്കാൻ മാത്രമല്ല (പുഷ്-പ്രിൻസിപ്പിൾ) കാമുണ്ടയ്ക്ക് കഴിയൂ കണക്ടറുകൾ, മാത്രമല്ല ഒരു തരത്തിലുള്ള ബിൽറ്റ്-ഇൻ ക്രമത്തിൽ വർക്ക് ഇനങ്ങൾ ഇടുക. തൊഴിലാളിക്ക് REST വഴി വർക്ക് ഇനങ്ങൾ എടുക്കാനും ജോലി നിർവഹിക്കാനും കാമുണ്ടയെ പൂർത്തിയാക്കാൻ പറയാനും കഴിയും (പുൾ-പ്രിൻസിപ്പൽ).

അതിനാൽ ആദ്യം നിങ്ങൾ എക്സിക്യൂട്ട് ചെയ്യേണ്ടതുണ്ട് 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

എന്നിട്ട് അത് കാമുണ്ടയോട് പറയൂ തൊഴിലാളി ജോലി പൂർത്തിയാക്കി (ആദ്യ അഭ്യർത്ഥനയിൽ ലഭിച്ച ബാഹ്യ ടാസ്ക് ഐഡി നിങ്ങൾ നൽകണം എന്നത് ശ്രദ്ധിക്കുക):

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

അത്രയേയുള്ളൂ - നിങ്ങൾക്ക് ഇപ്പോഴും ജാവ ആവശ്യമില്ല, അല്ലേ? ആരംഭിക്കാൻ അത് മതി!

ക്ലയന്റ് ലൈബ്രറികൾ

ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയിലും ഒരു REST API വിളിക്കുന്നത് എളുപ്പമാണ്. JavaScript-ൽ, JQuery ഉപയോഗിച്ചും C#-ൽ System.Net.Http, Newtonsoft.Json എന്നിവ ഉപയോഗിച്ചും ഇത് സൗകര്യപ്രദമാണ്. എന്നാൽ ഇതിന് സമയമെടുക്കും. അതിനാൽ നിങ്ങൾക്ക് കുറച്ച് ക്ലയന്റ് ലൈബ്രറി ഉപയോഗിക്കാം.

ഇപ്പോൾ, നിരവധി റെഡിമെയ്ഡ് ക്ലയന്റ് ലൈബ്രറികൾ ലഭ്യമാണ്:

• ജാവാസ്ക്രിപ്റ്റ്: ലിങ്ക്. കാമുണ്ട പിന്തുണച്ചു;
• ജാവ: ലിങ്ക്. കാമുണ്ട പിന്തുണച്ചു;
• സി #:ലിങ്ക് и ലിങ്ക്. ഈ രണ്ട് പ്രോജക്റ്റുകളും ഒരു ഇന്റർമീഡിയറ്റ് അവസ്ഥയിലാണ്, പ്രായോഗികമായി പ്രവർത്തനരഹിതമാണ്, പക്ഷേ ഒരു നല്ല ആരംഭ പോയിന്റായി വർത്തിക്കും;
• PHP: ലിങ്ക് - വളരെ പൂർണ്ണമല്ല, ഏറ്റവും പുതിയ API മാറ്റങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടില്ല, എന്നാൽ ഇത് ഉപയോഗിക്കുന്ന പ്രോജക്റ്റുകൾ എനിക്കറിയാം.

JavaScript, Java എന്നിവ ഒഴികെ, ക്ലയന്റ് ലൈബ്രറികൾ Camunda ഉൽപ്പന്നത്തിന്റെ തന്നെ ഭാഗമല്ല. കാമുണ്ടയുടെ എല്ലാ REST API ഫീച്ചറുകളേയും അവർ പിന്തുണയ്ക്കുമെന്ന് പ്രതീക്ഷിക്കരുത്. ഒരു ലൈബ്രറി ഒരു നിശ്ചിത ഫംഗ്‌ഷൻ നൽകാത്തതിനാൽ അത് അവിടെ ഇല്ലെന്ന് അർത്ഥമാക്കുന്നില്ല, എപ്പോഴും കാമുണ്ടയുടെ REST API പരിശോധിക്കുക. റഫറൻസ് പ്രോജക്റ്റുകൾ ഒരു ആരംഭ പോയിന്റായും ടെംപ്ലേറ്റായും ലൈബ്രറികളെ ഉപയോഗിക്കുന്നു.

സി # ഉദാഹരണം

മുകളിലുള്ള ക്ലയന്റ് ലൈബ്രറി ഉപയോഗിച്ച്, നമുക്ക് ലളിതമായി എഴുതാം:

  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 standalone WAR" ഉള്ള ഇഷ്‌ടാനുസൃത ഡോക്കർ ചിത്രം

കാമുണ്ടയിൽ നിന്ന് മുൻകൂട്ടി നിർമ്മിച്ച ഡോക്കർ ചിത്രത്തിന് പകരമായി, നിങ്ങൾക്ക് സ്വയം ടോംകാറ്റ് തയ്യാറാക്കാം (ഉദാഹരണത്തിന്, ഔദ്യോഗിക ഡോക്കർ ടോംകാറ്റ് ചിത്രങ്ങളെ അടിസ്ഥാനമാക്കി) തുടർന്ന് WAR ഫയലുകളിൽ ഒന്നായി കാമുണ്ട അതിലേക്ക് പകർത്തുക.

നിങ്ങൾക്ക് നിരവധി അധിക ആവശ്യകതകളുണ്ടെങ്കിൽ ഒരു Java ബിൽഡ് എൻവയോൺമെന്റ് സജ്ജീകരിക്കാൻ കഴിയുമെങ്കിൽ, നിങ്ങൾക്ക് Camunda Standalone War സജ്ജീകരിക്കാനും കഴിയും. ഈ ഉദാഹരണങ്ങളിൽ പോലെ ഒരു Maven ബിൽഡ് സജ്ജീകരിക്കുക: ബിൽഡ് യുദ്ധ കോൺഫിഗറുമായി മാവൻ അല്ലെങ്കിൽ അസംബ്ലി ഓവർലേ ഉള്ള മാവൻ.

Camunda Tomcat വിതരണം ആരംഭിക്കുന്നു

Camunda Tomcat ഡിസ്ട്രിബ്യൂഷൻ ഡൗൺലോഡ് ചെയ്ത് അൺസിപ്പ് ചെയ്ത് പ്രവർത്തിപ്പിക്കുക എന്നതാണ് മറ്റൊരു ഓപ്ഷൻ. ഇതിന് നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്ന Java Runtime Environment (JRE) മാത്രമേ ആവശ്യമുള്ളൂ. അത് എളുപ്പം ആകാം ഇവിടെ നിന്ന് ഡൗൺലോഡ് ചെയ്യുക.

ഡാറ്റാബേസ് മാറ്റുന്നതിനോ മറ്റെന്തെങ്കിലും ചെയ്യുന്നതിനോ നിങ്ങൾ ടോംകാറ്റ് കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട് ഡോക്യുമെന്റേഷനിൽ വിവരിച്ചിരിക്കുന്നു. ടോംകാറ്റ് സങ്കീർണ്ണമാണെന്ന് എനിക്കറിയാം, പക്ഷേ ഇത് യഥാർത്ഥത്തിൽ വളരെ ലളിതമാണ്. ഈ പ്രക്രിയയിൽ ആവശ്യമായി വന്നേക്കാവുന്ന എല്ലാത്തിനും ഉത്തരങ്ങൾ Google-ന് അറിയാം.

ടോംകാറ്റ് ഉപയോഗിച്ച് കാമുണ്ട പ്രവർത്തിപ്പിക്കുന്നു

ടോംകാറ്റ് സ്വയം സജ്ജീകരിച്ച് അതിൽ കാമുണ്ട ഇൻസ്റ്റാൾ ചെയ്യുക എന്നതാണ് അവസാന ബദൽ, ഇൻസ്റ്റാളേഷൻ വിവരണം പിന്തുടരുന്നു. നിങ്ങൾ ഇഷ്ടപ്പെടുന്ന ടോംകാറ്റിന്റെ ഏത് പതിപ്പും ഉപയോഗിക്കാൻ ഇത് നിങ്ങൾക്ക് ഓപ്‌ഷൻ നൽകും, അല്ലെങ്കിൽ ഒരു വിൻഡോസ് സേവനമായി ഇൻസ്റ്റാൾ ചെയ്യുക.

ഉൽപ്പാദനത്തിലേക്ക് കാമുണ്ട സമാരംഭിക്കുന്നു

ഇതിന് സാധാരണയായി Camunda പ്രവർത്തിപ്പിക്കുന്നതിന് ചില അന്തിമ സജ്ജീകരണം ആവശ്യമാണ്. ഇത് വളരെ വിശദമായി വിവരിക്കുന്ന മാർഗ്ഗനിർദ്ദേശങ്ങൾ കാമുണ്ടയിൽ ഉണ്ട്, എന്നാൽ ഈ ലേഖനത്തിൽ ഞാൻ അവയിലേക്ക് കടക്കില്ല - ഞാൻ ഒരു ഉദാഹരണം മാത്രമേ നൽകൂ: ഡിഫോൾട്ടായി പ്രാമാണീകരണത്തിനായി വിതരണത്തിന്റെ REST API കോൺഫിഗർ ചെയ്തിട്ടില്ല. നിങ്ങൾ ഇത് മാറ്റാൻ ആഗ്രഹിച്ചേക്കാം.

സംഗ്രഹിക്കുന്നു

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, നിങ്ങൾ ഉപയോഗിക്കുന്ന ഭാഷ പരിഗണിക്കാതെ തന്നെ Camunda ഉപയോഗിച്ച് ആരംഭിക്കുന്നത് വളരെ എളുപ്പമാണ്. എല്ലാ ഇടപെടലുകളും REST API വഴിയാണ് ചെയ്യുന്നത് എന്നതാണ് പ്രധാന കാര്യം. ഇൻസ്റ്റാളേഷനും വളരെ എളുപ്പമാണ്, പ്രത്യേകിച്ച് ഡോക്കർ ഉപയോഗിക്കുമ്പോൾ.

അവലംബം: www.habr.com