კამუნდას გამოყენება მარტივი ორკესტრირებისთვის REST და Workflow Engine-ზე დაფუძნებული (არა ჯავა)

ჰეი ჰაბრ! თქვენს ყურადღებას წარმოგიდგენთ სტატიის თარგმანს „გამოიყენე კამუნდა, როგორც ადვილად გამოსაყენებელი REST-ზე დაფუძნებული ორკესტრირება და სამუშაო პროცესის ძრავა (ჯავას შეხების გარეშე)“ ბერნდ რიკერის მიერ.

07.07.2020/XNUMX/XNUMX, თარგმანი მუხლი ბერნდ რიკერი

მე ხშირად განვიხილავ მიკროსერვისის არქიტექტურას არა Java ადამიანებთან: C#, Node.JS/JavaScript დეველოპერებთან ან Golang-ის მოყვარულებთან. ყველა მათგანს ემუქრება ის ფაქტი, რომ მათ ესაჭიროებათ საორკესტრო ძრავა მიკროსერვისის არქიტექტურაში ან უბრალოდ ინსტრუმენტი სამუშაო ნაკადის ოპტიმიზაციისა და შეკვეთის, დროის გატარების, საგასა და ტრანზაქციების კომპენსაციის უნარის მოსაპოვებლად.

BPM პლატფორმა ღია წყარო კამუნდასგან შესანიშნავია ასეთი ამოცანებისთვის. დეველოპერის კეთილგანწყობა პროდუქტის ერთ-ერთი მთავარი მახასიათებელია. მაგრამ თუ გადახედავთ მის დოკუმენტაციას, შეიძლება შეგექმნათ შთაბეჭდილება, რომ კამუნდას კეთილგანწყობა ძირითადად Java-ის დეველოპერებზეა მიმართული. პლატფორმა უამრავ შესაძლებლობას იძლევა საკუთარი ფუნქციების და გაფართოებების დასაკავშირებლად, მაგრამ ეს ყველაფერი კეთდება Java-ში. მართლა?

არა! ფაქტობრივად, თქვენ შეგიძლიათ მარტივად გაუშვათ Camunda Java-ს ცოდნის გარეშე და დააკონფიგურიროთ არქიტექტურა თქვენი არჩევანის ნებისმიერ ენაზე კოდირებისთვის. ამ სტატიაში ჩვენ განვიხილავთ:

• ძირითადი არქიტექტურა;
• REST API;
• რჩევები არსებული კლიენტების ბიბლიოთეკების შესახებ Java-ს გარდა სხვა ენებისთვის;
• C# და Node.JS გამოყენების მაგალითი;
• Camunda სერვერის (Docker ან Tomcat) გაშვების გზები.

არქიტექტურა

Camunda დაწერილია ჯავაში და გასაშვებად მოითხოვს Java ვირტუალურ მანქანას (JVM). Camunda გთავაზობთ REST API-ს, რომელიც საშუალებას გაძლევთ დაწეროთ თქვენთვის სასურველ ენაზე და გამოიყენოთ REST კამუნდასთან ერთად:

კამუნდაში სამუშაო ნაკადები განისაზღვრება BPMN-ში, რომელიც ძირითადად XML ფაილია. მისი მოდელირება შესაძლებელია გამოყენებით კამუნდა მოდელიერი.

კამუნდას გაშვება წინასწარ ჩაშენებული Docker გამოსახულების მეშვეობით

კამუნდას გაშვების უმარტივესი გზაა Docker-ის გამოყენება. კამუნდას გაშვების ალტერნატიული გზები აღწერილია ამ სტატიაში მოგვიანებით.

ამ შემთხვევაში, უბრალოდ გაუშვით:

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

თქვენ არ უნდა ინერვიულოთ Linux-ზე, Java-ის ვირტუალურ მანქანებზე ან Tomcats-ზე. Dockerfiles და ძირითადი დოკუმენტაცია (მაგალითად, საჭირო მონაცემთა ბაზებთან დაკავშირების ინსტრუქციები) ხელმისაწვდომია აქ Github.

თუ გსურთ გაუშვათ Camunda Enterprise Edition, შეგიძლიათ მარტივად შეცვალოთ dockerfile.

თუმცა, არის ერთი უარყოფითი მხარე კამუნდას დოკერის გამოყენებით გაშვებაში: თქვენ მიიღებთ Tomcat-ის ვერსიას, რომელიც ყოველთვის არ შეიცავს უახლეს გამოსწორებებს. ამის თავიდან ასაცილებლად, შეგიძლიათ თავად შექმნათ Docker გამოსახულება სასურველი Tomcat განაწილების საფუძველზე, როგორც ეს ნაჩვენებია ამ მაგალითში, ან გამოიყენოთ ქვემოთ აღწერილი ერთ-ერთი გადაწყვეტა.

პროცესის მოდელის დანერგვა

მოდით შევხედოთ მაგალითს საგას შაბლონის გამოყენებით კლასიკური სამოგზაურო დაჯავშნისთვის, სადაც გსურთ ზედიზედ სამი მოქმედების ჩართვა და მოხდენილი ანაზღაურება წარმატებული ქმედებების შემდეგ წარუმატებლობის შემთხვევაში. 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

