Valider les schémas pour les applications Apache Kafka avec Avro (Java)

Article
10/21/2023

Dans ce guide de démarrage rapide, nous explorons comment valider un événement à partir d’applications Apache Kafka avec Azure Schema Registry pour Event Hubs.

Dans ce cas d’usage, une application producteur Kafka utilise le schéma Avro stocké dans Azure Schema Registry pour sérialiser l’événement et le publier dans une rubrique/un hub d’événements Kafka au sein d’Azure Event Hubs. Le consommateur Kafka désérialise les événements qu’il consomme à partir d’Event Hubs. Pour cela, il utilise l’ID de schéma de l’événement et le schéma Avro, qui est stocké dans Azure Schema Registry.

Diagram showing schema serialization/de-serialization for Kafka applications using Avro schema.

Prérequis

Si vous débutez avec Azure Event Hubs, consultez la vue d’ensemble d’Event Hubs avant de suivre ce guide de démarrage rapide.

Pour effectuer ce démarrage rapide, vous avez besoin de ce qui suit :

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Dans votre environnement de développement, installez les composants suivants :
- Java Development Kit (JDK) 1.7+.
- Téléchargez et installez une archive binaire Maven.
- Git
Clonez le dépôt Azure Schema Registry pour Kafka.

Créer un hub d’événements

Suivez les instructions fournie dans Démarrage rapide : Créer un espace de noms Event Hubs et un Event Hub pour créer un espace de noms Event Hubs et un Event Hub. Suivez ensuite les instructions fournies dans Obtenir la chaîne de connexion pour obtenir une chaîne de connexion à votre espace de noms Event Hubs.

Notez les paramètres suivants que vous allez utiliser dans le guide de démarrage rapide actuel :

Chaîne de connexion pour l’espace de noms Event Hubs
Nom du Event Hub

Créer un schéma

Suivez les instructions de Créer des schémas à l’aide du registre de schémas pour créer un groupe de schémas et un schéma.

Créez un groupe de schémas nommé contoso-sg à l’aide du portail Registre de schémas. Utilisez Avro comme type de sérialisation et Aucun pour le mode de compatibilité.

Dans ce groupe de schémas, créez un nouveau schéma Avro avec le nom de schéma : Microsoft.Azure.Data.SchemaRegistry.example.Order à l’aide du contenu de schéma suivant.

{
  "namespace": "Microsoft.Azure.Data.SchemaRegistry.example",
  "type": "record",
  "name": "Order",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "amount",
      "type": "double"
    },
    {
      "name": "description",
      "type": "string"
    }
  ]
}

Inscrire une application pour accéder au registre de schémas

Vous pouvez utiliser Microsoft Entra ID pour autoriser votre application productrice et client Kafka à accéder aux ressources Azure Schema Registry en enregistrant votre application client auprès d'un locataire Microsoft Entra à partir du portail Azure.

Pour enregistrer une application Microsoft Entra nommée, example-app consultez Enregistrer votre application auprès d'un locataire Microsoft Entra.

tenant.id : définit l’ID de locataire de l’application
client.id : définit l’ID client de l’application
client.secret : définit la clé secrète client pour l’authentification

Et si vous utilisez une identité managée, vous avez besoin des éléments suivants :

use.managed.identity.credential : indique que les informations d’identification MSI doivent être utilisées pour une machine virtuelle avec MSI
managed.identity.clientId : si spécifié, génère des informations d’identification MSI avec l’ID client donné
managed.identity.resourceId : si spécifié, génère des informations d’identification MSI avec l’ID de ressource donné

Ajouter un utilisateur au rôle Lecteur du registre de schémas

Ajoutez votre compte d’utilisateur au rôle Lecteur du registre de schémas au niveau de l’espace de noms. Vous pouvez également utiliser le rôle Contributeur du registre de schémas, mais ce n’est pas nécessaire pour ce démarrage rapide.

Sur la page Espace de noms Event Hubs, sélectionnez Contrôle d’accès (IAM) dans le menu de gauche.
Sur la page Contrôle d’accès (IAM), sélectionnez + Ajouter ->Ajouter une attribution de rôle dans le menu.
Sur la page Type d’affectation, sélectionnez Suivant.
Sur la page Rôles, sélectionnez Lecteur du registre de schémas (préversion), puis sélectionnez Suivant en bas de la page.
Utilisez le lien + Sélectionner des membres pour ajouter l’application example-app que vous avez créée à l’étape précédente au rôle, puis sélectionnez Suivant.
Sur la page Vérifier + attribuer, sélectionnez Vérifier + attribuer.

Mettre à jour la configuration de l’application cliente des applications Kafka

Vous devez mettre à jour la configuration client des applications productrices et consommatrices Kafka avec la configuration liée à l'application Microsoft Entra que nous avons créée et les informations du registre de schéma.

