🥇Använda Camunda för enkel REST-baserad orkestrering och Workflow Engine (ingen Java)

Hej, Habr! Jag presenterar för din uppmärksamhet en översättning av artikeln "Använd Camunda som en lättanvänd REST-baserad orkestrerings- och arbetsflödesmotor (utan att röra Java)" av Bernd Rücker.

07.07.2020/XNUMX/XNUMX, översättning Artikel Bernd Rücker

Jag diskuterar ofta mikrotjänstarkitektur med icke-Java-personer: C#, Node.JS/JavaScript-utvecklare eller Golang-entusiaster. Alla ställs inför det faktum att de behöver en orkestreringsmotor i en mikrotjänstarkitektur eller bara ett verktyg för att optimera arbetsflödet och få möjlighet att beställa, hantera timeouts, Saga och kompensera transaktioner.

BPM-plattform med öppen källkod från Camunda bra för sådana uppgifter. Utvecklarvänlighet är en av produktens nyckelegenskaper. Men om man tittar på dess dokumentation kan man få intrycket att Camundas vänlighet främst riktar sig till Java-utvecklare. Plattformen ger många möjligheter att koppla ihop dina egna funktioner och tillägg, men allt görs i Java. Är det verkligen?

Nej! Faktum är att du enkelt kan köra Camunda utan någon Java-kunskap och konfigurera arkitekturen för att koda på valfritt språk. I den här artikeln kommer vi att titta på:

grundläggande arkitektur;
REST API;
råd om befintliga klientbibliotek för andra språk än Java;
exempel på användning av C# och Node.JS;
sätt att köra Camunda-server (Docker eller Tomcat).

Arkitektur

Camunda är skrivet i Java och kräver en Java Virtual Machine (JVM) för att köras. Camunda tillhandahåller ett REST API som låter dig skriva på vilket språk du vill och använda REST med Camunda:

Arbetsflöden i Camunda definieras i BPMN, som i grunden är en XML-fil. Den kan modelleras med hjälp av Camunda Modeler.

Kör Camunda via en förbyggd Docker-bild

Det enklaste sättet att köra Camunda är att använda Docker. Alternativa sätt att köra Camunda beskrivs längre fram i den här artikeln.

I det här fallet kör du bara:

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

Du behöver inte oroa dig för Linux, Java Virtual Machines eller Tomcats. Dockerfiler och grundläggande dokumentation (till exempel instruktioner för att ansluta till de nödvändiga databaserna) finns på Github.

Om du vill köra Camunda Enterprise Edition kan du enkelt byta Dockerfile.

Det finns dock en nackdel med att köra Camunda med Docker: du kommer att få en version av Tomcat som inte alltid innehåller de senaste korrigeringarna. För att komma runt detta på något sätt kan du själv skapa en Docker-bild baserat på den önskade Tomcat-distributionen, som visas i det här exemplet, eller använda någon av lösningarna som beskrivs nedan.

Installera en processmodell

Låt oss titta på ett exempel med Saga-mallen för en klassisk resebokning där du vill utlösa tre åtgärder i rad och graciöst kompensera framgångsrika åtgärder vid ett senare misslyckande. Presenterat i BPMN-form ser det ut så här:

Nu kan du använda REST API för implementering av processmodeller. Låt oss säga att du sparade den som trip.bpmn och körde Camunda via Docker så att den var tillgänglig på 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

Nu kan du springa nya arbetsflödesinstanser använder REST API och skickar de data du vill se som arbetsflödesinstansvariabler:

  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

Nästa intressanta fråga är hur utlöser Camunda procedurer som att boka en bil? Camunda kan inte bara omedelbart ringa tjänster (Push-Principle), med hjälp av vissa inbyggda kontakter, men också lägga arbetsartiklar i en slags inbyggd kö. Arbetaren kan sedan ta emot arbetsobjekt via REST, utföra arbetet och rapportera slutförandet till Camunda (Pull-Principle).

