Annonce du nouveau client Java Conductor v4

Oleh: Miguel Prieto

---

Awal tahun ini, Python SDK telah melakukan facelift yang besar. Kini SDK Konduktor lain sedang menjalani pemulihan yang ketara, dan kami sangat teruja untuk mengumumkan Java Client v4, yang menampilkan peningkatan reka bentuk yang ketara, peningkatan prestasi dan kebergantungan yang dioptimumkan.

Dalam Java Client v4 kami, kami telah mengurangkan jejak pergantungan dengan menambah baik reka bentuknya. Kami telah menambah penapis, acara dan pendengar untuk mengalih keluar kebergantungan langsung. Keputusan reka bentuk ini dibuat selepas pertimbangan yang teliti untuk menjadikan pelanggan lebih mudah digunakan, dilanjutkan dan diselenggara.

Baca terus untuk mengetahui lebih lanjut!

---

Mengapa kita melakukan ini?

Kami telah mendengar maklum balas anda dan sedang berusaha untuk meningkatkan pengalaman pembangun. Orkes dan komuniti OSS Konduktor sedang menguruskan dua projek klien/SDK Java yang berasingan, yang kedua-duanya, seperti kebanyakan dalam industri kami, telah mengumpul beberapa hutang teknikal. Kami memutuskan masa yang sesuai untuk menangani hutang ini.

Beberapa perkara utama yang ingin kami atasi dengan segera ialah:

1. Satu pelanggan Java Konduktor (untuk memerintah mereka semua)
   Matlamatnya adalah untuk menyatukan kedua-dua projek sedia ada menjadi satu penyelesaian yang bersatu, lebih terurus, mengambil elemen terkuat daripada setiap projek. Ini seharusnya diterjemahkan kepada kemas kini yang lebih pantas, sokongan yang lebih baik dan pengalaman pembangunan yang lebih padu.

2. Pengoptimuman pergantungan
   Sebagai sebahagian daripada pembersihan kod, kami telah mengalih keluar beberapa kebergantungan:

   • Pergantungan pada kod hujung belakang—Klien OSS Java dan projek SDK sebelumnya adalah sebahagian daripada repo OSS Konduktor dan bergantung pada konduktor-common. Walaupun ini memastikan model bahagian belakang/pelanggan sentiasa disegerakkan, ini juga bermakna beberapa kod dan kebergantungan yang berkaitan dengan bahagian belakang telah bocor kepada pelanggan.
   • Pergantungan pada artifak yang tidak digunakan lagi.
   • Pergantungan pada bahan yang anda tidak perlukan.

   Dengan mengalih keluar kebergantungan berkod keras, pengguna dan penyumbang boleh melanjutkan pelanggan tanpa dikunci ke dalam perpustakaan atau alatan tertentu.

3. Lebih modulariti
   Kami telah menyusun semula projek untuk meningkatkan modulariti, menjadikan pelanggan lebih fleksibel dan lebih mudah untuk disesuaikan.

   Dengan pendekatan modular ini, anda boleh menyepadukan alat pemantauan, pengelogan atau penemuan pilihan anda melalui acara, pendengar dan penapis. Ini bukan sahaja memudahkan penyesuaian tetapi juga menjadikan pangkalan kod lebih boleh diselenggara dan kalis masa hadapan, memperkasakan pembangun untuk membina dan menskalakan sambungan mereka sendiri mengikut keperluan.

4. Pembersihan/pemfaktoran semula kod
   Dengan pangkalan kod yang lebih bersih, pembangunan masa hadapan harus lebih pantas dan kurang terdedah kepada ralat, menjadikannya lebih mudah untuk sumbangan komuniti juga.

5. Contoh yang lebih baik
   Kami telah memperkenalkan modul dalam projek khusus untuk contoh. Walaupun ia masih dalam proses, modul ini akan berfungsi sebagai sumber utama untuk contoh praktikal dunia sebenar sama ada anda sedang memulakan atau mencari kes penggunaan lanjutan.

Rumah, rumah manis

Klien Konduktor Rasmi dan SDK kini ditempatkan di https://github.com/conductor-sdk, kecuali Klien Java OSS/SDK, yang merupakan sebahagian daripada repo OSS Konduktor https://github.com /orkes-io/orkes-conductor-client/tree/main.

