Adobe每秒200万条记录如何使用Apache火花!

视频记录

——[Yeshwanth Vijayakumar)嗨,伙计们,这是Yeshwanth Vijayakumar。我是一个项目领导在Adobe体验平台。bob体育客户端下载具体的统一的团队。今天的讲座是关于Adobe如何使用Apache引发大量的吞吐量。

今天的目标,我想保持尽可能简单。第一件事是分享的技巧和经验,从我们的不同的用例。第二件事是,希望它能节省你至少一个小时的时间。有一件事我已经意识到这些年来,我们总是想做一些真的是利基。然后我和他们说话的人越多,他们说,“哦,我的上帝,”他为什么不告诉我过吗?“所以,这是一种组合的深度和我遇到的东西。我想分享。

处理是什么意思?议程!

设置议程,对吧?处理是什么意思?我想看它在多个水平。所以我把演讲分成三个不同的部分。第一,当我们说吞吐量,我们也有摄入,就像我们如何获取数据。我们有一个相关联的吞吐量。第二部分是评价,你知道,查询处理。所以,我们通常讲的更常见的吞吐量。但可能是我。第三件事是,复述。 I just wanna go a bit about how it kind of applies to a lot of the use cases that we’ve seen, and how we can get a bit of extra juice from it.

让我们来谈谈现在的摄入情况。

统一配置文件数据摄入

统一的团队,基本上在这个数据从许多不同的来源,如Adobe运动。Adobe运动,对于那些不知道这就像电子邮件针对一些解决方案与所有的批处理和爆炸之类的。很多营销的用例。我就像网站建设。Adobe分析是最大的网络分析供应商之一。然后还像Adobe广告云。所以你有大量的你知道,市场信息流动的所有这些不同的客户。可以以多种格式和数据。可以是JSON,拼花,protobuf但是关键是,B44,一旦土地变成一个平台在这一棵树,或经验数据模型,这是一个标准化的数据模型,我们对市场营销的用例。bob体育客户端下载一旦在那里,它进入统一的形象店,基本上给你像一个360度视角营销用例。 Like I could make a cray like, “Hey, get me all the people who did, “who saw an advertisement for a Photoshop, “but did a trier of illustrator in the last three weeks.” And what you say did not get an email from Adobe in the last 30 days. So, you can make a lot of complicated and powerful segmentation use cases. Just with your first party data, are the party data. But the key thing that we’re gonna focus on, once it gets there, we’re gonna focus on the statistic creation, once it gets into the unified profile store. So, with respect to the ingestion thing. So all of this is getting piped into say a Kafka topic. So you have a fire hose of data flowing in. So, and we’re gonna build statistics on top of them, okay? So, that’s the setting of what we’re gonna talk with respect to the throughput. The first thing is we’re gonna go over, knowing what the lag is. Before we go into throughput, right? We need to know what we need to measure. Specifically with such a high volume of data flowing in. We want to be able to measure a lot of things, like what is the simple things that spot streaming gives you right out of the box, through the streaming credit listener. Like you get a handle on every credit progress. So whenever a micro batch completes, this handle gets called, and you are able to get. (mumbles) The number of rules that got ingested into the micro batch, and also things like how many rows got processed per second, the ad batch time. So, you get a good amount of information from just the vanilla metrics, that comes with the on query progress. But then, I mentioned that the kind of listening to like an offstream Kafka. So this fire hose. So, more often than not, you’re gonna fall back. So, apart from the throughput, you also need to know where you are at that point of time, when you’re processing information.

我偶然发现这很酷的博客,哪种进入如何跟踪,卡夫卡的延迟你的话题。一个利基技巧是,我们为同一主题创建一个虚拟消费者团体,我们听。从火花,然后获取进步信息的结构化流创造力。然后他们回信检查点状态,消费者团体。所以,你有一个主题,你有一个特定的消费群体来跟踪我们读过多少,和我们喂养火花流债权人。一旦你注册,你可以使用像洞穴一样,如果你熟悉卡夫卡洞穴。

使用洞穴跟踪滞后

你可以跟踪你的滞后。所以,现在你可以了解,好吧,5月23日午夜12点,我们有一个20亿年的滞后。所以,这意味着。所以它的意思。所以,你知道我们继续跨多个时间段,我们做得有多好,或者我们需要做多少?这是一个关键的问题。另一件事是当然的香草度量标准,您也可以跟踪记录每秒,马上,你可以有一个破坏者。你可以看到它,我们做的每秒300万个问题,很简单,容易实现。所以,现在我们知道我们需要测量,以及如何测量它,就像我知道我们经历了非常快的方式,但是希望能给你一个想法是什么。现在我们可以进入。 How do we actually achieve that?/ With respect to optimizing the ingestion, that is the read.

