REST మరియు వర్క్‌ఫ్లో ఇంజిన్ ఆధారంగా సులభమైన ఆర్కెస్ట్రేషన్ కోసం Camundaని ఉపయోగించడం (జావా లేదు)

హే హబ్ర్! వ్యాసం యొక్క అనువాదాన్ని నేను మీ దృష్టికి అందిస్తున్నాను "Camundaని ఉపయోగించడానికి సులభమైన REST-ఆధారిత ఆర్కెస్ట్రేషన్ మరియు వర్క్‌ఫ్లో ఇంజిన్‌గా ఉపయోగించండి (జావాను తాకకుండా)" బెర్న్డ్ రూకర్ ద్వారా.

07.07.2020/XNUMX/XNUMX, అనువాదం వ్యాసాలు బెర్న్డ్ రూకర్

నేను తరచుగా నాన్-జావా వ్యక్తులతో మైక్రోసర్వీస్ ఆర్కిటెక్చర్ గురించి చర్చిస్తాను: C# డెవలపర్లు, Node.JS/JavaScript డెవలపర్లు లేదా గోలాంగ్ అభిమానులు. వారందరికీ మైక్రోసర్వీస్ ఆర్కిటెక్చర్‌లో ఆర్కెస్ట్రేషన్ మెకానిజం అవసరం లేదా వర్క్‌ఫ్లోను క్రమబద్ధీకరించడానికి మరియు ఆర్డర్, టైమ్‌అవుట్‌లు, సాగా మరియు నష్టపరిహారం లావాదేవీలను నిర్వహించే సామర్థ్యాన్ని పొందే సాధనం అవసరం అనే వాస్తవాన్ని ఎదుర్కొంటున్నారు.

తో BPM ప్లాట్‌ఫారమ్ Camunda నుండి ఓపెన్ సోర్స్ అటువంటి పనులకు గొప్పది. డెవలపర్ స్నేహపూర్వకత అనేది ఉత్పత్తి యొక్క ముఖ్య లక్షణాలలో ఒకటి. కానీ మీరు దాని డాక్యుమెంటేషన్‌ను చూస్తే, కాముండా యొక్క "స్నేహపూర్వకత" ప్రధానంగా జావా డెవలపర్‌లను లక్ష్యంగా చేసుకున్నట్లు మీరు అభిప్రాయాన్ని పొందవచ్చు. ప్లాట్‌ఫారమ్ మీ స్వంత ఫంక్షన్‌లు మరియు పొడిగింపులను కనెక్ట్ చేయడానికి చాలా ఎంపికలను అందిస్తుంది, అయితే ఇవన్నీ జావాలో చేయబడతాయి. ఇది నిజంగా ఉందా?

లేదు! వాస్తవానికి, మీరు ఎటువంటి జావా పరిజ్ఞానం లేకుండా సులభంగా Camundaని అమలు చేయవచ్చు మరియు మీకు నచ్చిన ఏ భాషలోనైనా కోడ్ కోసం నిర్మాణాన్ని సెటప్ చేయవచ్చు. ఈ వ్యాసంలో, మేము పరిశీలిస్తాము:

• ప్రాథమిక నిర్మాణం;
• REST API
• జావా కాకుండా ఇతర భాషల కోసం ఇప్పటికే ఉన్న క్లయింట్ లైబ్రరీలపై సలహా;
• ఉదాహరణకు C# మరియు Node.JS ఉపయోగించి;
• Camunda సర్వర్‌ను ప్రారంభించడానికి మార్గాలు (డాకర్ లేదా టామ్‌క్యాట్).

నిర్మాణం

Camunda జావాలో వ్రాయబడింది మరియు అమలు చేయడానికి జావా వర్చువల్ మెషిన్ (JVM) అవసరం. Camunda మీకు నచ్చిన భాషలో వ్రాయడానికి మరియు Camundaతో RESTని ఉపయోగించడానికి అనుమతించే REST APIని అందిస్తుంది:

Camundaలోని వర్క్‌ఫ్లోలు BPMNలో నిర్వచించబడ్డాయి, ఇది ప్రాథమికంగా XML ఫైల్. దీనితో మోడల్ చేయవచ్చు కముండా మోడలర్.

ముందుగా నిర్మించిన డాకర్ చిత్రం ద్వారా Camundaని అమలు చేస్తోంది

Camundaని అమలు చేయడానికి సులభమైన మార్గం డాకర్‌ని ఉపయోగించడం. Camunda ప్రారంభించటానికి ప్రత్యామ్నాయ మార్గాలు ఈ వ్యాసంలో తరువాత వివరించబడ్డాయి.