Melangkah ke hadapan, semua Pelanggan Konduktor dan SDK akhirnya akan ditempatkan dalam direktori konduktor-klien yang sama dalam repo konduktor-oss/konduktor. Pergi ke sana untuk mencari kod sumber untuk Java Client/SDK v4.

Apa yang baharu dalam Java Client v4?

1. Kebergantungan yang dioptimumkan

Java Client v4 memperkenalkan set pergantungan yang lebih diperkemas dan cekap berbanding dengan dua projek yang digantikannya.

Kami telah mengalih keluar semua kebergantungan yang tidak digunakan, tidak digunakan lagi dan tidak perlu, dengan ketara mengurangkan pencemaran laluan kelas. Pengoptimuman ini bukan sahaja meminimumkan risiko konflik antara perpustakaan tetapi juga harus meningkatkan prestasi keseluruhan dan kebolehselenggaraan. Dengan memudahkan pepohon pergantungan, v4 menyediakan pelanggan yang lebih bersih dan ringan yang lebih mudah untuk digunakan dan disepadukan dengan lebih lancar ke dalam projek anda.

2. TaskRunner Baharu

TaskRunner telah difaktorkan semula. Ia menggantikan TaskPollExecutor, kerana kedua-duanya berkongsi tanggungjawab teras yang sama: mengurus kumpulan benang yang digunakan oleh pekerja untuk mengundi, melaksanakan dan mengemas kini tugas.

Dengan itu, kami telah mengalih keluar kebergantungan langsung pada Netflix Eureka dan Spectator, memperkenalkan mekanisme dipacu peristiwa dan menambahkan PollFilter—panggilan balik yang menentukan sama ada pengundian harus berlaku. Selain itu, pengendalian ralat dan pengurusan konkurensi telah dipertingkatkan.

Si vous utilisez Eureka et Spectator, ne vous inquiétez pas : les événements et les filtres sont fournis pour une intégration transparente avec ces excellents outils et bibliothèques.

3. Extensibilité à l'aide d'événements, d'écouteurs et de filtres

Java Client v4 introduit une extensibilité améliorée via des événements, des écouteurs et des filtres. Ceux-ci peuvent être utilisés à diverses fins, notamment le suivi des métriques, la journalisation, l'audit et le déclenchement d'actions personnalisées en fonction de conditions spécifiques.

Par exemple, vous pouvez utiliser une fonction Lambda comme PollFilter pour vérifier l'état de l'instance tel que rapporté par Eureka. Si l'instance est marquée comme UP (ce qui signifie qu'Eureka la considère comme saine et disponible), le travailleur procédera à l'interrogation des tâches.

De plus, un auditeur peut être enregistré pour gérer les événements PollCompleted. Dans ce scénario, l'écouteur enregistre les détails de l'événement et utilise Prometheus pour suivre la durée du processus d'interrogation, en attachant le type de tâche comme étiquette pour le suivi détaillé des métriques. Cette approche ajoute non seulement de la flexibilité, mais améliore également l'observabilité et le contrôle du comportement du client.

var runnerConfigurer = new TaskRunnerConfigurer
        .Builder(taskClient, List.of(new HelloWorldWorker()))
        .withThreadCount(10)
        .withPollFilter((String taskType, String domain) -> {
            return eurekaClient.getInstanceRemoteStatus().equals(InstanceStatus.UP);
        })
        .withListener(PollCompleted.class, (e) -> {
            log.info("Poll Completed {}", e);
            var timer = prometheusRegistry.timer("poll_completed", "type", e.getTaskType());
            timer.record(e.getDuration());
        })
        .build();

runnerConfigurer.init();

Le client dispose également d'interfaces spécialisées comme MetricsCollector, qui est construite sur ces événements et auditeurs. Nous fournirons bientôt des implémentations concrètes de Metrics Collectors.

4. OkHttp3 v4 — la bonne quantité de fonctionnalités OOTB

OkHttp3 v4 est l'un des clients HTTP les plus populaires et les plus appréciés pour Java. En le mettant à niveau, notre client Java/SDK v4 prend désormais en charge HTTP2 et Gzip prêts à l'emploi, vous permettant d'effectuer des requêtes HTTP ou des transferts de données plus rapides. Bien qu'il existe d'autres excellentes options, OkHTTP a été choisi pour sa simplicité, ses performances et sa fiabilité.