我们想看看,但是之前我们去那里,对吧?让我们看一下我描述的通用流。所以,我们有一个卡夫卡的话题,有一些分区。然后我们有一些盒子流媒体应用程序,读入数据,并分发到执行人的。和执行人有一些业务逻辑。使用这个业务逻辑,业务逻辑,我们做一些处理,并将其写入一个外部数据库。到目前为止一切顺利,很酷。现在,让我们进入实际,优化提示点的方法。所以对于这三个树突。这部分的代码,我是的,你必须熟悉它,因为这是有点像卡夫卡101结构化流媒体网站。 But then we’re gonna kind of dig in into a couple of important aspects, through which we can tune our applications. The first thing that we wanna do, is we’re going to set the executors and this constant let’s pick a number. I’m gonna just draw a line in this. And don’t go too low. Otherwise you’re gonna have a big phone. And then once you keep this constant, they are going to pay attention to this parameter, maxOffsetsPerTrigger The structure streaming competent with Kafka, it’s predominantly your pool-based interface. So, we decide how many offsets they’re going to pull from Kafka per trigger interval, meaning, say if you’re trigger interval for the micro batch is say 30 seconds. And if this value is say a hundred thousand, we will be like, okay, every 30 seconds, we are gonna pull in hundred K entries from Kafka, and that’s going to be distributed across to your executor’s. So, this becomes the first gate that we need to optimize on.

首先,假设我们非常乐观,我们就选一个号码,说,这是目标每秒,我想去。所以计算触发,并设置它的最大补偿基于这个基础。

接下来我们要做的是,我们的所有监控到位。他们会监控处理时间。处理时间,我们会将其和触发间隔。为了一个例子,让我们来触发间隔30秒。每30秒我们拉在一百年关键记录,然后说我们的处理时间不会监视仪表盘上的分别,你设置它。即使是在充满活力的方式,如果处理时间需要40秒。现在的数据,每30秒钟你了一些数据,但你需要40秒来处理它。所以你不会赶上这个吞吐量。(喃喃自语)所以,这不是你理想的吞吐量。因此,我们需要现在我们所说的清洗和重复。 So, what we’re gonna do is, if we see that the processing time is veil assessor, than the trigger iterval you know that you have some headroom to grow QPS wise. So increase it. Easy thing is like as you know, step in terms of doubles, like kind of like a binary search approach. So you keep increasing until you find your niche process, or to say maxOffsetsPerTrigger such that your processing time is as close to your trigger interval. Once you’ve kind of gone through the process with respect to that, the next thing that we wanna do, is we wanna look at this interesting parameter called min partitions. So min partitions, basically it enables a fan-out pattern. It maps one Kafka partition. (mumbles) Maps one Kafka partition to multiple sub-partitions within the executer. We are gonna take it a much more deeper in the the next slide so that, get a visual and representation of that. But then the key aspect is that as VDP di process, multiple times, we will end up with a proper throughput per code.

当然,假设,你知道像摇滚明星在这里,我们有一些很好的优化业务逻辑代码,它知道它在做什么。这个假设,为特定的代码,他们计算,为特定类型的实例和一切,我们计算吞吐量/代码。现在我们可以横向规模。

这里有一些警告,特别是像网络带宽等等。但是,通常这不是,如果你通常认为网络是你的问题,10倍的,也许不是。现在让我们挖得深一些,如果我们设置主分区的数量大于分区卡夫卡。

流与MinPartitions卡夫卡>分区

这里的例子是,让我们把这个话题有两个分区,和我们有三个执行人。现在说,如果我说主分区等于6,现在会发生什么是每个分区会分成多个子分区。所以,你可以看到遗嘱执行人,分区1.1,1.2。第三,除了一个好的分割成进入执行程序。所以,这是一个非常有趣的事情,因为很多的时间。所以在最初的阶段,我就像当我还是越来越挂在吞吐量,我曾经告诉管道团队,“嘿,伙计们,我想我是饱和。“你能增加分区卡夫卡的数量吗?”,他们会说,“不,伙计,这是很难的。:“我们不能继续增加,当你想要的分区。“当然,他们是对的。所以你不能这样做。相反,最简单的做法是吸引更多数据,然后做一个扇出模式,根据自己的应用程序。 And this is something that the main partitions helps you do with respect to scaling your application. Instead of you saying like, “Hey, you know what, what and like by how many partitions “are there in Kafka?” What you are bottlenecked is, how fast you can read from Kafka that doesn’t change. Now that is somewhere, the net network actually plays a big part.