ఈ సందర్భంలో, కేవలం అమలు చేయండి:

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

మీరు Linux, JVMలు లేదా Tomcats గురించి ఆందోళన చెందాల్సిన అవసరం లేదు. డాకర్ ఫైల్స్ మరియు ప్రాథమిక డాక్యుమెంటేషన్ (ఉదాహరణకు, అవసరమైన డేటాబేస్‌లకు కనెక్ట్ చేయడానికి సూచనలు) అందుబాటులో ఉన్నాయి Github.

మీరు Camunda Enterprise ఎడిషన్‌ని అమలు చేయాలనుకుంటే మీరు సులభంగా మార్చవచ్చు Dockerfile.

అయితే, డాకర్‌తో క్యాముండాను అమలు చేయడంలో ఒక ప్రతికూలత ఉంది: మీరు ఎల్లప్పుడూ తాజా పరిష్కారాలను కలిగి ఉండని టామ్‌క్యాట్ వెర్షన్‌తో ముగుస్తుంది. దీని చుట్టూ పని చేయడానికి, మీరు ఈ ఉదాహరణలో చూపిన విధంగా కావలసిన టామ్‌క్యాట్ పంపిణీ ఆధారంగా మీ స్వంత డాకర్ చిత్రాన్ని సృష్టించవచ్చు లేదా దిగువ వివరించిన పరిష్కారాలలో ఒకదాన్ని ఉపయోగించవచ్చు.

ప్రక్రియ నమూనా విస్తరణ

క్లాసిక్ ట్రిప్ బుకింగ్ కోసం సాగా టెంప్లేట్‌ని ఉపయోగించి ఒక ఉదాహరణను చూద్దాం, ఇక్కడ మీరు వరుసగా మూడు చర్యలను ట్రిగ్గర్ చేయాలనుకుంటున్నారు మరియు తరువాత విఫలమైతే విజయవంతంగా పూర్తి చేసిన చర్యలకు మనోహరంగా పరిహారం చెల్లించాలి. BPMN రూపంలో ప్రాతినిధ్యం వహిస్తుంది, ఇది ఇలా కనిపిస్తుంది:

ఇప్పుడు మీరు ఉపయోగించవచ్చు ప్రాసెస్ మోడల్ విస్తరణ కోసం REST API. మీరు దీన్ని trip.bpmnగా సేవ్ చేసి, డాకర్ ద్వారా Camundaని అమలు చేయండి, కనుక ఇది 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 కొన్ని అంతర్నిర్మిత ఉపయోగించి సేవలను వెంటనే కాల్ చేయదు (పుష్-ప్రిన్సిపల్). కనెక్టర్లు, కానీ ఒక రకమైన అంతర్నిర్మిత క్రమంలో పని వస్తువులను కూడా ఉంచండి. కార్మికుడు REST ద్వారా పని వస్తువులను పొందవచ్చు, పనిని నిర్వహించవచ్చు మరియు Camundaని పూర్తి చేయమని చెప్పవచ్చు (పుల్-ప్రిన్సిపల్).

కాబట్టి మొదట మీరు అమలు చేయాలి 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కి కాల్ చేయడం సులభం. జావాస్క్రిప్ట్‌లో, ఇది J క్వెరీని ఉపయోగించి మరియు C#లో System.Net.Http మరియు Newtonsoft.Jsonని ఉపయోగించి సౌకర్యవంతంగా చేయబడుతుంది. అయితే దీనికి సమయం పడుతుంది. కాబట్టి మీరు కొన్ని క్లయింట్ లైబ్రరీని ఉపయోగించవచ్చు.

ప్రస్తుతం, అనేక రెడీమేడ్ క్లయింట్ లైబ్రరీలు అందుబాటులో ఉన్నాయి:

• జావాస్క్రిప్ట్: ссылка. కాముండా మద్దతు;
• జావా: ссылка. కాముండా మద్దతు;
• సి #:ссылка и ссылка. ఈ రెండు ప్రాజెక్టులు ఇంటర్మీడియట్ స్థితిలో ఉన్నాయి మరియు ఆచరణాత్మకంగా నిద్రాణస్థితిలో ఉన్నాయి, కానీ మంచి ప్రారంభ స్థానంగా ఉపయోగపడతాయి;
• PHP: ссылка - చాలా పూర్తి కాదు మరియు తాజా API మార్పులను చేర్చలేదు, కానీ దానిని ఉపయోగించే ప్రాజెక్ట్‌లు నాకు తెలుసు.

