En utilisant Schemaverse, vous forcez les producteurs à produire des messages basés sur la structure donnée en validant chaque message ingéré. Ceci est particulièrement utile si vous travaillez avec plusieurs producteurs. Il vous permet également de mettre en place des standards pour le schéma de votre produit et de faire évoluer votre schéma (En RUN TIME). Découvrons comment l’utilisation de Memphis Schemaverse augmentera la qualité de vos données.
Qu’est-ce que Memphis ?
Memphis{dev} est une plate-forme de traitement de données en temps réel open source qui fournit une prise en charge de bout en bout pour les cas d’utilisation de streaming dans l’application à l’aide du courtier de messages distribué Memphis.
« J’ai mis trois minutes à faire à Memphis ce qui m’a pris une semaine et demie à Kafka.
Memphis{dev} permet de créer des applications de nouvelle génération qui nécessitent de gros volumes de données en streaming et enrichies, des protocoles modernes, zéro opération, un développement rapide, une réduction extrême des coûts et un temps de développement nettement inférieur pour les développeurs et les ingénieurs de données orientés données.
Quatre piliers critiques
- Performances — Utilisation améliorée du cache
- Résilience — Ne perdez jamais un message et 99,95 % de disponibilité
- Observabilité — Observabilité prête à l’emploi qui a du sens et réduit le temps de dépannage
- Expérience développeur — Modularité, traitement en ligne, gestion des schémas, gitops. Fait par des développeurs pour n’importe qui, pas seulement des développeurs.
Principales caractéristiques de Memphis (actuelles et futures)
- Un courtier de messages cloud natif distribué
- Écrit en Golang
- Interface utilisateur et CLI low-code pour les ingénieurs, les opérations et les équipes produit
- Centre de surveillance et de notification prêt à l’emploi
- DLQ
- Suivi des messages en temps réel
- Gestion, validation et transformation de schémas
- Framework de connecteurs réalisé par l’équipe Memphis et la communauté *
- Enrichissement de flux sans serveur *
- Sécurité et audit améliorés
- Balisage d’objet
Contrats de données
Dans une plateforme de données fédérée, où les responsabilités sont réparties entre les parties prenantes, les équipes et les sources, il est plus difficile de contrôler et d’établir un standard unique. C’est là que le concept de contrats de données entre en jeu. Pourquoi les contrats de données sont-ils importants ? Parce que (a) ils fournissent des informations sur qui possède quels produits de données. (b) ils prennent en charge l’établissement de normes et la gestion de vos pipelines de données en toute confiance. Ils fournissent également des informations cruciales sur les données consommées, par qui et dans quel but. Conclusion : les contrats de données sont essentiels pour une gestion robuste des données !
Le bloc de construction de base pour contrôler et garantir la qualité des données qui circulent dans votre organisation entre les différents propriétaires consiste à définir des schémas et des modèles de données bien écrits.
Pourquoi?
- Les pipelines de données se cassent constamment et créent des problèmes de qualité des données ET de convivialité.
- Il existe un gouffre de communication entre les implémenteurs de services, les ingénieurs de données et les consommateurs de données.
- Il existe plusieurs approches pour résoudre ces problèmes, et les ingénieurs de données sont toujours des pionniers dans l’exploration de la frontière des meilleures pratiques futures.
Formats : un aperçu rapide des formats les plus populaires
- Protobuf
Le moderne. Les tampons de protocole sont le mécanisme extensible indépendant de la langue, de la plate-forme et de la sérialisation des données structurées de Google – pensez XML, mais plus petit, plus rapide et plus simple. - Avro
La populaire. Apache Avro™ est le principal format de sérialisation pour les données d’enregistrement et le premier choix pour les pipelines de données en continu. Il offre une excellente évolution de schéma. - JSON
Le plus simple. JSON Schema est un vocabulaire qui permet d’annoter et de valider des documents JSON.
Processus de sérialisation
La sérialisation convertit un objet de données – une combinaison de code et de données – en une série d’octets qui enregistre l’état de l’objet sous une forme facilement transmissible. Le processus inverse est appelé désérialisation. La sérialisation est essentiellement représentée comme une fonction, chaque format de données avec sa propre implémentation, et dans le cas où la structure et le contenu d’une donnée donnée ne correspondent pas au schéma défini dans la structure .proto/.avro/.json, le processus de sérialisation échoue, et par conséquent, le message ne sera pas envoyé au courtier. Ce processus établit la validation initiale du message avant qu’il n’atteigne le courtier lui-même, en utilisant le cache client pour stocker le schéma localement.
Memphis Schemavers
Memphis Schemaverse fournit un magasin de schémas robuste et une couche de gestion de schémas au-dessus du courtier Memphis sans calcul autonome ni ressources dédiées. Avec une interface utilisateur unique et moderne et une approche programmatique, les utilisateurs techniques et non techniques peuvent créer et définir différents schémas, attacher le schéma à plusieurs stations et choisir si le schéma doit être appliqué ou non. L’approche low-code de Memphis supprime la partie de sérialisation car elle est intégrée dans la bibliothèque du producteur. Schemaverse prend en charge la gestion des versions, les méthodologies GitOps et l’évolution des schémas.
Comprend également
- Excellente interface utilisateur et approche programmatique
- Intégrer au courtier
- Application de la confiance zéro
- Gestion des versions
- Surveillance prête à l’emploi
- Schémas d’importation et d’exportation
- Validation et sérialisation à faible/sans code
- Aucune configuration nécessaire
- Prise en charge native de Python, Go, Node.js
Commencer
Étape 1 : créer un nouveau schéma (actuellement uniquement disponible via Memphis Gui)
Étape 2 : Joindre le schéma
Dirigez-vous vers votre station, et dans le coin supérieur gauche, cliquez sur « + Joindre un schéma »
Étape 3 : Exemple de code dans Node.js
Memphis fait abstraction du besoin de fonctions de sérialisation externes et les intègre dans le SDK.
Producteur (exemple Protobuf)
const memphis = require("memphis-dev");
var protobuf = require("protobufjs");
(async function () {
try {
await memphis.connect({
host: "localhost",
username: "root",
connectionToken: "*****"
});
const producer = await memphis.producer({
stationName: "marketing-partners.prod",
producerName: "prod.1"
});
var payload = {
fname: "AwesomeString",
lname: "AwesomeString",
id: 54,
};
try {
await producer.produce({
message: payload
});
} catch (ex) {
console.log(ex.message)
}
} catch (ex) {
console.log(ex);
memphis.close();
}
})();Consommateur (nécessite un fichier .proto pour décoder les messages)
const memphis = require("memphis-dev");
var protobuf = require("protobufjs");
(async function () {
try {
await memphis.connect({
host: "localhost",
username: "root",
connectionToken: "*****"
});
const consumer = await memphis.consumer({
stationName: "marketing",
consumerName: "cons1",
consumerGroup: "cg_cons1",
maxMsgDeliveries: 3,
maxAckTimeMs: 2000,
genUniqueSuffix: true
});
const root = await protobuf.load("schema.proto");
var TestMessage = root.lookupType("Test");
consumer.on("message", message => {
const x = message.getData()
var msg = TestMessage.decode(x);
console.log(msg)
message.ack();
});
consumer.on("error", error => {
console.log(error);
});
} catch (ex) {
console.log(ex);
memphis.close();
}
})();