标签: distributed-computing

我很好奇在分布式和并发环境中生成唯一序列号的约束和权衡.

想象一下:我有一个系统,它所做的就是每次提出时都会返回一个唯一的序列号.这是这种系统的理想规范(约束):

• 保持高负荷.
• 允许尽可能多的并发连接.
• 分布式:跨多台机器分散负载.
• 性能:尽可能快地运行并具有尽可能多的吞吐量.
• 正确性:生成的数字必须:
  1. 不要重复.
  2. 每个请求都是唯一的(如果任何两个请求在同一时间发生,则必须有一种断开关系的方式).
  3. (增加)顺序.
  4. 请求之间没有差距:1,2,3,4 ......(实际上是一个总#请求的计数器)
• 容错:如果一台或多台机器或所有机器发生故障,它可以恢复到故障前的状态.

显然,这是一个理想化的规范,并非所有约束都可以完全满足.参见CAP定理.但是,我很想听听您对各种限制因素的分析.我们将留下什么类型的问题以及我们将使用什么算法来解决剩余的问题.例如,如果我们摆脱了计数器约束,那么问题就变得容易了:因为允许间隙,我们可以对数值范围进行分区并将它们映射到不同的机器上.

欢迎任何参考(论文,书籍,代码).我还想保留一份现有软件清单(开源与否).

软件:

• Snowflake:一种网络服务,可以通过一些简单的保证在大规模生成唯一的ID号.
• keyspace:一个可公开访问的唯一128位ID生成器,其ID可用于任何目的
• RFC-4122实现存在于许多语言中.RFC规范可能是一个非常好的基础,因为它可以防止任何系统间协调,UUID是128位,并且当使用来自实现某些版本规范的软件的ID时,它们包含一个时间代码部分,可能的分类等

我正在开始我的最后一年计算机科学项目,我正在努力弄清楚我的第一步.有关更多详细信息,您可以转到项目页面.

背景:因为我在分布式系统方面经验很少,所以基本上我应该如何面对这样的挑战.我想出的是系统应该如下工作:

客户端发送一个文件或一组包含要处理的代码的文件.该代码将实现由我编写的分布式算法接口,即特定类.服务器将从类中创建一个对象.该对象将负责运行算法.服务器将结果返回给客户端.(我实际上后来读到了RMI并发现它非常相似).

发送文件是基本的 - 常见的网络I/O. 真正的问题是对象创建并在运行时将其用作预定义接口.

问题:

1. 我提出的挑战听起来像是一个反思挑战,这是正确的吗？
2. 您有关于如何实施它的任何第一个提示吗？

寻找一些分布式系统java技术我遇到过RMI,TRMI,LINDA,CORBA,JINI等等.RMI听起来最吸引人,因为它与我收集的解决方案非常相似,但它也很老.

1. 您认为哪些库可以帮助我完成这项任务？请记住,我是一名计算机科学专业的学生,​​因此开箱即用的解决方案不会与我的教授保持一致.
2. RMI已经老了,还有更好的解决方案吗？
3. 关于TRMI的任何综合教程？

如果你发现我的逻辑有些错误,请纠正它.

如果您有关于该主题的更多提示,您认为应该讨论,请随时与我联系.

我正在寻找一个在C++分布式数字运算应用程序中使用的框架.

设置如下:

有一个主节点将问题域划分为小的独立任务.任务分配给具有不同功能的工作节点(例如,CPU类型/ GPU启用).工作节点在可用时动态添加到计算网格中.也可能发生工作节点死亡,而没有说再见.

我正在寻找一个快速的C/C++框架来完成这个设置.

总结一下,我的主要要求是:

• 工人/任务调度范例
• 动态添加/删除节点
• 目标网络:1G - 10G以太网(企业网络,不需要互联网的良好性能)
• 可选:加密和验证通信

我们需要建立一个系统,其中多个进程在同一个数据集上工作.我们的想法是拥有一组可以被我们的工作进程(异步)拉出的元素(即没有重复的值).这些进程可能分布在多个服务器上,因此我们需要一个分布式解决方案.

目前,我们正在考虑的模式是使用Redis来保存一个包含工作数据的集合.每个进程都应连接到该集,并从中弹出一个值.随机功能spop对我们来说实际上是一个加分,因为我们需要随机访问集合中的元素.必须从我们的主PostgreSQL数据库填充数据.

就像我说的,我们还有一个可供查询的PostgreSQL数据库,进程在请求元素时可以访问.但是,我们不知道是否在重载下可能成为瓶颈.我们确实希望在这个子系统上进行繁重的 - 非常繁重的并发访问(想想数百甚至数千个进程).

如果它与此有任何关联,我们使用Python rQ来处理异步任务(作业和工作者).

编辑:就大小而言,元素可能不会很大 - 顶部大小应该在500-1000字节左右.它们基本上是URL,所以除非发生奇怪的事情,否则它们应该远低于这个大小.元素的数量将取决于并发进程的数量,因此大约10-50 K元素可能是一个很好的球场.请记住,这更像是一个临时区域,因此重点应放在速度上而不是尺寸上.

总之,我的问题是:

1. 在使用多个进程时,Redis是否为共享访问设置了一个好主意？是否有任何数据可以让我们知道该解决方案将如何扩展？如果是这样,你能提供任何指示或建议吗？

2. 填充共享数据时,什么是一个好的更新策略？

非常感谢你!

在阅读zeromq指南时,我遇到了客户端代码,它在循环中发送100k请求,然后在第二个循环中接收回复.

#include "../include/mdp.h"
#include <time.h>


int main (int argc, char *argv [])
{
    int verbose = (argc > 1 && streq (argv [1], "-v"));
    mdp_client_t *session = mdp_client_new ("tcp://localhost:5555", verbose);
    int count;
    for (count = 0; count < 100000; count++) {
        zmsg_t *request = zmsg_new ();
        zmsg_pushstr (request, "Hello world");
        mdp_client_send (session, "echo", &request);
    }
    printf("sent all\n");

    for (count = 0; count < 100000; count++) {
        zmsg_t *reply = mdp_client_recv (session,NULL,NULL);
        if (reply)
            zmsg_destroy (&reply);
        else
            break;              //  Interrupted by …

TLDR; 在消费者即时创建的主题交换和队列的上下文中,当没有消费者消费该消息时,如何重新传递消息/生产者被通知？

我有以下组件:

• 主要服务,生成文件.每个文件都有一定的类别(例如pictures.profile,pictures.gallery)
• 一组工人,使用文件并从中生成文本输出(例如文件的大小)

我目前只有一个RabbitMQ主题交换.

• 制作人向交易所发送消息routing_key = file_category.
• 每个消费者创建一个队列并将交换绑定到该队列以获得一组路由键(例如图片.*和videos.trending).
• 当使用者处理了文件时,它会将结果推送到processing_results队列中.

现在 - 这个工作正常,但它仍然有一个重大问题.目前,如果发布者发送的消息带有没有绑定使用者的路由密钥,则该消息将丢失.这是因为即使消费者创建的队列是持久的,一旦消费者断开连接,它就会被销毁,因为它对这个消费者是唯一的.

消费者代码(python):

channel.exchange_declare(exchange=exchange_name, type='topic', durable=True)
result = channel.queue_declare(exclusive = True, durable=True)
queue_name = result.method.queue

topics = [ "pictures.*", "videos.trending" ]
for topic in topics:
    channel.queue_bind(exchange=exchange_name, queue=queue_name, routing_key=topic)

channel.basic_consume(my_handler, queue=queue_name)
channel.start_consuming()

在我的用例中,在这种情况下丢失消息是不可接受的.

试图解决方案

但是,如果通知生产者没有消费者收到消息(在这种情况下它可以稍后重新发送),则"丢失"消息变得可以接受.我发现强制性字段可能有所帮助,因为AMQP的规范规定:

如果消息无法路由到队列,此标志告诉服务器如何做出反应.如果设置了此标志,则服务器将返回带有Return方法的unroutable消息.

这确实有效 - 在制片人中,我能够注册ReturnListener:

rabbitMq.confirmSelect();  

rabbitMq.addReturnListener( (int replyCode, String replyText, String exchange, String routingKey, …

我有一个带有10个微服务的微服务架构,每个微服务都提供一个客户端.在由microService团队管理/控制的客户端内部,我们只接收参数并将它们传递给通用的http调用程序,它接收端点和N个参数,然后进行调用.所有的microService都使用http和web api(我猜技术并不重要).

对于我而言,成为微服务团队提供客户端没有意义,应该是消费者的责任,如果他们想要创建一些抽象或直接调用它是他们的问题,而不是微服务问题.我看到Web API的方式就是合同.所以我认为我们应该在microService端删除所有客户端(将责任传递给消费者),并在消费者一侧创建一个使用通用调用者到达端点的服务层.

下图显示了红线定义边界的所有组件,谁负责:

• 网关有适配器层
• 适配器层引用microService客户端包
• MicroService客户端包引用通用HTTP调用程序包

另一方面是因为我们可能有N个消费者,他们都在重复客户端的代码.如果microService提供了一个客户端,我们就有一个独特的/集中的位置来控制它.

哪种方法是正确的？客户是微服务还是消费者的责任？

这是一个内部产品.

山姆·纽曼（Sam Newman）在他的《建筑微服务》一书中指出