所以,现在澄清,你知道我说的,这个逻辑是坚如磐石,我们优化它。

MicroBatch困难!逻辑的最佳实践

我们使用,说你可能已经做了所有基准测试,他们说你做了什么或微板凳盯你知道哪些JSON培养你使用,完成。但有一件事我认识到,尽管,你还会犯一些错误。所以,我注意的一件事是什么进化自己的代码,这两个模式之间的主要区别,也就是地图或forEach或你知道这是在记录,记录的基础上,与地图分区或forEach批,这本身已经像一个批处理的概念和它的名字。如果你观察,地图或forEach的事情,在优点方面,几乎每一个hello示例代码很容易。它使用一个映射或forEach。这是超级简单的可视化。这可能是最简单的方法,你可以开始使用。但对于缺点,对吧?它的低。我相信很多人,我知道你可能不知道你在做什么。 And I’m just saying it from my own experience, with respect to seeing nine out of 10 times, it’s usually slow and how to read rewrite it as, a map partition of forEach batch. So, a lot of bias altered in my truck. With respect to why it’s usually slow, is that you don’t have a lot of local aggregations. And even if you want to do local aggregations, you need to specify explicit combiners. Specifying combiners and spark, is probably like feeling deep, potentially. That’s one thing that I don’t actually enjoy in the spark API, but yeah. The next thing is, it also spawns up a lot of individual tasks.

可能是好是坏取决于情况。然后我觉得最主要的是很多次,我们有下游处理器。所以,很难得到正确的连接管理,当你使用单独的记录。(喃喃自语)当然forEach作家,是一个值得注意的例外,但我喜欢和我的东西更细粒度的控制。如果你到达地图分区,或者forEach批平行的,对吧?这些都是优点。你有明确的连接管理。接下来我们将看一个例子。然后下一个是,这能帮助你你知道,批处理事情更容易,你可以更有效地重用连接。另一件事是,你可以有地方使用你知道像你可以聚合,如hashmap或任何数据结构集。 You can use it at the partition level and then go for it. So you get like local aggregations, and you have complete control over it. The next thing with respective cons, is that when you look at it, it’s not exactly easy to visualize.

你需要更多的内存。所以,在地图上或forEach,你做记录,记录。在这里,你实际上是模拟配料过程。因此,输入负载会显著提高。所以,你需要重新评估实施的记忆,根据这个工作负载之类的。不仅仅是会说,“哦,我有相同的实例。“我要把它交给我的包和批处理它。“不,那是行不通的。当然,就像我说的,是丑的想象。现在,我们要看看,哦!有一件事。 Like I said, memory is one thing, but there’s also CPU. Usually we don’t bother to change our spot per CPU’s. It’s usually set to one or two, but then depending upon how well you are batching, or paralyzing within your map partitions or your forEach batch. You might wanna add a little bit more juice to your spark or task per CPU’s.

一个例子

现在,如果你看一个例子对吧?这是来自另一个讨论在同一火花峰会。这会创建一些布鲁姆过滤器事件流的流动,我们使用一批forEach构造看到什么,然后他们要构建布鲁姆过滤器和船去复述。

如果你仔细看看这个,顶部的forEach批处理,我们有一个共同的复述,连接,线程安全的复述,连接可以得到重用,任何下游。然后接下来的部分,你会发现他们有一个当地的聚合,你知道,像所有的独特的产品在一个批处理。这是一套,所以你得到的地方聚集在forEach批级别。一旦你得到,你可以看到他们在做一个更新的布隆过滤器下游复述,使用通用的连接。要注意的关键是,这forEach很容易瘫痪和线程。(喃喃自语),然后对连接管理,我们可以发出一个明确的结束,这样我们就可以高枕无忧,我们不是导致很多问题关于数据库连接管理下游的一面。

与结束这个例子中,如果我们要进入下一张幻灯片。

猜测!

另一个常见的事情在处理如此高的吞吐量