Pour mettre à jour la configuration du producteur Kafka, accédez à azure-schema-registry-for-kafka/tree/master/java/avro/samples/kafka-producer.

Mettez à jour la configuration de l’application Kafka dans src/main/resources/app.properties en suivant le guide de démarrage rapide Kafka pour Event Hubs.
Mettez à jour les détails de configuration du producteur dans src/main/resources/app.properties à l'aide de la configuration liée au registre de schémas et de l'application Microsoft Entra que vous avez créée ci-dessus, comme suit :
```
schema.group=contoso-sg
schema.registry.url=https://<NAMESPACENAME>.servicebus.windows.net

 tenant.id=<>
 client.id=<>
 client.secret=<>
```
Suivez les mêmes instructions et mettez également à jour la configuration azure-schema-registry-for-kafka/tree/master/java/avro/samples/kafka-consumer.

Pour les applications producteur et consommateur Kafka, le schéma Avro suivant est utilisé :

{
  "namespace": "com.azure.schemaregistry.samples",
  "type": "record",
  "name": "Order",
  "fields": [
    {
      "name": "id",
      "type": "string"
    },
    {
      "name": "amount",
      "type": "double"
    },
    {
      "name": "description",
      "type": "string"
    }
  ]
}

Utilisation du producteur Kafka avec la validation de schéma Avro

Pour exécuter l’application producteur Kafka, accédez à azure-schema-registry-for-kafka/tree/master/java/avro/samples/kafka-producer.

Vous pouvez exécuter l’application producteur afin qu’elle puisse produire des enregistrements spécifiques à Avro ou des enregistrements génériques. Pour le mode avec enregistrements spécifiques, vous devez d’abord générer les classes sur le schéma producteur avec la commande maven suivante :
```
mvn generate-sources
```

Vous pouvez ensuite exécuter l’application producteur avec les commandes suivantes.

mvn clean package
mvn -e clean compile exec:java -Dexec.mainClass="com.azure.schemaregistry.samples.producer.App"

Une fois réussie l’exécution de l’application producteur, elle vous invite à choisir le scénario de producteur. Dans le cadre de ce guide de démarrage rapide, vous pouvez choisir l’option 1 : produire des enregistrements spécifiques à Avro.
```
Enter case number:
1 - produce Avro SpecificRecords
2 - produce Avro GenericRecords
```

Une fois la sérialisation et la publication des données réussies, vous devez voir les journaux de console suivants dans votre application producteur :

INFO com.azure.schemaregistry.samples.producer.KafkaAvroSpecificRecord - Sent Order {"id": "ID-0", "amount": 10.0, "description": "Sample order 0"}
INFO com.azure.schemaregistry.samples.producer.KafkaAvroSpecificRecord - Sent Order {"id": "ID-1", "amount": 11.0, "description": "Sample order 1"}
INFO com.azure.schemaregistry.samples.producer.KafkaAvroSpecificRecord - Sent Order {"id": "ID-2", "amount": 12.0, "description": "Sample order 2"}

Utilisation du consommateur Kafka avec la validation de schéma Avro

Pour exécuter l’application consommateur Kafka, accédez à azure-schema-registry-for-kafka/tree/master/java/avro/samples/kafka-consumer.

Vous pouvez exécuter l’application consommateur afin qu’elle puisse consommer des enregistrements spécifiques à Avro ou des enregistrements génériques. Pour le mode avec enregistrements spécifiques, vous devez d’abord générer les classes sur le schéma producteur avec la commande maven suivante :
```
mvn generate-sources
```

Vous pouvez ensuite exécuter l’application consommateur avec la commande suivante.

mvn clean package
mvn -e clean compile exec:java -Dexec.mainClass="com.azure.schemaregistry.samples.consumer.App"

Une fois l’application consommateur exécutée avec succès, elle vous invite à choisir le scénario de producteur. Dans le cadre de ce guide de démarrage rapide, vous pouvez choisir l’option 1 : consommer des enregistrements spécifiques à Avro.
```
Enter case number:
1 - consume Avro SpecificRecords
2 - consume Avro GenericRecords
```

Une fois réussies la consommation et la désérialisation des données, vous devez voir les journaux de console suivants dans votre application producteur :

INFO com.azure.schemaregistry.samples.consumer.KafkaAvroSpecificRecord - Order received: {"id": "ID-0", "amount": 10.0, "description": "Sample order 0"}
INFO com.azure.schemaregistry.samples.consumer.KafkaAvroSpecificRecord - Order received: {"id": "ID-1", "amount": 11.0, "description": "Sample order 1"}
INFO com.azure.schemaregistry.samples.consumer.KafkaAvroSpecificRecord - Order received: {"id": "ID-2", "amount": 12.0, "description": "Sample order 2"}

Nettoyer les ressources

Supprimez l’espace de noms Event Hubs ou supprimez le groupe de ressources contenant l’espace de noms.

Partager via