Så först måste du göra hämta AndLock (eftersom andra arbetare kan få uppgifter samtidigt för att skala systemet):

  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

Säg det sedan till Camunda arbetare har avslutat sitt arbete (observera att du måste ange det externa uppgifts-ID som togs emot i den första begäran):

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

Det var allt - du har inte behövt någon Java än så länge, eller hur? Och det räcker för att komma igång!

Klientbibliotek

Att anropa REST API är enkelt i alla programmeringsspråk. I JavaScript är det bekvämt att göra detta med JQuery, och i C# kan du använda System.Net.Http och Newtonsoft.Json. Men det här kommer att ta tid. Så du kan bara använda något klientbibliotek.

Det finns för närvarande flera färdiga klientbibliotek tillgängliga:

javascript: länk. Med stöd av Camunda;
Java: länk. Med stöd av Camunda;
C #:länk и länk. Båda dessa projekt är i ett mellanläge och har praktiskt taget ingen aktivitet, men kan fungera som en bra utgångspunkt;
PHP: länk är inte ett särskilt komplett bibliotek och inkluderar inte de senaste API-ändringarna, men jag känner till projekt som använder det.

Med undantag för JavaScript och Java är klientbibliotek inte en del av själva Camunda-produkten. Förvänta dig inte att de ska stödja alla funktioner i Camundas REST API. Bara för att ett bibliotek inte tillhandahåller en viss funktion betyder det inte att det inte finns där, kolla alltid Camunda REST API. Typiska projekt använder bibliotek som utgångspunkt och mall.

Exempel med C#

Med hjälp av ovanstående klientbibliotek kan vi helt enkelt skriva:

  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", "..." }
    });

Fullständig fungerande källkod kan hittas online: länk. Ett annat exempel finns på länk.

Exempel med 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();

Mer information finns på hemsidan github.com

Alternativa sätt att starta Camunda

Anpassad Docker-bild med "Camunda fristående WAR"

Som ett alternativ till den förbyggda Docker-bilden från Camunda kan du förbereda Tomcat själv (till exempel baserat på de officiella Docker Tomcat-bilderna) och sedan kopiera Camunda in i den som en av de så kallade WAR-filerna.

Om du har många ytterligare krav och kan anpassa en Java-byggmiljö kan du också konfigurera Camunda Fristående krig. Konfigurera ett Maven-bygge som i dessa exempel: bygg Maven med krigskonfiguration eller montering Maven med överlägg.

Lanserar Camunda Tomcat-distributionen

Ett annat alternativ är att helt enkelt ladda ner Camunda Tomcat-distributionen, packa upp den och köra den. För att göra detta behöver du bara Java Runtime Environment (JRE) installerad på din dator. Det kan vara lätt ladda ner härifrån.

För att ändra databasen eller göra något annat måste du konfigurera Tomcat som beskrivs i dokumentationen. Jag vet att Tomcat kan verka komplicerat, men det är faktiskt väldigt enkelt. Och Google har svaren på allt du kan behöva under processen.

Kör Camunda med Tomcat

Det sista alternativet är att konfigurera Tomcat själv och installera Camunda i den, efter installationsbeskrivningen. Detta ger dig möjlighet att använda vilken version av Tomcat du föredrar, eller till exempel installera den som en Windows-tjänst.

Lansering av Camunda i produktion

Vanligtvis kommer detta att kräva att du gör några slutliga inställningar för att få Camunda igång. Camunda har riktlinjer som beskriver detta i detalj, men jag kommer inte att beröra dem i den här artikeln – jag ska bara ge ett exempel: distributionens REST API är inte konfigurerat för autentisering som standard. Du kanske vill ändra detta.

Summering

Som du kanske har märkt är det väldigt enkelt att komma igång med Camunda, oavsett vilket språk du använder. Det viktiga är att all kommunikation sker via REST API. Installationen är också ganska enkel, speciellt när du använder Docker.

Källa: will.com

Använda Camunda för enkel orkestrering baserad på REST och Workflow Engine (ingen Java)