Olá, Habr! Apresento a sua atenção uma tradução do artigo por Bernd Rücker.
07.07.2020/XNUMX/XNUMX, tradução Bernd Rücker
Costumo discutir arquitetura de microsserviços com pessoas que não são Java: desenvolvedores de C#, Node.JS/JavaScript ou entusiastas de Golang. Todos eles se deparam com o fato de que precisam de um mecanismo de orquestração em uma arquitetura de microsserviços ou apenas de uma ferramenta para otimizar o fluxo de trabalho e ganhar a capacidade de solicitar, lidar com timeouts, Saga e compensar transações.
Plataforma BPM com ótimo para tais tarefas. A facilidade de desenvolvimento é um dos principais recursos do produto. Mas se você olhar sua documentação, poderá ter a impressão de que a simpatia do Camunda é voltada principalmente para desenvolvedores Java. A plataforma oferece muitas oportunidades para conectar suas próprias funções e extensões, mas tudo é feito em Java. É realmente?
Não! Na verdade, você pode executar Camunda facilmente sem nenhum conhecimento de Java e configurar a arquitetura para codificar em qualquer linguagem de sua escolha. Neste artigo veremos:
- arquitetura básica;
- API REST;
- aconselhamento sobre bibliotecas clientes existentes para outras linguagens além de Java;
- exemplo de uso de C# e Node.JS;
- maneiras de executar o servidor Camunda (Docker ou Tomcat).
Arquitetura
Camunda é escrito em Java e requer uma Java Virtual Machine (JVM) para funcionar. Camunda fornece uma API REST que permite escrever em qualquer linguagem que desejar e usar REST com Camunda:
Os fluxos de trabalho no Camunda são definidos em BPMN, que é basicamente um arquivo XML. Ele pode ser modelado usando .
Executando Camunda por meio de uma imagem Docker pré-construída
A maneira mais fácil de executar o Camunda é usar o Docker. Formas alternativas de executar o Camunda são descritas posteriormente neste artigo.
Neste caso, basta executar:
docker run -d -p 8080:8080 camunda/camunda-bpm-platform:latest
Você não precisa se preocupar com Linux, Java Virtual Machines ou Tomcats. Dockerfiles e documentação básica (por exemplo, instruções para conexão com os bancos de dados necessários) estão disponíveis em .
Se você deseja executar o Camunda Enterprise Edition, você pode facilmente alterar .
No entanto, há uma desvantagem em executar o Camunda usando Docker: você acabará com uma versão do Tomcat que nem sempre inclui as correções mais recentes. Para contornar isso de alguma forma, você mesmo pode criar uma imagem Docker com base na distribuição desejada do Tomcat, conforme mostrado neste exemplo, ou usar uma das soluções descritas abaixo.
Implantando um modelo de processo
Vejamos um exemplo usando o modelo Saga para uma reserva de viagem clássica em que você deseja acionar três ações consecutivas e compensar normalmente as ações bem-sucedidas no caso de uma falha posterior. Apresentado no formato BPMN, fica assim:
Agora você pode usar . Digamos que você o salvou como trip.bpmn e executou o Camunda via Docker para que estivesse disponível em 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
Agora você pode correr usando a API REST e passando os dados que você deseja ver como variáveis de instância de fluxo de trabalho:
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
A próxima questão interessante é como Camunda aciona procedimentos como reservar um carro? Camunda não só pode chamar serviços imediatamente (Push-Principle), usando alguns recursos integrados , mas também coloca itens de trabalho em uma espécie de fila integrada. O trabalhador pode então receber itens de trabalho via REST, executar o trabalho e relatar a conclusão para Camunda (Pull-Principle).
Então primeiro você precisa fazer (já que outros trabalhadores podem receber tarefas ao mesmo tempo para dimensionar o sistema):
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
Então diga a Camunda que (observe que você deve inserir o ID da tarefa externa recebido na primeira solicitação):
curl
-H "Content-Type: application/json"
-X POST
-d <!-- -->'{"workerId":"worker123", "variables": {}}'<!-- -->
http://localhost:8080/engine-rest/<!-- -->external-task/EXTERNAL_TASK_ID/complete
É isso aí - você não precisou de nenhum Java até agora, certo? E isso é o suficiente para começar!
Bibliotecas de clientes
Chamar a API REST é fácil em qualquer linguagem de programação. Em JavaScript é conveniente fazer isso usando JQuery, e em C# você pode usar System.Net.Http e Newtonsoft.Json. Mas isso levará tempo. Então você pode simplesmente usar alguma biblioteca cliente.
Existem atualmente várias bibliotecas clientes prontas disponíveis:
- JavaScript: . Apoiado por Camunda;
- Java: . Apoiado por Camunda;
- C #: и . Ambos os projectos estão num estado intermédio e praticamente não têm actividade, mas podem servir como um bom ponto de partida;
- PHP: não é uma biblioteca muito completa e não inclui as alterações mais recentes da API, mas conheço projetos que a utilizam.
Com exceção de JavaScript e Java, as bibliotecas clientes não fazem parte do produto Camunda em si. Não espere que eles suportem todos os recursos da API REST do Camunda. Só porque uma biblioteca não oferece um determinado recurso não significa que ela não esteja lá, verifique sempre a API REST do Camunda. Projetos típicos usam bibliotecas como ponto de partida e modelo.
Exemplo com C#
Usando a biblioteca cliente acima, podemos simplesmente escrever:
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", "..." }
});
O código-fonte funcional completo pode ser encontrado online: . Outro exemplo está disponível em .
Exemplo com 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();
Mais informações podem ser encontradas no site
Maneiras alternativas de iniciar Camunda
Imagem Docker personalizada com "Camunda standalone WAR"
Como alternativa à imagem Docker pré-construída do Camunda, você mesmo pode preparar o Tomcat (por exemplo, com base nas imagens oficiais do Docker Tomcat) e depois copiar o Camunda para ele como um dos chamados arquivos WAR.
Se você tiver muitos requisitos adicionais e puder personalizar um ambiente de construção Java, também poderá configurar o War Camunda Standalone. Configure uma compilação Maven como nestes exemplos: build ou montagem .
Lançando a distribuição Camunda Tomcat
Outra opção é simplesmente baixar a distribuição Camunda Tomcat, descompactá-la e executá-la. Para fazer isso, você só precisa do Java Runtime Environment (JRE) instalado em seu computador. Pode ser facilmente .
Para alterar o banco de dados ou fazer qualquer outra coisa você precisa configurar o Tomcat como . Eu sei que o Tomcat pode parecer complicado, mas na verdade é muito simples. E o Google tem as respostas para tudo que você precisa no processo.
Executando Camunda usando Tomcat
A última alternativa é configurar você mesmo o Tomcat e instalar o Camunda nele, . Isso lhe dará a oportunidade de usar qualquer versão do Tomcat de sua preferência ou, por exemplo, instalá-lo como um serviço do Windows.
Lançamento de Camunda em produção
Normalmente, isso exigirá que você faça algumas configurações finais para colocar o Camunda em execução. Camunda tem diretrizes que descrevem isso detalhadamente, mas não vou abordá-las neste artigo - vou apenas dar um exemplo: a API REST da distribuição não está configurada para autenticação por padrão. Você pode querer mudar isso.
Somando-se
Como você deve ter notado, começar a usar o Camunda é muito fácil, independente do idioma que você usa. O ponto principal é que toda a comunicação é feita através da API REST. A instalação também é bastante simples, principalmente ao usar o Docker.
Fonte: habr.com