ProHoster > Blog > Administração > Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Olá, Habr! Apresento a vocês a tradução do artigo «Use Camunda como uma engine de orquestração e fluxo de trabalho baseada em REST fácil de usar (sem tocar em Java)» autor Bernd Rücker.

07.07.2020, tradução artigo Bernd Rücker

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Eu frequentemente discuto arquitetura de microsserviços com pessoas que estão distantes de Java: desenvolvedores C#, Node.JS/JavaScript ou fãs de Golang. Todos eles se deparam com a necessidade de um mecanismo de orquestração em uma arquitetura de microsserviços ou simplesmente uma ferramenta para otimizar o fluxo de trabalho e obter a capacidade de ordenar, lidar com timeouts, gerenciar Sagas e transações compensatórias.

A plataforma BPM de código aberto da Camunda é excelente para essas tarefas. A amigabilidade para desenvolvedores é uma das características chave do produto. Mas, ao olhar para sua documentação, pode-se ter a impressão de que a principal «amigabilidade» da Camunda é voltada para desenvolvedores Java. A plataforma oferece muitas oportunidades para integrar suas próprias funcionalidades e extensões, mas tudo isso é feito em Java. Será que isso é verdade?

Não! Na verdade, é fácil rodar a Camunda sem nenhum conhecimento em Java e configurar a arquitetura para código em qualquer linguagem de sua escolha. Neste artigo, vamos abordar:

  • a arquitetura básica;
  • REST API;
  • dicas sobre bibliotecas de clientes existentes para linguagens diferentes de Java;
  • um exemplo de uso em C# e Node.JS;
  • métodos para iniciar o servidor Camunda (Docker ou Tomcat).

Arquitetura

A Camunda é escrita em Java e precisa de uma máquina virtual Java (JVM) para funcionar. A Camunda fornece uma REST API que permite que você escreva em qualquer linguagem que desejar e utilize REST com a Camunda:

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Os fluxos de trabalho na Camunda são definidos em BPMN, que basicamente se apresenta como um arquivo XML. Pode ser modelado usando Camunda Modeler.

Executando a Camunda através de uma imagem Docker pré-criada

A maneira mais simples de iniciar a Camunda é usar o Docker. Métodos alternativos de executar a Camunda são descritos mais adiante neste artigo.

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Neste caso, basta executar:

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

Você não precisa se preocupar com Linux, máquinas virtuais Java ou Tomcats. Dockerfiles e a documentação principal (como a instrução para conectar-se aos bancos de dados necessários) estão disponíveis em Github.

Se você deseja rodar a Camunda Enterprise Edition, você pode facilmente modificar Dockerfile.

No entanto, executar o Camunda com Docker tem uma desvantagem: você receberá uma versão do Tomcat que pode não incluir as correções mais recentes. Para contornar isso, você pode criar sua própria imagem Docker com base na distribuição do Tomcat desejada, como mostrado neste exemplo, ou usar uma das soluções descritas abaixo.

Implantação do modelo de processo

Vamos considerar um exemplo usando o template Saga para uma reserva de viagem clássica, onde você deseja chamar três ações em sequência e compensar corretamente as ações bem-sucedidas em caso de uma falha posterior. Representado na forma BPMN, ele aparece da seguinte forma:

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

Agora você pode usar API REST para implantação do modelo de processo. Suponha que você o salvou com o nome trip.bpmn e executou o Camunda através do Docker para que estivesse acessí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 "trip.bpmn=@trip.bpmn" 
http://localhost:8080/engine-rest/deployment/create

Agora você pode iniciar novas instâncias do fluxo de trabalho usando a API REST e passando os dados que você deseja ver como variáveis na instância do 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 pergunta interessante é: como o Camunda chama procedimentos, como a reserva de um carro? O Camunda pode não apenas chamar serviços imediatamente (Princípio do Push), utilizando alguns conectores embutidos, mas também colocar os elementos de trabalho em uma espécie de fila embutida. Após isso, o trabalhador pode obter os elementos de trabalho via REST, realizar a tarefa e informar ao Camunda quando terminar (Princípio do Pull).Portanto, primeiro você precisa executar

Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)

