面向高频率数据访问的微服务架构；在内存解决方案中？
Microservices Architecture for highly frequent data access; in memory solutions?
让我们定义以下用例：
- 必须完成一项模拟任务，其中涉及 [day1, day2, ..., dayN] 的 iteration/simulation。迭代的每一步都取决于前一步，因此顺序是预定义的。
- 该任务有一个由 Object1 表示的状态，该对象将在迭代的每个步骤中更改。
- 迭代的步骤涉及 2 个不同的任务：Task1 和 Task2。
- 要完成 Task1，需要来自 Database1 的数据。
- 要完成 Task2，还需要来自不同数据库的外部数据，即 Database2。
- Task1完成后，需要应用Task2。
- Task1 以及 Task2 需要访问 Object1
- 两个任务完成后，Object1的状态发生变化，一个迭代步骤完成。
此 iteration/simulation 任务平均涉及 10,000 次迭代 步。平均 100 iteration/simulation 个任务需要 同时 执行，由多个最终用户启动。
现在我们讨论微服务架构来解决这个问题，因为生产中的应用程序需要可扩展性。同样出于开发目的，这也是至关重要的，因为 Task1 和 Task2 最近添加了新的 features/parameters 和 在开发中规模不同.
So, to avoid the network bottleneck here, involving the constant
database access in every iteration and also the send data between
Task1 and Task2, what would be an appropriate system architecture to
this problem?
Should there be at least two different services for Task1 and
Task2 and maybe even one for the actual iteration/simulation state
control? Can someone maybe tell us a little bit more about the use of
an in memory data grid solution like hazlecast or only in-memory
database like redis for this problem?
The main question here is what are the arguments for a microservice
architecture due to probably communication/network bottleneck? The
only way to speed this up is to spawn all needed data for the
simulation task in memory and keep it there the whole time, to avoid
the network bottleneck?
感谢您的回答和宝贵意见。
（此问题与服务间通信无关，如消息传递或 REST http（pub/sub 或 req/resp），两者都可能为此任务应用高网络负载。）
Now we discuss a microservice architecture for the problem, due to the needed scalability of the application in production. Also for development purpose this is crucial, because Task1 and Task2 are recently added new features/parameters and scale differently in development.
这正是流处理平台的优势所在。我建议使用像 Apache Kafka or Apache Pulsar 这样的系统来解决这个问题。
Should there be at least two different services for Task1 and Task2 and maybe even one for the actual iteration/simulation state control?
Task1 和 Task2 就是所谓的流处理器，他们阅读（订阅）一个主题，做一些operations/transformations 并写（发布）到 另一个主题。
The main question here is what are the arguments for a microservice architecture due to probably communication/network bottleneck? The only way to speed this up is to spawn all needed data for the simulation task in memory and keep it there the whole time, to avoid the network bottleneck?
同样，这正是像 Apache Kafka 或 Apache Pulsar 这样的系统做得很好的问题。要在流处理系统中 scale 写入和读取，您可以 partition 您的 topics.
使用 Hazelcast，您可以两全其美 - 数据存储（Hazelcast 集群中的缓存）和 compute/processing。在同一个 Hazelcast 集群中，您可以使用 Hazelcast 数据结构创建缓存并使用数据库中的数据加载它们（预加载预热或按需加载缓存中的数据）。然后使用 Hazelcast Jet API 在集群中执行任务。这样，您的任务将可以访问之前加载到集群中的数据，并且优势在于 - 数据位于离您的任务最近的可能位置，因此任务执行的延迟极低。
Jet 的另一个好处 - 由于 Jet 是一个 DAG 实现，您可以按照您喜欢的方向将多个任务相互连接起来。例如，Task1 可以输入到 Task2，Task2 可以输入到 Task3，Task3 可以同时输入到 Task1 和 2，等等。这使您可以完全控制可能需要在不同阶段执行多个任务的完整作业执行。 Jet 提供任务的流处理和批处理，在设计和执行作业时具有相同的灵活性。
如果在 Kafka 生态系统之外使用，您可能会发现使用 Kafka 执行任务有问题。 Jet 非常灵活，可以连接到任何 source/sink，包括 Kafka。
让我们定义以下用例：
- 必须完成一项模拟任务，其中涉及 [day1, day2, ..., dayN] 的 iteration/simulation。迭代的每一步都取决于前一步，因此顺序是预定义的。
- 该任务有一个由 Object1 表示的状态，该对象将在迭代的每个步骤中更改。
- 迭代的步骤涉及 2 个不同的任务：Task1 和 Task2。
- 要完成 Task1，需要来自 Database1 的数据。
- 要完成 Task2，还需要来自不同数据库的外部数据，即 Database2。
- Task1完成后，需要应用Task2。
- Task1 以及 Task2 需要访问 Object1
- 两个任务完成后，Object1的状态发生变化，一个迭代步骤完成。
此 iteration/simulation 任务平均涉及 10,000 次迭代 步。平均 100 iteration/simulation 个任务需要 同时 执行，由多个最终用户启动。
现在我们讨论微服务架构来解决这个问题，因为生产中的应用程序需要可扩展性。同样出于开发目的，这也是至关重要的，因为 Task1 和 Task2 最近添加了新的 features/parameters 和 在开发中规模不同.
So, to avoid the network bottleneck here, involving the constant database access in every iteration and also the send data between Task1 and Task2, what would be an appropriate system architecture to this problem?
Should there be at least two different services for Task1 and Task2 and maybe even one for the actual iteration/simulation state control? Can someone maybe tell us a little bit more about the use of an in memory data grid solution like hazlecast or only in-memory database like redis for this problem?
The main question here is what are the arguments for a microservice architecture due to probably communication/network bottleneck? The only way to speed this up is to spawn all needed data for the simulation task in memory and keep it there the whole time, to avoid the network bottleneck?
感谢您的回答和宝贵意见。
（此问题与服务间通信无关，如消息传递或 REST http（pub/sub 或 req/resp），两者都可能为此任务应用高网络负载。）
Now we discuss a microservice architecture for the problem, due to the needed scalability of the application in production. Also for development purpose this is crucial, because Task1 and Task2 are recently added new features/parameters and scale differently in development.
这正是流处理平台的优势所在。我建议使用像 Apache Kafka or Apache Pulsar 这样的系统来解决这个问题。
Should there be at least two different services for Task1 and Task2 and maybe even one for the actual iteration/simulation state control?
Task1 和 Task2 就是所谓的流处理器，他们阅读（订阅）一个主题，做一些operations/transformations 并写（发布）到 另一个主题。
The main question here is what are the arguments for a microservice architecture due to probably communication/network bottleneck? The only way to speed this up is to spawn all needed data for the simulation task in memory and keep it there the whole time, to avoid the network bottleneck?
同样，这正是像 Apache Kafka 或 Apache Pulsar 这样的系统做得很好的问题。要在流处理系统中 scale 写入和读取，您可以 partition 您的 topics.
使用 Hazelcast，您可以两全其美 - 数据存储（Hazelcast 集群中的缓存）和 compute/processing。在同一个 Hazelcast 集群中，您可以使用 Hazelcast 数据结构创建缓存并使用数据库中的数据加载它们（预加载预热或按需加载缓存中的数据）。然后使用 Hazelcast Jet API 在集群中执行任务。这样，您的任务将可以访问之前加载到集群中的数据，并且优势在于 - 数据位于离您的任务最近的可能位置，因此任务执行的延迟极低。
Jet 的另一个好处 - 由于 Jet 是一个 DAG 实现，您可以按照您喜欢的方向将多个任务相互连接起来。例如，Task1 可以输入到 Task2，Task2 可以输入到 Task3，Task3 可以同时输入到 Task1 和 2，等等。这使您可以完全控制可能需要在不同阶段执行多个任务的完整作业执行。 Jet 提供任务的流处理和批处理，在设计和执行作业时具有相同的灵活性。
如果在 Kafka 生态系统之外使用，您可能会发现使用 Kafka 执行任务有问题。 Jet 非常灵活，可以连接到任何 source/sink，包括 Kafka。