შემდეგი საინტერესო კითხვა არის როგორ ააქტიურებს კამუნდა პროცედურებს, როგორიცაა მანქანის დაჯავშნა? კამუნდას შეუძლია არა მხოლოდ დაუყოვნებლივ დარეკოს სერვისები (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

მაშინ ეს უთხარი კამუნდას მუშამ დაასრულა სამუშაო (გაითვალისწინეთ, რომ პირველ მოთხოვნაში მიღებული გარე ამოცანის ID უნდა შეიყვანოთ):

  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. მაგრამ ამას დრო დასჭირდება. ასე რომ, შეგიძლიათ უბრალოდ გამოიყენოთ კლიენტის ბიბლიოთეკა.

ამჟამად ხელმისაწვდომია რამდენიმე მზა კლიენტის ბიბლიოთეკა:

• Javascript: ლინკები. კამუნდას მხარდაჭერით;
• ჯავა: ლინკები. კამუნდას მხარდაჭერით;
• C #:ლინკები и ლინკები. ორივე ეს პროექტი შუალედურ მდგომარეობაშია და პრაქტიკულად არ გააჩნია აქტივობა, მაგრამ შეიძლება იყოს კარგი საწყისი წერტილი;
• PHP: ლინკები არ არის ძალიან სრული ბიბლიოთეკა და არ შეიცავს უახლეს API ცვლილებებს, მაგრამ მე ვიცი პროექტები, რომლებიც მას იყენებენ.

JavaScript-ისა და Java-ს გარდა, კლიენტის ბიბლიოთეკები არ არის თავად კამუნდას პროდუქტის ნაწილი. ნუ მოელით, რომ მათ მხარი დაუჭირონ 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 standalone WAR"-ით

როგორც Camunda-დან წინასწარ ჩაშენებული Docker გამოსახულების ალტერნატივა, შეგიძლიათ თავად მოამზადოთ Tomcat (მაგალითად, ოფიციალური Docker Tomcat სურათების საფუძველზე) და შემდეგ დააკოპიროთ Camunda მასში, როგორც ე.წ. WAR ფაილი.

თუ თქვენ გაქვთ ბევრი დამატებითი მოთხოვნა და შეგიძლიათ Java-ს კონსტრუქციის გარემოს მორგება, ასევე შეგიძლიათ Camunda Standalone War-ის კონფიგურაცია. დააყენეთ Maven build, როგორც ამ მაგალითებში: build Maven ომის კონფიგურაციით ან შეკრება Maven ერთად Overlay.

Camunda Tomcat-ის დისტრიბუციის გაშვება

კიდევ ერთი ვარიანტია უბრალოდ ჩამოტვირთოთ Camunda Tomcat დისტრიბუცია, გახსენით იგი და გაუშვით. ამისათვის საჭიროა მხოლოდ Java Runtime Environment (JRE) დაინსტალირებული თქვენს კომპიუტერში. ეს შეიძლება იყოს მარტივად ჩამოტვირთეთ აქედან.

მონაცემთა ბაზის შესაცვლელად ან სხვა რამის გასაკეთებლად საჭიროა Tomcat like-ის კონფიგურაცია აღწერილია დოკუმენტაციაში. მე ვიცი, რომ Tomcat შეიძლება რთული ჩანდეს, მაგრამ სინამდვილეში ეს ძალიან მარტივია. და Google-ს აქვს პასუხები ყველაფერზე, რაც შეიძლება დაგჭირდეთ ამ პროცესში.

კამუნდას გაშვება Tomcat-ის გამოყენებით

ბოლო ალტერნატივა არის Tomcat-ის კონფიგურაცია და მასში Camunda-ს დაყენება. ინსტალაციის აღწერილობის შემდეგ. ეს მოგცემთ შესაძლებლობას გამოიყენოთ Tomcat-ის თქვენთვის სასურველი ნებისმიერი ვერსია, ან, მაგალითად, დააინსტალიროთ Windows სერვისად.

კამუნდას წარმოებაში გაშვება

როგორც წესი, ამისთვის დაგჭირდებათ საბოლოო დაყენების გაკეთება კამუნდას გასაშვებად. კამუნდას აქვს გაიდლაინები, რომლებიც აღწერს ამას ძალიან დეტალურად, მაგრამ მე მათ ამ სტატიაში არ შევეხები - მხოლოდ ერთ მაგალითს მოვიყვან: დისტრიბუციის REST API არ არის კონფიგურირებული ავტორიზაციისთვის ნაგულისხმევად. თქვენ შეიძლება გსურთ შეცვალოთ ეს.

შემაჯამებელი-up

როგორც თქვენ შენიშნეთ, კამუნდასთან მუშაობის დაწყება ძალიან მარტივია, მიუხედავად იმისა, თუ რა ენას იყენებთ. მთავარი ის არის, რომ ყველა კომუნიკაცია ხდება REST API-ის მეშვეობით. ინსტალაცია ასევე საკმაოდ მარტივია, განსაკუთრებით Docker-ის გამოყენებისას.

წყარო: www.habr.com