fetchAndLock (já que outros trabalhadores podem receber tarefas ao mesmo tempo para escalar 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

  Em seguida, informe ao Camunda que

o trabalhador concluiu o trabalho (note que você deve inserir o identificador da tarefa externa obtido 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

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

Isso é tudo — você ainda não precisou de Java, certo? E isso é suficiente para começar!

Bibliotecas do Cliente

Chamadas à API REST são fáceis em qualquer linguagem de programação. Em JavaScript, pode-se usar o JQuery, enquanto em C# utiliza-se o System.Net.Http e o Newtonsoft.Json. Mas isso leva tempo. Portanto, você pode simplesmente usar alguma biblioteca do cliente.

Atualmente, várias bibliotecas do cliente prontas estão disponíveis:

  • JavaScript: link. Camunda é suportada;
  • Java: link. Camunda é suportada;
  • C#:link e link. Ambos os projetos estão em estado intermediário e praticamente inativos, mas podem servir como um bom ponto de partida;
  • PHP: link — uma biblioteca que não é muito completa e não inclui as últimas mudanças da API, mas conheço projetos que a utilizam.

Exceto JavaScript e Java, as bibliotecas do cliente não fazem parte do próprio produto Camunda. Não espere que elas suportem todas as funcionalidades da API REST da Camunda. Se uma biblioteca não fornece uma determinada função, isso não significa que ela não exista; sempre verifique a API REST da Camunda. Projetos típicos usam bibliotecas como ponto de partida e template.

Exemplo em C#

Usando a biblioteca do cliente mencionada acima, podemos simplesmente escrever:

  var camunda = new CamundaEngineClient("http://localhost:8080/engine-rest/engine/default/", null, null);
  // Faça o deploy do arquivo BPMN XML dos recursos
  camunda.RepositoryService.Deploy("trip-booking", new List {
        FileParameter.FromManifestResource(Assembly.GetExecutingAssembly(), "FlowingTripBookingSaga.Models.FlowingTripBookingSaga.bpmn")
     });
  
  // Registre trabalhadores
  registerWorker("reserve-car", externalTask => {
    // aqui você pode fazer a coisa de verdade! Como um sysout :-)
    Console.WriteLine("Reservando carro agora...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  registerWorker("cancel-car", externalTask => {
    Console.WriteLine("Cancelando carro agora...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  registerWorker("book-hotel", externalTask => {
    Console.WriteLine("Reservando hotel agora...");
    camunda.ExternalTaskService.Complete(workerId, externalTask.Id);
  });
  // Registre mais trabalhadores...
  
  StartPolling();
  
  string processInstanceId = camunda.BpmnWorkflowService.StartProcessInstance("FlowingTripBookingSaga", new Dictionary()
    {
      {"someBookingData", "..." }
    });

O código-fonte totalmente operacional pode ser encontrado na Internet: link. Outro exemplo está disponível em link.
Пример с 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 + " - adicionado algo";
    callback(null, {
      variables: {
        someNewData: someNewData
      }
    });
  });
  
  workers.shutdown();

Mais informações podem ser encontradas no site github.com
Métodos alternativos para iniciar o Camunda
Imagem Docker personalizada com 'Camunda standalone WAR'
Como alternativa à imagem Docker pronta da Camunda, você pode configurar o Tomcat por conta própria (por exemplo, com base nas imagens oficiais do Docker Tomcat) e, em seguida, copiar o Camunda como um dos chamados arquivos WAR.
 Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)
Se você tiver muitos requisitos adicionais e puder configurar o ambiente de construção Java, também pode configurar o Camunda Standalone WAR. Configure a construção do Maven conforme estes exemplos: construção Maven com configuração WAR ou construção Maven com Overlay.
Executando a distribuição Camunda Tomcat
Outra opção é simplesmente baixar a distribuição Camunda Tomcat, descompactá-la e executá-la. Para isso, você precisará apenas do Java Runtime Environment (JRE) instalado em seu computador. Você pode facilmente baixá-lo daqui.
 Uso do Camunda para orquestração fácil com base em REST e em um motor de fluxo de trabalho (sem Java)
Para alterar o banco de dados ou fazer algo mais, você precisará configurar o Tomcat, como descrito na documentação. Eu sei que o Tomcat pode parecer complicado, mas na verdade é muito simples. E o Google sabe as respostas para tudo o que pode ser necessário durante o processo.
Executando o Camunda usando o Tomcat
A última alternativa é configurar o Tomcat por conta própria e instalar o Camunda nele, seguindo as instruções de instalação. Isso permitirá usar qualquer versão do Tomcat que você preferir ou, por exemplo, instalá-lo como um serviço do Windows.
Executando o Camunda em produção
Normalmente, será necessário fazer algumas configurações finais para executar o Camunda. O Camunda tem recomendações que descrevem isso em detalhes, mas não detalharei isso neste artigo — vou mencionar apenas um exemplo: a API REST da distribuição padrão não está configurada para autenticação. Você pode querer mudar isso.
Conclusão
Como você pode notar, começar a trabalhar com o Camunda é muito simples, independentemente do idioma que você estiver usando. O ponto chave é que toda a interação é feita através da API REST. A instalação também é bastante simples, especialmente quando usando o Docker.
Fonte: habr.com
    
                
 Compre hospedagem confiável para sites com proteção contra DDoS, servidores VPS VDS 🔥 Compre hospedagem confiável para sites com proteção contra DDoS, servidores VPS VDS | ProHoster