Avec la mise à niveau OkHttp, nous avons également décidé de supprimer une couche d'abstraction, Jersey. Jersey est plus riche en fonctionnalités mais aussi plus lourd qu'un simple client HTTP comme OkHttp. Certaines de ces fonctionnalités (telles que l'injection de dépendances, les filtres et les mappeurs d'exceptions) peuvent être excessives si vous souhaitez simplement effectuer des requêtes HTTP de base.

5. Facilité de migration d'OSS vers Orkes

Le client favorise une intégration transparente entre OSS Conductor et Orkes Conductor, offrant aux utilisateurs la flexibilité de changer à mesure que leurs besoins évoluent, tout en maintenant d'abord la prise en charge de la communauté open source.

Le module Orkes Client étend simplement le Conductor Client en ajoutant une authentification via un HeaderSupplier.

Pour les utilisateurs d'OSS qui ont créé des Workers avec Client v4 mais qui souhaitent essayer Orkes Conductor, il leur suffit d'ajouter la dépendance orkes-conductor-client à leur projet et d'instancier le client avec OrkesAuthentication en tant que fournisseur d'en-tête. Revenir à OSS est aussi simple que de supprimer ce fournisseur d'en-tête.

var client = ConductorClient.builder()
                .basePath(BASE_PATH)
                .addHeaderSupplier(new OrkesAuthentication(KEY, SECRET))
                .build();
return new TaskClient(client); // Use this TaskClient with TaskRunner to initialize workers

Découvrez les 6 différences entre Conductor OSS et Orkes Conductor.

6. Exemples et documentation améliorés

Nous avons commencé à regrouper les exemples dans un module dédié, avec des améliorations qui couvrent des domaines clés tels que l'autorisation, la gestion des définitions de flux de travail et de tâches, la planification des flux de travail, et bien plus encore. Bien que ce module soit encore en cours de développement, nous ajouterons et affinerons continuellement des exemples pour fournir de meilleurs conseils et couvrir des cas d'utilisation réels.

Notre objectif est de permettre aux développeurs d'utiliser efficacement notre client/SDK et d'explorer les meilleures pratiques à mesure que le module évolue.

Premiers pas avec le client Java v4

Voici comment commencer à utiliser Java Client v4 :

Étape 1 : faire tourner le conducteur

Utilisez Conductor OSS ou Orkes Conductor :

• Conductor OSS : exécutez-le à partir de la source ou utilisez Docker.
• Orkes Conductor—Essayez Orkes Playground ou inscrivez-vous pour un essai gratuit.

Étape 2 : Ajoutez une dépendance conducteur-client à votre projet

Pour les projets basés sur Gradle :

implementation 'org.conductoross:conductor-client:4.0.0'
implementation 'io.orkes:orkes-conductor-client:4.0.0' // required if using Orkes Conductor

Pour les projets basés sur Maven :

<dependency>
    <groupId>org.conductoross</groupId>
    <artifactId>conductor-client</artifactId>
    <version>4.0.0</version>
</dependency>
<dependency>
    <groupId>io.orkes</groupId>
    <artifactId>orkes-conductor-client</artifactId>
    <version>4.0.0</version>
</dependency> <!-- Required if using Orkes Conductor –->

Étape 3 : Créer une instance ConductorClient

import com.netflix.conductor.client.http.ConductorClient;

// … boilerplate or other code omitted
var client = new ConductorClient("http://localhost:8080/api");

Si vous utilisez Orkes Conductor, vous devrez créer une application et récupérer vos informations d'identification. Avec votre identifiant de clé et votre secret, créez une instance ConductorClient :

import com.netflix.conductor.client.http.ConductorClient;
import io.orkes.conductor.client.http.OrkesAuthentication;

var client = ConductorClient.builder()
           .basePath("https://play.orkes.io/api")
           .addHeaderSupplier(new OrkesAuthentication(KEY, SECRET))
           .build();

ou

import io.orkes.conductor.client.ApiClient;

var client = ApiClient.builder() // ApiClient extends ConductorClient
                 .basePath("https://play.orkes.io/api")
                .credentials(KEY, SECRET)
                .build();

Étape 4 : Créer un flux de travail

Vous pouvez créer un workflow dans Conductor en utilisant ce JSON :