在输入时本身就是在这样一个高容量,你将要看到的是,您的流程可能开始这样做。但后一到两天,这些都是长时间运行的应用程序,甚至一两天之后,你会看到一些退化。可能是机器,它可以在垃圾收集之类的。一些你的任务出发,可能会慢下来,像,为什么会这样?它开始运行。它跑了两个小时或三个小时或24小时。这是为什么还发生了吗?所以,贫民窟,所以火花这极其简洁的特性称为“投机执行”。是,究竟发生了什么,如果投机执行被设置为true,如果你有一些缓慢运行任务,苍白地推出了其他遗嘱执行人。和新任务,如果他们完成在缓慢运行的任务之前,旧的任务被杀死了。所以,我们猜测。 That’s saying like, okay, this will then. And this is extremely useful, because we do as an even if some nodes get really slow, because we have speculative execution on, we will be able to kind of get to the same average timings that we had before, so that the throughput doesn’t drop drastically. One cool parameter apart from just turning on speculative execution, is also the spark.speculation.quantile.

所以,告诉你多少的任务必须完成,之前启用的猜测。9点意味着,90%的任务必须投机执行监控甚至开始之前就已经完成了。所以,如果你看看我们这里的例子,您可以看到,通常需要两到三秒每一步,然后强调了两个步骤七秒,六秒,你可以看到很多任务被杀。所以,这只是意味着投机执行决定,好吧,一切都乱了套。他们不正常。让我们产生了新的任务,并确保他们迎头赶上。所以,这可能是说这不会导致一个巨大的波动在计时。你需要标签保持大约在同一时间。这个个人被一个巨大的救命稻草的监视或起始过程,等等。

我们经历了摄入的吞吐量小费。所以,但现在我们将开关齿轮,和进入评估场景。但主要是对,我们会有一些查询和我们如何评价他们。

我们处理呢?

首先,让我们得到一些上下文关于我们要评估,或结构是什么样子的?我们的主要目标,是我们想要尽可能多的查询并行运行的规范化的数据帧。什么我的意思是,如果你想象,说你有查询,查询1000。在我们专业的用例,我为我的团队,我们要做的就是要把这些千查询和我们希望它像一个大非正规数据上运行框架。

这里的关键是,他们不依赖于引发基于成本的优化器。主要原因是,每个查询需要查看每个房间,和查询的字段的子集感兴趣,可能是在整个的所有字段,数据帧的所有列。所以,这意味着所有的压低,所有的过滤器不起作用。所以我们不需要一个基于成本的优化器,因为它总是一个全表扫描。所以鉴于这种完美风暴,我们如何优化和激活。下一件事是,我们想要一种交互式处理层。所以一旦有人提交查询,你想要,所以有人在另一端等待背后的UI,幸存下来得到真实的结果。我们如何为别人得到实时的结果?所以的意思是实时的…我的意思是,你需要完成的查询表示秒,10秒,20秒在马克斯。

所以,鉴于这种问题陈述,有些事情,我们发现阻塞。

|学会如何缓存我物理的艺术计划

所以,我们要看他们。第一件事是,我们如何学会缓存身体计划。这是一个不错的,主要是因为如果你重复查询在同一数据帧,从RDBMS土地的一些灵感。

对于重复查询在DF相同

所以,特别是我们准备好的语句在RDBMS,喜欢这里的例子中,产品的事件,你可以看到它的模板,模板的值。所以,这避免了重复查询计划通过使用该模板。这意味着什么,是解析的编译过程,优化和翻译一个物理计划执行的方式提前发生,然后值代替。所以,如果我们一遍又一遍地做同样的处理,在火花,可能对我们有一份事先准备好的声明中?

所以,我在这里的例子中,然后在接下来的几张幻灯片,我们会在这个例子本身,看看我们如何缓存该查询计划。

对,现在很多你会喜欢,”好吧,没关系。“为什么你还想这样做吗?“什么是你面临的问题”,你想要缓存吗?“我们的数据帧像成千上万的嵌套列。打印该查询计划,对吧?当你在调试模式下,成本一个溢出而打印日志。

你不能复制粘贴。查询的时间计划,很大程度上。它完全是一个因素的列数。只是两到三秒,通常你会发现在毫秒,2 - 3秒,有时甚至5。所以,这取决于组织我们跑步,这个查询,会发疯的。所以,当你谈论,交互式查询时总不定时少10秒,30%的时间,是一个很好的工作。有这非常有趣的的谈判周期没有回答,它带领我们去在这个方向。

所以,对状态得分,我们将一个简单的数据帧。一旦我们进入下一个幻灯片。

