Qu'est-ce que Kogito

Kogito est un outil d'automatisation des processus métier natif pour le cloud, conçu pour simplifier votre vie. Pensez-y comme l'enfant chéri de la gestion des processus métier (BPM) et de la gestion des décisions, élevé dans le cloud par son parent attentionné, Quarkus.

Mais pourquoi devriez-vous, en tant que développeur chevronné, vous intéresser à Kogito ? Voici le résumé :

  • C'est natif pour le cloud et prêt pour Kubernetes dès le départ
  • Il s'intègre parfaitement avec Quarkus, vous offrant des capacités Java supersoniques et subatomiques
  • Il transforme vos processus métier et décisions en éléments de premier ordre dans votre code
  • C'est open-source et soutenu par la Fondation Apache (actuellement en incubation)

Plongée dans le dépôt d'exemples Kogito

Maintenant que nous avons éveillé votre intérêt, faisons un tour du dépôt apache/incubator-kie-kogito-examples. Ce trésor d'exemples est votre billet pour maîtriser Kogito.

Configurer votre terrain de jeu Kogito

Avant de plonger, assurez-vous d'avoir tout ce dont vous avez besoin pour exécuter ces exemples :

  • Java 11+ (parce que nous ne sommes pas des sauvages)
  • Maven 3.8.1+
  • Docker (pour satisfaire vos envies de conteneurisation)
  • Quarkus CLI (optionnel, mais fortement recommandé pour un gain de productivité supplémentaire)

Vous avez tout ça ? Super ! Maintenant, passons à la pratique.

Quarkus : le partenaire de Kogito

Vous vous demandez peut-être, "Quel est le rapport avec Quarkus ?" Eh bien, tout. Quarkus est le framework Java supersonique et subatomique qui donne à Kogito ses superpouvoirs natifs pour le cloud. C'est comme du Red Bull pour vos applications Java, mais sans les tremblements de caféine.

Kogito utilise Quarkus pour :

  • Atteindre des temps de démarrage ultra-rapides
  • Réduire l'empreinte mémoire (votre portefeuille vous remerciera)
  • Fournir des capacités de rechargement à chaud (parce que qui a le temps pour les redémarrages ?)
  • Offrir une intégration transparente avec les technologies natives pour le cloud

Exploration des exemples Kogito : un tourbillon

Jetons un coup d'œil à certains des exemples les plus intéressants du dépôt :

1. Processus + Règles : le duo dynamique

Accédez au répertoire kogito-quarkus-examples/process-business-rules-quarkus. Cet exemple montre comment Kogito combine processus et règles pour créer un moteur de prise de décision puissant.

Points clés :

  • Intégration des processus BPMN2 avec les tables de décision DMN
  • Génération automatique de points de terminaison REST pour vos processus
  • Exécution transparente des règles dans les contextes de processus

2. Flux de travail sans serveur : parce que les serveurs, c'est dépassé

Consultez l'exemple serverless-workflow-examples/serverless-workflow-greeting-quarkus. Celui-ci est pour tous les passionnés de sans serveur.

