Je suis nouveau dans le traitement de flux (flux kafka/flink/tempête/étincelle/etc) et essayer de trouver la meilleure façon de gérer un problème du monde réel, représenté ici par un exemple de jouet. Nous sommes liés à Kafka pour notre ingestion de pubsub/data, mais n'avons aucun attachement particulier en termes de framework/approche de processeur de flux. En théorie, supposons que j'ai une source qui émet des valeurs à virgule flottante de façon sporadique. De plus, à un moment donné, il existe un multiplicateur M qui doit être appliqué aux valeurs de cette source; mais M peut changer, et d'un point de vue critique, je peux seulement découvrir le changement beaucoup plus tard - peut-être même pas "dans l'ordre de changement."architecture de traitement de flux: les événements futurs affectent les résultats passés
Je pense à représenter ceci dans Kafka
"Values": (timestamp, floating point value) - the values from the source, tagged with their emission time.
"Multipliers": (timestamp, floating point multiplier) - indicates M changed to this floating point multiplier at this timestamp.
Je serais alors tenté de créer un sujet de sortie, par exemple « Résultats », en utilisant un cadre de traitement de flux standard, qui relie les deux cours d'eau, et multiplie simplement chaque valeur en valeurs par le multiplicateur actuel déterminé par multiplicateurs. Cependant, d'après ce que j'ai compris, cela ne fonctionnera pas, car les nouveaux événements postés dans les multiplicateurs peuvent avoir un impact arbitrairement important sur les résultats déjà écrits dans le flux de résultats. Conceptuellement, j'aimerais avoir quelque chose comme un flux de résultats courant à partir du dernier événement envoyé aux multiplicateurs contre toutes les valeurs des valeurs, mais qui peut être «recalculé» lorsque d'autres événements Valeurs ou multiplicateurs entrent en jeu.
Quelles sont les techniques pour réaliser/architecturer ceci avec des processeurs de kafka et de flux principaux?
Exemple:
Dans un premier temps,
Values = [(1, 2.4), (2, 3.6), (3, 1.0), (5, 2.2)]
Multipliers = [(1, 1.0)]
Results = [(1, 2.4), (2, 3.6), (3, 1.0), (5, 2.2)]
Plus tard,
Values = [(1, 2.4), (2, 3.6), (3, 1.0), (5, 2.2)]
Multipliers = [(1, 1.0), (4, 2.0)]
Results = [(1, 2.4), (2, 3.6), (3, 1.0), (5, 4.4)]
Enfin, après un autre événement affiché à Multiplicateurs (et une nouvelle valeur émise aussi):
Values = [(1, 2.4), (2, 3.6), (3, 1.0), (5, 2.2), (7, 5.0)]
Multipliers = [(1, 1.0), (4, 2.0), (2, 3.0)]
Results = [(1, 2.4), (2, 10.8), (3, 3.0), (5, 4.4), (7, 10.0)]
À mon humble avis, c'est assez large pour vous donner une réponse concrète. La solution réelle dépendra des exigences: "Que devons-nous faire avec les données". Sur l'exemple fourni, je voudrais stocker les deux flux et faire l'opération sur lire: ie. quand les résultats sont nécessaires Mais cela pourrait ne pas être suffisant en fonction des exigences de l'application dans un scénario réel. – maasg
Dans ce programme, le multiplicateur multiple la valeur par clé. Votre résultat sera donc affecté. –
bon point maasg. Dans notre cas, il y a trop de données en streaming pour supporter le report du calcul. En outre, nous devons faire une sorte de requête, comme "donnez-moi toutes les valeurs de résultat et leur horodatage où la valeur est entre X et Y, autant que vous le sachiez selon les informations actuelles sur les multiplicateurs"; Impossible d'indexer les résultats de cette requête sans les avoir calculés. – jdowdell