L'intégration GO et Kafka est une solution efficace pour créer des systèmes de données en temps réel haute performance. La bibliothèque client appropriée doit être sélectionnée en fonction des besoins: 1. La priorité est donnée à Kafka-Go pour obtenir des API de style go simple et un bon soutien de contexte, adapté à un développement rapide; 2. Sélectionnez Sarama lorsque des fonctions de contr?le fin ou avancées sont nécessaires; 3. Lors de la mise en ?uvre des producteurs, vous devez configurer l'adresse du courtier, le thème et les stratégies d'équilibrage de chargement, et gérer les délais d'attente et les arrêts à travers le contexte; 4. Les consommateurs doivent utiliser des groupes de consommateurs pour atteindre l'évolutivité et la tolérance aux défauts, soumettre automatiquement les décalages et utiliser raisonnablement un traitement simultané; 5. Utilisez JSON, AVRO ou Protobuf pour la sérialisation, et il est recommandé de combiner le registre des schémas pour assurer la compatibilité des données; 6. Améliorer la résilience du système par des mécanismes de réessayer, les journaux structurés (tels que le ZAP) et la surveillance (comme Prometheus); 7. Gérez toujours les erreurs et implémentez la fermeture gracieuse pour s'assurer que les messages ne sont pas perdus. En résumé, l'adoption d'un modèle raisonnable peut permettre aux services GO de traiter efficacement les données à haut débit, ce qui convient aux architectures et aux communications microservices basées sur des événements.

GO est devenu un choix populaire pour construire des systèmes simultanés de haute performance, et Apache Kafka est une plate-forme de streaming distribuée de premier plan. La combinaison des deux permet aux développeurs de construire des pipelines de données évolutifs et en temps réel et des architectures motivées par des événements. L'intégration GO avec Kafka permet une ingestion, un traitement et une livraison efficaces des données de streaming sur les microservices et les plateformes de données.

Voici comment intégrer efficacement GO avec Kafka pour le streaming des données:

1. Choisissez le bon client kafka pour aller

Le client Kafka le plus utilisé et le plus exécuté dans l'écosystème Go est Shopify / Sarama . Il s'agit d'une bibliothèque Pure Go qui prend en charge les producteurs et les consommateurs, avec des fonctionnalités telles que SSL, l'authentification SASL et la compression de messages.

Alternativement, Segmentio / Kafka-Go fournit une interface GO idiomatique plus simple construite en haut du package net standard. Il est plus facile à utiliser pour les débutants et s'intègre bien au package context de Go.

Quand utiliser qui:

• Utilisez Sarama si vous avez besoin d'un contr?le à grains fins, des fonctionnalités avancées de Kafka ou si vous l'utilisez déjà en production.
• Utilisez Kafka-Go si vous préférez le code plus propre, une meilleure intégration de contexte et un développement plus rapide.

2. Implémentez un producteur de Kafka à Go

Un producteur publie des messages sur un sujet Kafka. Voici un exemple de base en utilisant Kafka-Go :

 package principal

importer (
    "contexte"
    "enregistrer"

    "github.com/segmentio/kafka-go"
)

func main () {
    écrivain: = & kafka.writer {
        Addr: kafka.tcp ("localhost: 9092"),
        Sujet: "My-Topic",
        Balancer: & kafka.leastbytes {},
    }

    err: = writer.writeMessages (context.background (),
        Kafka.Message {
            Clé: [] octet ("key-1"),
            Valeur: [] BYTE ("Hello Kafka de Go!"),
        },
    )
    Si err! = Nil {
        log.fatal ("échec du message:", err)
    }

    écrivain.close ()
}

Points clés:

• Utilisez context pour les délais d'expiration et les fermetures gracieuses.
• Gérer correctement les erreurs - les problèmes de travail et l'indisponibilité du courtier sont courants.
• Considérez le lot et la compression pour les scénarios à haut débit.

3. Construisez un consommateur Kafka avec une gestion des erreurs appropriée

Les consommateurs lisent les messages des sujets. Voici un simple consommateur en utilisant Kafka-Go :

 lecteur: = kafka.newreader (kafka.readerconfig {
    Brokers: [] String {"LocalHost: 9092"},
    Sujet: "My-Topic",
    GroupID: "My-Group", // Active les groupes de consommateurs et la gestion de la compensation
    Minbytes: 10e3, // 10kb
    Maxbytes: 10e6, // 10 Mo
})

pour {
    msg, err: = reader.readMessage (context.background ())
    Si err! = Nil {
        log.fatal ("Message de lecture d'erreur:", err)
    }
    Log.printf ("Re?u:% S | Sujet:% S | Partition:% D | Offset:% D",
        String (msg.value), msg.topic, msg.partition, msg.offset)
}

Meilleures pratiques:

• Utilisez toujours des groupes de consommateurs pour l'évolutivité et la tolérance aux défauts.
• Engagez régulièrement des compensations (Kafka-Go le fait automatiquement sauf si désactivé).
• Utilisez des goroutines simultanées pour traiter les messages en parallèle, mais soyez prudent avec l'état partagé.

Exemple: processus des messages simultanément:

 aller func () {
    pour {
        msg, _: = reader.readMessage (context.background ())
        Go Func (M Kafka.Message) {
            // Message de traitement
            Log.println ("Traitement:", String (m.value))
        } (msg)
    }
} ()

4. Gérer la sérialisation et la gestion des schémas

Les messages Kafka sont des octets bruts. Pour les données structurées, utilisez des formats de sérialisation comme:

• JSON - simple et lisible
• Avro / Protobuf - Efficient et Forced (mieux pour les systèmes à grande échelle)

Avec Protobuf:

 données, _: = proto.marshal (& myevent {userId: 123, action: "ligin"})
writer.WriteMessages (CTX, Kafka.Message {Value: Data})

Utilisez le registre des schémas (par exemple, Registre du schéma confluent) avec AVRO pour appliquer la compatibilité et le versioning.

5. Assurer la résilience et l'observabilité

Les systèmes de streaming doivent être résilients. Considérer:

• Retries et revers pour les échecs transitoires
• Journalisation et surveillance (par exemple, prometheus grafana)
• Arrêt gracieux pour éviter de perdre des messages

Exemple: Ajouter la logique de réessayer

 Var Err Error
pour i: = 0; i <3; je {
    err = writer.writeMessages (CTX, msg)
    Si err == nil {
        casser
    }
    Time.Sleep (time.Duration (i 1) * time.second)
}
Si err! = Nil {
    log.fatal ("échec après les tentatives:", err)
}

Utilisez la journalisation structurée (par exemple, zap ou logrus ) pour suivre le flux de messages et les erreurs.

Conclusion

Intégrer GO avec Kafka est une combinaison puissante pour construire des systèmes de données en temps réel. Utilisez Kafka-Go pour la simplicité et les modèles GO modernes, ou Sarama pour des cas d'utilisation avancés. Concentrez-vous sur la bonne gestion des erreurs, la sérialisation et l'observabilité pour assurer la fiabilité.

Avec les bons modèles, les services GO peuvent produire et consommer efficacement des flux de haut volume, ce qui les rend idéaux pour l'approvisionnement en événements, l'agrégation de journaux et la communication des microservices.

Fondamentalement, restez simple, gérez les erreurs et évoluez intelligemment.

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!