జావాస్క్రిప్ట్ మరియు జావా మినహా, క్లయింట్ లైబ్రరీలు కాముండా ఉత్పత్తిలో భాగం కావు. వారు Camunda యొక్క అన్ని REST API ఫీచర్‌లకు మద్దతు ఇస్తారని ఆశించవద్దు. లైబ్రరీ నిర్దిష్ట ఫీచర్‌ను అందించనందున అది అక్కడ లేదని కాదు, ఎల్లప్పుడూ Camunda యొక్క 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 నుండి ముందుగా నిర్మించిన డాకర్ చిత్రానికి ప్రత్యామ్నాయంగా, మీరు టామ్‌క్యాట్‌ను మీరే సిద్ధం చేసుకోవచ్చు (ఉదాహరణకు, అధికారిక డాకర్ టామ్‌క్యాట్ చిత్రాల ఆధారంగా) ఆపై Camundaని WAR ఫైల్‌లు అని పిలవబడే వాటిలో ఒకటిగా కాపీ చేయవచ్చు.

మీకు అనేక అదనపు అవసరాలు ఉంటే మరియు జావా నిర్మాణ వాతావరణాన్ని సెటప్ చేయగలిగితే, మీరు Camunda స్వతంత్ర యుద్ధాన్ని కూడా సెటప్ చేయవచ్చు. ఈ ఉదాహరణలలో వలె మావెన్ బిల్డ్‌ను సెటప్ చేయండి: బిల్డ్ యుద్ధ కాన్ఫిగరేషన్‌తో మావెన్ లేదా అసెంబ్లీ అతివ్యాప్తితో మావెన్.

Camunda Tomcat పంపిణీని ప్రారంభిస్తోంది

Camunda Tomcat పంపిణీని డౌన్‌లోడ్ చేసి, అన్జిప్ చేసి, దాన్ని అమలు చేయడం మరొక ఎంపిక. దీనికి మీ కంప్యూటర్‌లో ఇన్‌స్టాల్ చేయబడిన జావా రన్‌టైమ్ ఎన్విరాన్‌మెంట్ (JRE) మాత్రమే అవసరం. ఇది సులభంగా ఉంటుంది ఇక్కడ నుండి డౌన్‌లోడ్ చేసుకోండి.

డేటాబేస్‌ను మార్చడానికి లేదా ఏదైనా చేయడానికి మీరు టామ్‌క్యాట్‌ను కాన్ఫిగర్ చేయాలి డాక్యుమెంటేషన్‌లో వివరించబడింది. టామ్‌క్యాట్ సంక్లిష్టంగా అనిపించవచ్చని నాకు తెలుసు, కానీ నిజానికి ఇది చాలా సులభం. మరియు ప్రక్రియలో అవసరమైన ప్రతిదానికీ సమాధానాలు Googleకి తెలుసు.

టామ్‌క్యాట్‌ని ఉపయోగించి కాముండాను నడుపుతోంది

చివరి ప్రత్యామ్నాయం టామ్‌క్యాట్‌ని మీరే సెటప్ చేసి, అందులో కముండాను ఇన్‌స్టాల్ చేయడం, సంస్థాపన వివరణను అనుసరించి. ఇది మీరు ఇష్టపడే టామ్‌క్యాట్ వెర్షన్‌ను ఉపయోగించడానికి లేదా ఉదాహరణకు విండోస్ సర్వీస్‌గా ఇన్‌స్టాల్ చేయడానికి మీకు ఎంపికను ఇస్తుంది.

కాముండాను ఉత్పత్తిలోకి లాంచ్ చేస్తోంది

ఇది సాధారణంగా Camundaని అమలు చేయడానికి కొంత తుది సెటప్ అవసరం. Camundaలో దీన్ని చాలా వివరంగా వివరించే మార్గదర్శకాలు ఉన్నాయి, కానీ నేను ఈ కథనంలో వాటి జోలికి వెళ్లను - నేను కేవలం ఒక ఉదాహరణకి పేరు పెడతాను: పంపిణీ యొక్క REST API డిఫాల్ట్‌గా ప్రమాణీకరణ కోసం కాన్ఫిగర్ చేయబడలేదు. మీరు దీన్ని మార్చాలనుకోవచ్చు.

సారాంశం

మీరు చూడగలిగినట్లుగా, మీరు ఉపయోగిస్తున్న భాషతో సంబంధం లేకుండా Camundaతో ప్రారంభించడం చాలా సులభం. ముఖ్య విషయం ఏమిటంటే, అన్ని పరస్పర చర్య REST API ద్వారా జరుగుతుంది. ఇన్‌స్టాలేషన్ చాలా సులభం, ముఖ్యంగా డాకర్‌ని ఉపయోగిస్తున్నప్పుడు.

మూలం: www.habr.com