Développer des applications modernes, qu'elles soient destinées au cloud, à l'edge computing ou à d'autres environnements, peut être un défi de taille. Entre la gestion de l'état, la communication entre microservices, la scalabilité et la tolérance aux pannes, de nombreux aspects doivent être pris en compte. C'est là que Dapr entre en jeu.

Introduction

Dapr, acronyme de Distributed Application Runtime, est un event driven runtime qui facilite la création d'applications résilientes, qu'elles soient stateless ou stateful, s'exécutant sur un environnement cloud ou non. Il fournit un ensemble de services abstraits permettant aux développeurs de se concentrer sur la logique métier grâce aux avantages d'une architecture de type sidecar.
Dans cet article, nous allons explorer comment déployer une application Java sur Kubernetes, utilisant Dapr pour la gestion des événements Kafka.

Configuration de l'environnement

La première étape consiste à installer Dapr, dans cet exemple nous allons utiliser Helm:

Assurez-vous d'avoir Helm installé sur votre système.
Ajoutez le référentiel Dapr Helm.

helm repo add dapr https://dapr.github.io/helm-charts/
helm repo update

Créez un fichier de configuration values.yaml pour personnaliser la configuration Dapr. Vous pouvez consulter les options de configuration disponibles dans la documentation officielle de Dapr.
Installez Dapr avec Helm en spécifiant le fichier values.yaml

install dapr dapr/dapr -f values.yaml

Vous pouvez consulter la documentation officielle de Dapr pour trouver d'autres options d'installation et de configuration.

Création de l'application Java

Nous allons créer une application simple qui expose un endpoint HTTP et utilise Dapr pour publier des messages sur un topic Kafka.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication
public class SimpleApplication {

    public static void main(String[] args) {
        SpringApplication.run(SimpleApplication.class, args);
    }

    @PostMapping("/publish")
    public void publishMessage(@RequestBody String message) {
        // Logique de publication du message sur Kafka
        System.out.println("Message kafka reçu: " + message);
    }
}

Configuration de Dapr

Afin que Dapr puisse interagir avec Kafka, nous devons créer un composant de type pubsub.kafka. Voici un exemple :

apiVersion: dapr.io/v1alpha1
kind: Component
metadata:
  name: kafka
spec:
  type: pubsub.kafka
  metadata:
  - name: brokers
    value: "kafka.kafka.svc.cluster.local:9092"
  - name: version
    value: "2.8.0"

Assurez-vous d'adapter les valeurs selon votre configuration Kafka.

Déploiement sur Kubernetes

Nous allons maintenant déployer notre application Java et configurer Dapr en tant que sidecar.

Création des fichier deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-app
spec:
  selector:
    matchLabels:
      app: java-app
  template:
    metadata:
      labels:
        app: simple-app
    spec:
      containers:
      - name: simple-app
        image: <votre-image-docker>
        ports:
        - containerPort: 8080
      - name: dapr-sidecar
        image: "dapr/placeholder:latest"
        ports:
        - containerPort: 3500

Remplacez <votre-image-docker> par le chemin de votre image que vous avez déjà créée et déployée dans votre registre docker.

dapr.yaml

apiVersion: dapr.io/v1alpha1
kind: Configuration
metadata:
  name: dapr-config
spec:
  tracing:
    samplingRate: "1.0"

Dans le cas où vous ne souhaiter pas avoir un fichier de configuration Kafka séparé, vous pouvez ajouter la partie configuration du composent pubsub dans le fichier dapr.yaml:

apiVersion: dapr.io/v1alpha1
kind: Configuration
metadata:
  name: dapr-config
spec:
  tracing:
    samplingRate: "1.0"
  components:
    - name: kafka
      type: pubsub.kafka
      metadata:
        - name: brokers
          value: "kafka.kafka.svc.cluster.local:9092"
        - name: version
          value: "2.8.0"

Votre application Java est maintenant prête à être déployée sur Kubernetes avec Dapr configuré en tant que sidecar pour la gestion des événements avec Kafka

Conclusion

Dans cet article, nous avons exploré comment déployer une application Java sur Kubernetes, utilisant Dapr en tant que sidecar pour la gestion des événements avec Kafka. En utilisant Dapr, nous avons pu séparer la logique de gestion des événements de notre application principale, ce qui rend notre application plus modulaire et facile à maintenir.