我们将一个简单的数据帧。喜欢事件数据帧,它有一些事件的流入。我们要做的是为每一个分区,在我们所有的好的实践之前,我们已经指定。他们会做一个forEach角色在该分区,他们会做一些IO操作。所以,在这种情况下,IO操作是我们打印。它甚至会打印类型。所以它很好模拟我们的案例。

我们做的另一件事是,为了模拟相同的条件,我们在我们的代码库,我们还缓存这个事件数据,数据帧。太好了,所以我们也缓存。如果你看看这里的查询计划,您可以看到,其实做一个InMemoryTablescan, DeserializeToObject mapPartitions。好,都好,看起来很好对吧?这很好。但是,时间是1分40秒,然后查询规划阶段,周围,我说什么?8到10秒,然后领导。所以,现在接下来,我们所做的是,它可以从缓存查询非常当前的事情。我们所做的是火花,每个查询内部结构执行管道,它有这个查询执行的部分。这是物理的计划。 It doesn’t keep track of the actual… The physical plan is kind of a misnomer. It doesn’t keep track of which data set, or data frame is actually executing on. It’s more like the query plan, like okay, projection of these fields, like more schema base. It keeps track of that. So, what we did was, we hooked on to the query execution, what did I say, attribute and got the RDD out of it. So, but then that gives you an RDD of internal rules.

所以,我们抽样的缓存。当然现在你没有的,一个数据帧的事件。相反,你有一个抽样的内部的角色。但我们也预处理,去创建一个行和季度的,你会说什么?现有的模式。现在,一旦我们得到了这个,当您运行查询缓存的内部规则,我们看到的是,查询执行时间,下到60秒,花一分钟的时间,把他们所说的VC分40秒。当然,在本例中,我们使用了一个值得注意的是,更多的数量比我们将使用在一个领域,我说什么?我们实际的用例。所以你看到的差异几乎40秒,但是是的,你要点。你也可以看到的差异使生成的查询计划。

所以,这帮助我们的互动功能。现在,下一个问题是,你加入的任何查询。

连接优化的交互式查询(固执己见)

连接优化主要用于交互式查询。我将有一个非常固执己见的选择。交互式查询。处理连接,最好的办法是不要加入。

我知道很多人都只会说我说的,但是是的,试着denormalizing他们尽可能具体地说,在你需要权衡,因为如果你看看交互性,你不能阻止跳跃。但是你不能避免。试着广播连接表,如果足够小。这样你得到一个散列连接。下一件事就是如此,但有时你得到,你知道像我一样需要加入。它就像一个散列连接,但是它不是足够小。所以,很酷的一件事,你可以做的是,把它放到复述。复述,工作做得很好关于高吞吐量复述。这使得很容易替代一个广播加入。理论上,如果你看着它,你仍然得到一个广播的特点加入。

一旦这些交互查询的数据开始变得非常大。如果你加入,你将会有洗牌。你不喜欢震荡和打乱不喜欢你。所以,你很快就会发现。所以我们的连接将默认连接,除非他们所说的,成本优化器,,告诉你做其它的事情。最好的,如果你可以避免连接在一起。

下一个大事件是斜的。倾斜的数据。

最糟糕的事情之一,你可以看到活泼的方式,就像你说,“哦,你知道,”已经完成了99%的任务,一个还没有完成。“然后你觉得,“嘿屎!“这不是去工作。“那么,甚至完成了99%的工作,还是一个人没有完成,他们会失败你的任务。通常这是因为数据帧的默认分区方案,可能不是很好。一些分区可以有太多的数据。所以处理会导致像我的记忆或连接失败。

所以,re-partitioning是你最好的朋友。火花有这个需要工具来做,你知道,DF trynna重新分区,可以使用一些列和。很多你会说,“嘿,我已经知道了,这很好。“但有时这可能还不够。所以,我们要做的是,我们在上面添加一些盐。盐是什么意思,我们创建一个新的列或派生列,它给你一个独特的或均匀分布,对你想完成的目标分区数。如果你想保持相同的分区数,这还好,但是,你可以得到一个新的目标分区数,或在,然后尝试重新分区。

现在的问题是,好,很好,但是盐键听起来不错。你得到一个均匀分布,重新包装。但我怎么知道这是什么目标分区数,我指的是?

魔法targetPartitionCount怎么走吗?

一个快速技巧实际上帮助,没有我们在上面花费了大量的资源,是我们只是抽样,像一个随机抽样。一个关键方面,在我们的很多调查,是建议每个拼花分区有像一个128 mb的大小。

和这个建议做了因为它…它模仿了HDFS块大小。

