Sarama Go : guide complet avec exemples pratiques

Qu'est-ce que Sarama et pourquoi l'utiliser ?

Sarama est une bibliothèque Go haute performance, écrite en pur Go, pour interagir avec Apache Kafka. Elle offre un ensemble complet d'outils pour communiquer avec un cluster Kafka, notamment des producteurs (producers) pour envoyer des messages, des consommateurs (consumers) pour les lire, ainsi que des fonctions d'administration pour gérer les topics, les partitions et les configurations.

Apache Kafka est une plateforme de streaming distribuée utilisée pour construire des pipelines de données en temps réel, des systèmes de messagerie, du traitement d'événements et du stockage de logs. Sarama permet aux applications Go de s'intégrer facilement à Kafka, garantissant un transfert de données fiable et efficace.

Pourquoi choisir Sarama ?

• Pur Go : Sarama est entièrement écrite en Go, sans dépendances externes en C/C++, ce qui simplifie la compilation et le déploiement.
• Haute performance : La bibliothèque est optimisée pour gérer de gros volumes de données et prend en charge l'envoi asynchrone de messages.
• Flexibilité : Elle supporte différents modes de fonctionnement pour les producteurs (synchrone, asynchrone) et les consommateurs (simple, groupe de consommateurs).
• Communauté active : Sarama est l'une des bibliothèques Kafka les plus populaires pour Go, avec de nombreux contributeurs et une documentation complète.
• Contrôle total : Elle offre au développeur un contrôle complet sur la configuration, y compris la gestion des offsets, la sérialisation/désérialisation et la gestion des erreurs.

Installation

L'installation de Sarama dans un projet Go se fait de manière standard via le gestionnaire de paquets go get.

go get github.com/IBM/sarama

Après avoir exécuté cette commande, la bibliothèque sera ajoutée à votre fichier go.mod et vous pourrez l'importer dans votre code.

Important : Assurez-vous d'avoir installé Go version 1.18 ou supérieure, car Sarama utilise les fonctionnalités modernes du langage.

Démarrage rapide : envoyer et recevoir des messages

Écrivons un exemple simple qui envoie un message dans un topic Kafka et le lit.

1. Producteur (Producer) — envoi d'un message

package main

import (
    "fmt"
    "log"

    "github.com/IBM/sarama"
)

func main() {
    // 1. Configuration du producteur
    config := sarama.NewConfig()
    config.Producer.Return.Successes = true // Nécessaire pour le mode synchrone
    config.Producer.RequiredAcks = sarama.WaitForAll // Attendre l'accusé de réception de toutes les répliques

    // 2. Création d'un producteur synchrone
    producer, err := sarama.NewSyncProducer([]string{"localhost:9092"}, config)
    if err != nil {
        log.Fatalf("Impossible de créer le producteur : %v", err)
    }
    defer producer.Close()

    // 3. Création du message
    msg := &sarama.ProducerMessage{
        Topic: "mon-topic",
        Key:   sarama.StringEncoder("ma-cle"),
        Value: sarama.StringEncoder("Bonjour, Kafka !"),
    }

    // 4. Envoi du message
    partition, offset, err := producer.SendMessage(msg)
    if err != nil {
        log.Fatalf("Impossible d'envoyer le message : %v", err)
    }

    fmt.Printf("Message envoyé dans la partition %d avec l'offset %d\n", partition, offset)
}

2. Consommateur (Consumer) — réception du message

package main

import (
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/IBM/sarama"
)

func main() {
    // 1. Configuration du consommateur
    config := sarama.NewConfig()
    config.Consumer.Return.Errors = true
    config.Consumer.Offsets.Initial = sarama.OffsetOldest // Lire depuis le début

    // 2. Création du consommateur
    consumer, err := sarama.NewConsumer([]string{"localhost:9092"}, config)
    if err != nil {
        log.Fatalf("Impossible de créer le consommateur : %v", err)
    }
    defer consumer.Close()

    // 3. Abonnement à une partition
    parti