{
  "name": "hello_workflow",
  "description": "Hello Workflow!",
  "version": 1,
  "tasks": [
    {
      "name": "hello_task",
      "taskReferenceName": "hello_task_ref",
      "type": "SIMPLE",
      "inputParameters": {}
    }
  ],
  "inputParameters": [],
  "outputParameters": {

  },
  "schemaVersion": 2,
  "restartable": true,
  "workflowStatusListenerEnabled": false,
  "ownerEmail": "example@orkes.io",
  "timeoutPolicy": "ALERT_ONLY",
  "timeoutSeconds": 0
}

Ou utilisez notre module SDK pour créer des workflows sous forme de code. Pour cela, vous devez ajouter la dépendance suivante à votre projet :

Pour les projets basés sur Gradle :

implementation 'org.conductoross:java-sdk::4.0.0'

Pour les projets basés sur Maven :

<dependency>
    <groupId>org.conductoross</groupId>
    <artifactId>java-sdk</artifactId>
    <version>4.0.0</version>
</dependency>

Avec la dépendance ajoutée, vous pouvez exécuter le code suivant pour enregistrer le workflow :

import com.netflix.conductor.sdk.workflow.def.WorkflowBuilder;
import com.netflix.conductor.sdk.workflow.def.tasks.SimpleTask;
import com.netflix.conductor.sdk.workflow.executor.WorkflowExecutor;

// … boilerplate or other code omitted
var executor = new WorkflowExecutor("http://localhost:8080/api");
var workflow = new WorkflowBuilder<Void>(executor)
        .name("hello_workflow")
        .version(1)
        .description("Hello Workflow!")
        .ownerEmail("examples@orkes.io")
        .add(new SimpleTask("hello_task", "hello_task_ref"))
        .build();
workflow.registerWorkflow(true, true);
executor.shutdown();

Étape 5 : Démarrer un flux de travail

Maintenant que vous avez enregistré un workflow, vous pouvez le démarrer avec le code :

import com.netflix.conductor.client.http.ConductorClient;
import com.netflix.conductor.client.http.WorkflowClient;
import com.netflix.conductor.common.metadata.workflow.StartWorkflowRequest;

var client = new ConductorClient("http://localhost:8080/api");
var workflowClient = new WorkflowClient(client);
var workflowId = workflowClient.startWorkflow(new StartWorkflowRequest()
        .withName("hello_workflow")
        .withVersion(1));

System.out.println("Started workflow " + workflowId);

Step 6: Run a worker

You need a worker polling for “hello_workflow” tasks and executing them to complete the workflow you started in Step 5.

For that, you can run this example:

import com.netflix.conductor.client.automator.TaskRunnerConfigurer;
import com.netflix.conductor.client.http.ConductorClient;
import com.netflix.conductor.client.http.TaskClient;
import com.netflix.conductor.client.worker.Worker;
import com.netflix.conductor.common.metadata.tasks.Task;
import com.netflix.conductor.common.metadata.tasks.TaskResult;

import java.util.List;

public class HelloWorker implements Worker {

    @Override
    public TaskResult execute(Task task) {
        var taskResult = new TaskResult(task);
        taskResult.setStatus(TaskResult.Status.COMPLETED);
        taskResult.getOutputData().put("message", "Hello World!");
        return taskResult;
    }

    @Override
    public String getTaskDefName() {
        return "hello_task";
    }

    public static void main(String[] args) {
        var client = new ConductorClient("http://localhost:8080/api");
        var taskClient = new TaskClient(client);
        var runnerConfigurer = new TaskRunnerConfigurer
                .Builder(taskClient, List.of(new HelloWorker()))
                .withThreadCount(10)
                .build();
        runnerConfigurer.init();
    }
}

These complete examples can be found here.

Note: If you want to run these code snippets in Orkes Conductor, remember to authenticate.

What’s next?: Roadmap

We aim for full parity between OSS server models and SDKs, so stay tuned for more changes to Conductor’s Java SDK and improved documentation. To stay up-to-date with our progress, check out the Conductor OSS Project Board. To request features or report bugs, create a ticket in our GitHub repository or contact us on Slack.

We’ll also soon tackle other supported languages: JavaScript, C#, Go, and Clojure. In the meantime, happy coding! Don’t forget to follow the Conductor OSS project and support us by giving a ⭐.

Orkes Cloud is a fully managed and hosted Conductor service that can scale seamlessly to meet your needs. When you use Conductor via Orkes Cloud, your engineers don’t need to worry about setting up, tuning, patching, and managing high-performance Conductor clusters. Try it out with our 14-day free trial for Orkes Cloud.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!