Points forts :

  • Flux de travail définis en YAML (parce que qui n'aime pas YAML ?)
  • Architectures pilotées par les événements simplifiées
  • Intégrations avec AWS Lambda et Knative

3. DMN : rendre les décisions à nouveau géniales

Rendez-vous sur kogito-quarkus-examples/dmn-quarkus-example pour une plongée approfondie dans le modèle de décision et la notation (DMN) avec Kogito.

Ce que vous apprendrez :

  • Modélisation visuelle de la logique décisionnelle complexe
  • Génération automatique d'API REST pour vos services de décision
  • Tester et déboguer les modèles DMN comme un pro

Exécuter votre premier exemple Kogito : un guide étape par étape

Assez de théorie, passons à la pratique ! Nous utiliserons l'exemple process-business-rules-quarkus pour commencer.

Une fois en cours d'exécution, testez l'API :

curl -X POST -H 'Content-Type: application/json' -H 'Accept: application/json' -d '{"person": {"name":"John Doe", "age": 25}}' http://localhost:8080/persons

Construisez et exécutez l'exemple :

./mvnw clean compile quarkus:dev

Clonez le dépôt :

git clone https://github.com/apache/incubator-kie-kogito-examples.git
cd incubator-kie-kogito-examples/kogito-quarkus-examples/process-business-rules-quarkus

Voilà ! Vous venez d'exécuter un processus métier avec des règles intégrées en utilisant Kogito. Vous sentez la puissance qui coule dans vos veines ?

Implémentation des processus métier : BPMN et DMN, oh là là !

Kogito amène BPMN (Business Process Model and Notation) et DMN (Decision Model and Notation) au 21ème siècle. Fini les moteurs BPM lourds et encombrants. Avec Kogito, vos processus et décisions sont des citoyens de première classe dans votre code.

BPMN : des organigrammes sous stéroïdes

Regardons un processus BPMN simple :

<?xml version="1.0" encoding="UTF-8"?>
<bpmn2:definitions xmlns:bpmn2="http://www.omg.org/spec/BPMN/20100524/MODEL" id="_6063f3a1-5ba3-4f0e-b1f2-ad49e8e6f2a7" targetNamespace="http://www.omg.org/bpmn20">
  <bpmn2:process id="greeting" name="Greeting Process" isExecutable="true">
    <bpmn2:startEvent id="_1" name="StartProcess">
      <bpmn2:outgoing>_1-_2</bpmn2:outgoing>
    </bpmn2:startEvent>
    <bpmn2:scriptTask id="_2" name="Hello" scriptFormat="http://www.java.com/java">
      <bpmn2:incoming>_1-_2</bpmn2:incoming>
      <bpmn2:outgoing>_2-_3</bpmn2:outgoing>
      <bpmn2:script>System.out.println("Hello World");</bpmn2:script>
    </bpmn2:scriptTask>
    <bpmn2:endEvent id="_3" name="EndProcess">
      <bpmn2:incoming>_2-_3</bpmn2:incoming>
    </bpmn2:endEvent>
    <bpmn2:sequenceFlow id="_1-_2" sourceRef="_1" targetRef="_2"/>
    <bpmn2:sequenceFlow id="_2-_3" sourceRef="_2" targetRef="_3"/>
  </bpmn2:process>
</bpmn2:definitions>

Ce processus simple imprime "Hello World", mais imaginez les possibilités lorsque vous commencez à intégrer votre logique métier et des systèmes externes !

DMN : Décisions, décisions

Jetons un coup d'œil à un modèle DMN :

<?xml version="1.0" encoding="UTF-8"?>
<dmn:definitions xmlns:dmn="http://www.omg.org/spec/DMN/20180521/MODEL/" xmlns="https://kiegroup.org/dmn/_52CEF9FD-9943-4A89-96D5-6F66810CA4C1" xmlns:di="http://www.omg.org/spec/DMN/20180521/DI/" xmlns:kie="http://www.drools.org/kie/dmn/1.2" xmlns:dmndi="http://www.omg.org/spec/DMN/20180521/DMNDI/" xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/" id="_4F7C97F9-EA35-4CB5-8E4C-C40C91B5F729" name="Greeting" typeLanguage="http://www.omg.org/spec/DMN/20180521/FEEL/" namespace="https://kiegroup.org/dmn/_52CEF9FD-9943-4A89-96D5-6F66810CA4C1">
  <dmn:decision id="_23B84E59-33C6-4D3A-9314-CF0724714606" name="Greeting Message">
    <dmn:extensionElements/>
    <dmn:variable id="_078A6F79-1861-47A1-8921-C9E7F2B728D1" name="Greeting Message" typeRef="string"/>
    <dmn:informationRequirement id="_2066A270-2A88-4B77-9F90-1F683FDF852C">
      <dmn:requiredInput href="#_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C"/>
    </dmn:informationRequirement>
    <dmn:decisionTable id="_5A25D948-34E0-4527-9EE2-7A9C0DC663A5" hitPolicy="UNIQUE" preferredOrientation="Rule-as-Row">
      <dmn:input id="_79ECD1F2-E11E-4F6D-9038-C47AE6EC1C9C">
        <dmn:inputExpression id="_E17A0C1D-A0F0-4C5F-8A0E-8B5F9A1BAB08" typeRef="number">
          <dmn:text>Age</dmn:text>
        </dmn:inputExpression>
      </dmn:input>
      <dmn:output id="_EC6A4902-BD03-4D48-AA45-9AD2AEB83E8B"/>
      <dmn:annotation name="annotation-1"/>
      <dmn:rule id="_C3F28427-2608-4ACE-98EE-C5C2F0AEF7A7">
        <dmn:inputEntry id="_0FBE3F3C-5F3A-4A21-A4A5-D207B2BA7808">
          <dmn:text>< 18</dmn:text>
        </dmn:inputEntry>
        <dmn:outputEntry id="_C05BE7BB-BDA0-4C45-9ED1-4F5B17B2A3E6">
          <dmn:text>"Hello young person!"</dmn:text>
        </dmn:outputEntry>
        <dmn:annotationEntry>
          <dmn:text/>
        </dmn:annotationEntry>
      </dmn:rule>
      <dmn:rule id="_C3B07D74-0354-4C44-9587-9B44C67F5AE0">
        <dmn:inputEntry id="_8A9B0EEC-5CB9-4D31-BB56-0A723CEABFBC">
          <dmn:text>>= 18</dmn:text>
        </dmn:inputEntry>
        <dmn:outputEntry id="_42C4EB7F-3F00-4A19-9F43-D2E246F378F9">
          <dmn:text>"Hello adult!"</dmn:text>
        </dmn:outputEntry>
        <dmn:annotationEntry>
          <dmn:text/>
        </dmn:annotationEntry>
      </dmn:rule>
    </dmn:decisionTable>
  </dmn:decision>
  <dmn:inputData id="_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" name="Age">
    <dmn:extensionElements/>
    <dmn:variable id="_F0B70F13-94CB-4FB9-BD89-4AB84F8BDB07" name="Age" typeRef="number"/>
  </dmn:inputData>
  <dmndi:DMNDI>
    <dmndi:DMNDiagram>
      <di:extension>
        <kie:ComponentsWidthsExtension>
          <kie:ComponentWidths dmnElementRef="_5A25D948-34E0-4527-9EE2-7A9C0DC663A5">
            <kie:width>50</kie:width>
            <kie:width>100</kie:width>
            <kie:width>100</kie:width>
            <kie:width>100</kie:width>
          </kie:ComponentWidths>
        </kie:ComponentsWidthsExtension>
      </di:extension>
      <dmndi:DMNShape id="dmnshape-_23B84E59-33C6-4D3A-9314-CF0724714606" dmnElementRef="_23B84E59-33C6-4D3A-9314-CF0724714606" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="364" y="227" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNShape id="dmnshape-_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" dmnElementRef="_C7ED7EFC-9F7F-4FBE-81DB-57A32A56502C" isCollapsed="false">
        <dmndi:DMNStyle>
          <dmndi:FillColor red="255" green="255" blue="255"/>
          <dmndi:StrokeColor red="0" green="0" blue="0"/>
          <dmndi:FontColor red="0" green="0" blue="0"/>
        </dmndi:DMNStyle>
        <dc:Bounds x="365" y="94" width="100" height="50"/>
        <dmndi:DMNLabel/>
      </dmndi:DMNShape>
      <dmndi:DMNEdge id="dmnedge-_2066A270-2A88-4B77-9F90-1F683FDF852C" dmnElementRef="_2066A270-2A88-4B77-9F90-1F683FDF852C">
        <di:waypoint x="415" y="119"/>
        <di:waypoint x="414" y="252"/>
      </dmndi:DMNEdge>
    </dmndi:DMNDiagram>
  </dmndi:DMNDI>
</dmn:definitions>

Ce modèle DMN décide d'un message de salutation en fonction de l'âge d'une personne. C'est un exemple simple, mais imaginez l'étendre à des règles métier complexes et des processus de prise de décision !

Personnaliser les règles et décisions : à votre façon ou rien

Kogito ne vous offre pas seulement des règles et décisions prêtes à l'emploi. Il vous permet de les personnaliser pour répondre à vos besoins métier uniques. Voici quelques façons de montrer vos muscles de personnalisation :

1. Langage de règles Drools (DRL)

Pour les moments où les modèles visuels ne suffisent pas, vous pouvez utiliser le bon vieux DRL :

package org.acme.rules

import org.acme.model.Person

rule "Greet adults"
when
    $person: Person(age >= 18)
then
    System.out.println("Hello, responsible adult!");
end

rule "Greet children"
when
    $person: Person(age < 18)
then
    System.out.println("Hi, youngster! Where are your parents?");
end

2. Tables de décision

Pour les utilisateurs métier qui font de l'urticaire à la vue du code, les tables de décision sont une bénédiction :

RuleSet,org.acme.rules
RuleSetName,Greeting Rules

RuleTable Greeting
CONDITION,ACTION
Person.age,System.out.println
>=18,"Hello, responsible adult!"
<18,"Hi, youngster! Where are your parents?"

3. Étendre DMN avec des fonctions personnalisées

Besoin d'un peu plus de punch dans vos modèles DMN ? Étendez-les avec des fonctions Java personnalisées :

@DMNFunction(name = "toUpperCase")
public static String toUpperCase(String input) {
    return input.toUpperCase();
}

Vous pouvez maintenant utiliser toUpperCase() dans vos expressions DMN. Sympa, non ?

Intégrer Kogito avec le monde extérieur

Kogito s'entend bien avec les autres. Voyons comment l'intégrer avec certains systèmes externes populaires :

APIs REST : Parce que le SOAP, c'est pour se laver

Kogito génère automatiquement des points de terminaison REST pour vos processus et décisions. Mais que faire si vous devez appeler une API REST externe ? Facile :

@Inject
RestClient myExternalService;

@POST
@Path("/process")
public Response startProcess(ProcessPayload payload) {
    // Démarrez votre processus Kogito
    ProcessInstance<?> processInstance = processService.createProcessInstance(...);
    
    // Appelez l'API REST externe
    ExternalData data = myExternalService.getData(payload.getId());
    
    // Mettez à jour les variables du processus
    processInstance.updateVariables(Collections.singletonMap("externalData", data));
    
    return Response.ok(processInstance).build();
}

Kafka : Pour ces moments pilotés par les événements

Kogito et Kafka vont ensemble comme le beurre de cacahuète et la confiture. Voici un aperçu :

@Inject
Emitter<PersonEvent> personEventEmitter;

@POST
@Path("/persons")
public Response createPerson(Person person) {
    // Votre logique de processus Kogito ici
    
    // Émettez un événement à Kafka
    personEventEmitter.send(new PersonEvent(person));
    
    return Response.ok(person).build();
}

N'oubliez pas de configurer votre connexion Kafka dans application.properties :

mp.messaging.outgoing.person-events.connector=smallrye-kafka
mp.messaging.outgoing.person-events.topic=person-events
mp.messaging.outgoing.person-events.value.serializer=io.quarkus.kafka.client.serialization.JsonbSerializer

Déboguer Kogito : Quand les choses tournent mal

Même les meilleurs développeurs se retrouvent parfois dans une impasse de débogage. Voici quelques conseils pour rester sain d'esprit :

1. Activer la journalisation de débogage

Tout d'abord, augmentez la journalisation :

quarkus.log.category."org.kie".level=DEBUG
quarkus.log.category."org.drools".level=DEBUG
quarkus.log.category."org.jbpm".level=DEBUG

2. Utilisez l'interface de développement Kogito

Kogito est livré avec une interface de développement élégante. Ajoutez simplement cette dépendance :

<dependency>
    <groupId>org.kie.kogito</groupId>
    <artifactId>kogito-addons-quarkus-process-management</artifactId>
</dependency>

Vous pouvez maintenant accéder à http://localhost:8080/q/dev pour voir vos processus et décisions en action.

3. Testez, testez, testez

Les tests unitaires sont vos amis. Voici un exemple rapide :

@QuarkusTest
public class GreetingProcessTest {

    @Inject
    ProcessService processService;

    @Test
    public void testGreetingProcess() {
        ProcessInstance<?> processInstance = processService.createProcessInstance(
            "greeting",
            Collections.singletonMap("name", "John")
        );
        
        assertThat(processInstance.status()).isEqualTo(ProcessInstance.STATE_COMPLETED);
        assertThat(processInstance.variables()).containsEntry("greeting", "Hello, John!");
    }
}

Optimisation des performances : Faites-le aller vite

Kogito est rapide, mais avec ces conseils, vous pouvez le faire franchir le mur du son :

1. Compilation native

Quarkus offre une compilation native, qui peut réduire considérablement le temps de démarrage et l'utilisation de la mémoire :

./mvnw package -Pnative

2. Programmation réactive

Adoptez le paradigme réactif pour une meilleure évolutivité :

@Inject
ReactiveProcessService processService;

@POST
@Path("/process")
public Uni<ProcessInstance<?>> startProcess(ProcessPayload payload) {
    return processService.createProcessInstance("myProcess", payload.toMap());
}

3. Mise en cache

Utilisez les capacités de mise en cache intégrées de Quarkus pour accélérer les opérations fréquentes :

@CacheResult(cacheName = "greeting-cache")
public String getGreeting(String name) {
    // Opération coûteuse ici
    return "Hello, " + name + "!";
}

Meilleures pratiques : À faire et à ne pas faire

Concluons avec quelques règles d'or pour le développement Kogito :

À faire :

  • Gardez vos processus et décisions simples et modulaires
  • Utilisez des noms significatifs pour vos éléments BPMN et DMN
  • Tirez parti du rechargement à chaud de Quarkus pour un développement rapide
  • Documentez vos processus et décisions (votre futur vous vous remerciera)
  • Utilisez le contrôle de version pour vos fichiers BPMN et DMN

À ne pas faire :

  • Ne mettez pas de logique métier dans vos diagrammes de processus (utilisez plutôt des tâches de service)
  • Négligez pas la gestion des erreurs dans vos processus
  • N'oubliez pas la surveillance et l'observabilité
  • Ne négligez pas les meilleures pratiques de sécurité (Kogito n'est pas une poudre magique de sécurité)

Kogito dans le monde réel : Pas seulement un joli visage

Kogito n'est pas seulement pour les exemples de jouets. Il est utilisé dans la nature pour une automatisation sérieuse des processus métier. Voici quelques applications réelles :

  • Services financiers : Automatisation des processus d'approbation de prêt et détection de fraude
  • Santé : Gestion des flux de travail des patients et traitement des réclamations d'assurance
  • E-commerce : Orchestration des processus de traitement des commandes et de retour
  • Fabrication : Optimisation des décisions de la chaîne d'approvisionnement et des processus de contrôle qualité

Contribuer à Kogito : Rejoignez le club des cool kids

Vous vous sentez inspiré ? Vous voulez redonner à la communauté ? Voici comment vous pouvez contribuer à Kogito :

  1. Forkez le dépôt Kogito Examples
  2. Choisissez un problème dans le suivi des problèmes
  3. Apportez vos modifications et soumettez une demande de tirage
  4. Engagez-vous avec la communauté sur la liste de diffusion

Rappelez-vous, aucune contribution n'est trop petite. Même corriger une faute de frappe dans la documentation est apprécié !

Le compte à rebours final : Conclusion

Et voilà, mesdames et messieurs ! Un tourbillon de Kogito et de ses superpouvoirs. Nous avons couvert tout, de la configuration de votre premier projet Kogito à la contribution à la communauté open-source.

Kogito, propulsé par Quarkus, change la donne dans l'automatisation des processus métier. Il apporte la puissance des technologies natives pour le cloud au monde des processus et décisions métier. Que vous construisiez un flux de travail simple ou un système de prise de décision complexe, Kogito est là pour vous.

Alors, qu'attendez-vous ? Plongez, commencez à expérimenter et rejoignez la révolution Kogito. Votre futur vous (et votre équipe d'exploitation) vous remerciera.

Rappelez-vous : avec un grand pouvoir vient une grande responsabilité. Utilisez Kogito à bon escient, et que vos processus métier soient toujours en votre faveur !