所以,我们要做的就是样本的一小部分大型数据帧。(喃喃自语),然后我们估计每一行的大小,我们推断。所以,这里的样本函数,它所做的,它只是看着夹住,说5000行之类的。看它是什么尺寸,尺寸每一行。然后在此基础上,我们来看看多少,我们需要128 MB的分区。当你得到你的估计分区数,这udistic实际上非常好。

我们已经测试了一年多,和这种工作了。

如果你们有更好的。(喃喃自语)我一定会感兴趣的一个。

都放在一起!Dataframe大小:1300万条目

所以,让我们一起把这些东西,我们所讨论的,对吧?让我们开始交互式查询处理。所以,我们运行了一个测试。我们有一个数据帧。它大约有3000万项。嵌套模式有大约800字段。所以,你们都知道它会运行和查询计划问题。所以之前,你可以看到它花了23秒,这是不坏。它像周围八个分区,我们操作的。之后我们把所有的礼服,我谈到现在付诸实践,你可以看到,我们周围有大约30到子分区的分区拼花。 And with all other query practices that we put into place, you can see that it just took a mere six seconds to process. So that’s like 2.1 million records for a second. So yeah, so all of this put together definitely helped us, in achieving throughput that we wanted for the interactive case.

一件事我想触摸,除此之外,是一种常见的设计模式,试图把复述,无处不在。我有点内疚,但可悲的是,它只适合在很多地方,而且也帮助了我们。

用复述,引发非同寻常

复述,我不会走得深入每一件事,但一些不常见的用例是,你知道,你不能保持布鲁姆过滤器,和高级语言复述。但从火花写信给他们,你也可以得到互动计数而不是使用蓄电池。蓄电池有很多问题,但不使用蓄电池,可以使用流水线的复述,计数器,互动。(喃喃自语),那么另一件事是,如果你想模拟一种事件队列系统长期运行的火花工作,您还可以使用复述,将任何回点工作转化为一个交互式的位置。关键,虽然使用复述和火花,特别是复述,在火花,是流水线和批处理方面。就结束,复述,会涉及一些关于复述,流水线,因为这两种常见功能,就像在注入优化,以及交互式处理优化。

挖掘复述,流水线火花

所以,复述,流水线,没有流水线,如果要模拟一堆操作,对吧?所以客户说,“做点什么。“服务器说:“是的。“客户说,“做点什么了。”“服务器说:“是的。“所以你这个反弹。不过,管道发生的是,客户说,“嘿,ABC和D。“就推动它,所以它就像一个批处理。然后客户端读取所有的在一起,然后说,“好了,好了。“我要一起做所有这一切。“复述,这样做很好,因为在服务器端,它能够读取多个命令,同样从套接字读取命令。同时,我们将做所有的。(喃喃自语),每个操作完成。 It’s able to put all of the results on a single packet back, not a single packet, but then it’s able to write back at the same time. So, in terms of throughput with pipelining, we get a huge vendor benefit in redis. And then now when you put together, you know the whole micro batching, what they say, proposing that we saying, like try batching as much as possible. And you put the pipelining into place. They kind of make a pretty good fit.

如果你分数的一个例子,我们在这里,我们是什么,我们已经创建了这个forEach批事件流。我们首先要建立一个共同的复述,连接上,使流水线,我们要做的是,我们要设置冲洗为false。这意味着一旦命令来了,它不会被放在电线,这并不是要所有的复述。然后我们要做的是,我们要做一些当地的聚合对我们想做的操作。然后我们开始写复述之前,我们要微批。所以,我们要批量在微观批量本身。所以,我们要知道大小,比如10之类的,或任何你觉得是正确的,你的团队大小根据你的操作。一旦你有了,你可以开始注入消息。因此,所有你所做的只是不断添加消息。在这一点上,要注意的关键是,单个消息还去复述。 Once the individual batteries are done, they call an explicit flushed, and only then does the redis go there. So, this makes for a… So now all 10 commands for the set ad have gone to get them. So this way, you’re gonna see a huge jump in your throughput. I find that this niche trick actually helped a lot, with respect to our throughput increase. I would easily credit this to at least a 10 time improvement in a lot of our throughput use cases. Of course, now when you put together, you know the whole forEach patch map partitions paradigms. You could potentially, you know, the forEach that you have here, you could palatalize it even more with threads. The redis connection is set safe. So, you can try to crank a bit more juice out of it.

所以,今天我的提示和技巧。

如果你们有任何问题,随时达到到我,但就是这样。