การใช้ Camunda เพื่อการประสานที่ง่ายดายโดยใช้ REST และ Workflow Engine (ไม่มี Java)

เฮ้ ฮับ! ฉันขอเสนอการแปลบทความให้คุณทราบ “ใช้ Camunda เป็นเครื่องมือจัดระเบียบและเวิร์กโฟลว์ที่ใช้ REST ที่ใช้งานง่าย (โดยไม่ต้องแตะ Java)” โดย Bernd Rücker.

07.07.2020/XNUMX/XNUMX แปล บทความ แบร์นด์ รัคเกอร์

ฉันมักจะพูดคุยเกี่ยวกับสถาปัตยกรรมไมโครเซอร์วิสกับคนที่ไม่ใช่ Java: นักพัฒนา C#, Node.JS/JavaScript หรือผู้ที่ชื่นชอบ Golang พวกเขาทั้งหมดต้องเผชิญกับความจริงที่ว่าพวกเขาต้องการกลไกการประสานในสถาปัตยกรรมไมโครเซอร์วิสหรือเพียงเครื่องมือเพื่อเพิ่มประสิทธิภาพเวิร์กโฟลว์และได้รับความสามารถในการสั่งซื้อ จัดการการหมดเวลา Saga และการชดเชยธุรกรรม

แพลตฟอร์ม BPM ด้วย โอเพ่นซอร์สจาก Camunda เหมาะสำหรับงานดังกล่าว ความเป็นมิตรของนักพัฒนาเป็นหนึ่งในคุณสมบัติหลักของผลิตภัณฑ์ แต่ถ้าคุณดูเอกสารของมัน คุณอาจรู้สึกว่าความเป็นมิตรของ Camunda มุ่งเป้าไปที่นักพัฒนา Java เป็นหลัก แพลตฟอร์มนี้มอบโอกาสมากมายในการเชื่อมต่อฟังก์ชันและส่วนขยายของคุณเอง แต่ทั้งหมดนี้ทำได้ใน Java จริงเหรอ?

เลขที่! ในความเป็นจริง คุณสามารถรัน Camunda ได้อย่างง่ายดายโดยไม่ต้องมีความรู้ Java และกำหนดค่าสถาปัตยกรรมให้เขียนโค้ดในภาษาใดก็ได้ที่คุณเลือก ในบทความนี้เราจะดูที่:

• สถาปัตยกรรมพื้นฐาน
• ส่วนที่เหลือ API;
• คำแนะนำเกี่ยวกับไลบรารีไคลเอนต์ที่มีอยู่สำหรับภาษาอื่นที่ไม่ใช่ Java
• ตัวอย่างการใช้ C# และ Node.JS
• วิธีเรียกใช้เซิร์ฟเวอร์ Camunda (Docker หรือ Tomcat)

สถาปัตยกรรม

Camunda เขียนด้วยภาษา Java และต้องใช้ Java Virtual Machine (JVM) เพื่อทำงาน Camunda มี REST API ที่ให้คุณเขียนเป็นภาษาใดก็ได้ที่คุณต้องการ และใช้ REST กับ Camunda:

เวิร์กโฟลว์ใน Camunda ถูกกำหนดไว้ใน BPMN ซึ่งโดยพื้นฐานแล้วคือไฟล์ XML สามารถใช้สร้างแบบจำลองได้ คามันด้า โมเดลเลอร์.

ใช้งาน 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 คุณสามารถเปลี่ยนแปลงได้อย่างง่ายดาย ไฟล์นักเทียบท่า.

อย่างไรก็ตาม มีข้อเสียประการหนึ่งในการรัน 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)

ดังนั้นก่อนอื่นคุณต้องทำ ดึงข้อมูลและล็อค (เนื่องจากพนักงานคนอื่นสามารถรับงานพร้อมกันเพื่อปรับขนาดระบบได้):

  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: ลิงค์. สนับสนุนโดย Camunda;
• Java: ลิงค์. สนับสนุนโดย Camunda;
• ค#:ลิงค์ и ลิงค์. โครงการทั้งสองนี้อยู่ในสถานะขั้นกลางและแทบไม่มีกิจกรรมใด ๆ แต่สามารถใช้เป็นจุดเริ่มต้นที่ดีได้
• PHP: ลิงค์ ไม่ใช่ไลบรารีที่สมบูรณ์มากนักและไม่มีการเปลี่ยนแปลง API ล่าสุด แต่ฉันรู้จักโปรเจ็กต์ที่ใช้งาน

ไลบรารีไคลเอ็นต์ไม่ได้เป็นส่วนหนึ่งของผลิตภัณฑ์ Camunda ยกเว้น JavaScript และ Java อย่าคาดหวังว่าพวกเขาจะรองรับฟีเจอร์ทั้งหมดของ 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 build ได้ คุณยังสามารถกำหนดค่า Camunda Standalone war ได้อีกด้วย ตั้งค่า Maven build ดังตัวอย่างต่อไปนี้: build Maven พร้อมโครงแบบสงคราม หรือการประกอบ Maven พร้อมโอเวอร์เลย์.

เปิดตัวการจัดจำหน่าย Camunda Tomcat

อีกทางเลือกหนึ่งคือเพียงดาวน์โหลดการกระจาย Camunda Tomcat แตกไฟล์แล้วรัน ในการดำเนินการนี้ คุณจะต้องติดตั้ง Java Runtime Environment (JRE) บนคอมพิวเตอร์ของคุณเท่านั้น ก็สามารถได้อย่างง่ายดาย ดาวน์โหลดจากที่นี่.

หากต้องการเปลี่ยนฐานข้อมูลหรือทำอะไรก็ตาม คุณต้องกำหนดค่า Tomcat เช่น อธิบายไว้ในเอกสารประกอบ. ฉันรู้ว่า Tomcat อาจดูซับซ้อน แต่จริงๆ แล้วง่ายมาก และ Google ก็มีคำตอบให้กับทุกสิ่งที่คุณต้องการในกระบวนการนี้

ใช้งาน Camunda โดยใช้ Tomcat

ทางเลือกสุดท้ายคือการกำหนดค่า Tomcat ด้วยตัวเองและติดตั้ง Camunda ในนั้น ตามคำอธิบายการติดตั้ง. นี่จะทำให้คุณมีโอกาสใช้ Tomcat เวอร์ชันใดก็ได้ที่คุณต้องการ หรือติดตั้งเป็นบริการ Windows เป็นต้น

เปิดตัว Camunda สู่การผลิต

โดยปกติ คุณจะต้องทำการตั้งค่าขั้นสุดท้ายเพื่อให้ Camunda ทำงาน Camunda มีแนวทางที่อธิบายสิ่งนี้โดยละเอียด แต่ฉันจะไม่พูดถึงมันในบทความนี้ - ฉันจะยกตัวอย่างหนึ่ง: REST API ของการแจกจ่ายไม่ได้รับการกำหนดค่าสำหรับการรับรองความถูกต้องตามค่าเริ่มต้น คุณอาจต้องการเปลี่ยนสิ่งนี้

ข้อสรุปขึ้น

ดังที่คุณอาจสังเกตเห็นแล้วว่าการเริ่มต้นใช้งาน Camunda นั้นง่ายมาก ไม่ว่าคุณจะใช้ภาษาใดก็ตาม ประเด็นสำคัญคือการสื่อสารทั้งหมดดำเนินการผ่าน REST API การติดตั้งก็ค่อนข้างง่าย โดยเฉพาะเมื่อใช้ Docker

ที่มา: will.com