🥇Bruke Camunda for enkel orkestrering basert på REST og Workflow Engine (ingen Java)

Hei, Habr! Jeg presenterer for din oppmerksomhet en oversettelse av artikkelen "Bruk Camunda som en brukervennlig REST-basert orkestrerings- og arbeidsflytmotor (uten å berøre Java)" av Bernd Rücker.

07.07.2020/XNUMX/XNUMX, oversettelse artikler Bernd Rucker

Jeg diskuterer ofte mikrotjenestearkitektur med ikke-Java-folk: C#-utviklere, Node.JS/JavaScript-utviklere eller Golang-entusiaster. Alle står overfor det faktum at de trenger en orkestreringsmekanisme i en mikrotjenestearkitektur, eller bare et verktøy for å effektivisere arbeidsflyten og få muligheten til å bestille, håndtere timeouts, Saga og kompenserende transaksjoner.

BPM-plattform med åpen kildekode fra Camunda flott for slike oppgaver. Utviklervennlighet er en av nøkkelegenskapene til produktet. Men hvis du ser på dokumentasjonen, kan du få inntrykk av at Camundas "vennlighet" hovedsakelig er rettet mot Java-utviklere. Plattformen gir mange muligheter for å koble til dine egne funksjoner og utvidelser, men det hele gjøres i Java. Er det virkelig?

Nei! Faktisk kan du enkelt kjøre Camunda uten Java-kunnskap og konfigurere arkitekturen til å kode på et hvilket som helst språk du ønsker. I denne artikkelen skal vi se på:

grunnleggende arkitektur;
REST API
råd om eksisterende klientbiblioteker for andre språk enn Java;
eksempel ved å bruke C# og Node.JS;
måter å starte Camunda-serveren på (Docker eller Tomcat).

arkitektur

Camunda er skrevet i Java og krever en Java Virtual Machine (JVM) for å kjøre. Camunda tilbyr en REST API som lar deg skrive på hvilket som helst språk du liker og bruke REST med Camunda:

Arbeidsflyter i Camunda er definert i BPMN, som i utgangspunktet er en XML-fil. Den kan modelleres med Camunda Modeler.

Kjører Camunda gjennom et forhåndsbygd Docker-bilde

Den enkleste måten å kjøre Camunda på er å bruke Docker. Alternative måter å lansere Camunda på er beskrevet senere i denne artikkelen.

I dette tilfellet, bare kjør:

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

Du trenger ikke å bekymre deg for Linux, JVMs eller Tomcats. Dockerfiler og grunnleggende dokumentasjon (for eksempel instruksjoner for tilkobling til nødvendige databaser) er tilgjengelig på Github.

Hvis du vil kjøre Camunda Enterprise Edition kan du enkelt endre Dockerfile.

Å kjøre Camunda med Docker har imidlertid én ulempe: du vil ende opp med en versjon av Tomcat som ikke alltid inkluderer de siste rettelsene. For å omgå dette kan du lage ditt eget Docker-bilde basert på ønsket Tomcat-distribusjon, som vist i dette eksemplet, eller bruke en av løsningene beskrevet nedenfor.

Prosessmodellimplementering

La oss se på et eksempel ved å bruke Saga-malen for en klassisk reisebestilling der du ønsker å utløse tre handlinger på rad og elegant kompensere vellykkede handlinger i tilfelle en senere feil. Presentert i BPMN-form ser det slik ut:

Nå kan du bruke REST API for distribusjon av prosessmodeller. La oss si at du lagrer den som trip.bpmn og kjører Camunda via Docker slik at den er tilgjengelig 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

Nå kan du løpe nye arbeidsflytforekomster ved å bruke REST API og sende dataene du vil se som arbeidsflytforekomstvariabler:

  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

Det neste interessante spørsmålet er: hvordan kaller Camunda prosedyrer som å bestille en bil? Camunda kan ikke bare ringe tjenester umiddelbart (Push-Principle) ved hjelp av noe innebygd koblinger, men også sette arbeidselementer i en slags innebygd rekkefølge. Arbeideren kan deretter hente arbeidselementer via REST, utføre arbeidet og fortelle Camunda å fullføre (Pull-Principle).

Så først må du utføre henteAndLock (fordi andre arbeidere kan motta oppgaver samtidig for å skalere 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å fortell Camunda det arbeider fullførte arbeidet (merk at du må angi den eksterne oppgave-ID-en som ble mottatt i den første forespørselen):

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

Det er det - du har fortsatt ikke trengt noe Java, ikke sant? Og det er nok til å komme i gang!

Klientbiblioteker

Å ringe et REST API er enkelt på alle programmeringsspråk. I JavaScript gjøres dette praktisk ved å bruke JQuery, og i C#, ved å bruke System.Net.Http og Newtonsoft.Json. Men dette vil ta tid. Så du kan bare bruke et klientbibliotek.

For øyeblikket er flere ferdige klientbibliotek tilgjengelig:

Javascript: link. Støttet av Camunda;
Java: link. Støttet av Camunda;
C #:link и link. Begge disse prosjektene er i en mellomtilstand og praktisk talt i dvale, men kan tjene som et godt utgangspunkt;
PHP: link - ikke for komplett og inkluderer ikke de siste API-endringene, men jeg kjenner til prosjekter som bruker det.

Med unntak av JavaScript og Java er ikke klientbibliotekene en del av selve Camunda-produktet. Ikke forvent at de støtter alle Camundas REST API-funksjoner. Bare fordi et bibliotek ikke har en bestemt funksjon, betyr det ikke at det ikke er der, sjekk alltid Camundas REST API. Referanseprosjekter bruker biblioteker som utgangspunkt og mal.

Eksempel med C#

Ved å bruke klientbiblioteket ovenfor kan vi ganske enkelt skrive:

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

Den fullt fungerende kildekoden kan finnes på nettet: link. Et annet eksempel er tilgjengelig på link.

Eksempel 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 informasjon finner du på nettsiden github.com

Alternative måter å lansere Camunda på

Egendefinert Docker-bilde med "Camunda frittstående WAR"

Som et alternativ til et forhåndsbygd Docker-bilde fra Camunda kan du forberede Tomcat selv (for eksempel basert på de offisielle Docker Tomcat-bildene) og deretter kopiere Camunda inn i det som en av de såkalte WAR-filene.

Hvis du har mange tilleggskrav og kan sette opp et Java byggemiljø, kan du også sette opp Camunda Standalone war. Sett opp en Maven-bygg som i disse eksemplene: bygg Maven med krigskonfig eller montering Maven med overlegg.

Starter Camunda Tomcat-distribusjonen

Et annet alternativ er å ganske enkelt laste ned Camunda Tomcat-distribusjonen, pakke den ut og kjøre den. Dette krever bare Java Runtime Environment (JRE) installert på datamaskinen. Det kan være enkelt last ned herfra.

For å endre databasen eller gjøre noe annet må du konfigurere Tomcat som beskrevet i dokumentasjonen. Jeg vet at Tomcat kan høres komplisert ut, men det er faktisk veldig enkelt. Og Google vet svarene på alt som kan kreves i prosessen.

Kjører Camunda med Tomcat

Det siste alternativet er å sette opp Tomcat selv og installere Camunda i den, etter installasjonsbeskrivelsen. Dette vil gi deg muligheten til å bruke hvilken versjon av Tomcat du foretrekker, eller installere den som en Windows-tjeneste, for eksempel.

Lanserer Camunda i produksjon

Dette vil vanligvis kreve noe endelig oppsett for å kjøre Camunda. Det er retningslinjer i Camunda som beskriver dette i stor detalj, men jeg skal ikke gå inn på dem i denne artikkelen – jeg vil bare nevne ett eksempel: distribusjonens REST API er ikke konfigurert for autentisering som standard. Det kan være lurt å endre dette.

Oppsummering

Som du kanskje har lagt merke til, er det veldig enkelt å komme i gang med Camunda, uavhengig av språket du bruker. Nøkkelpunktet er at all kommunikasjon skjer gjennom REST API. Installasjonen er også ganske enkel, spesielt når du bruker Docker.

Kilde: www.habr.com

Bruke Camunda for enkel orkestrering basert på REST og Workflow Engine (ingen Java)