如果 Slave 关闭，Django 多个数据库回退到 Master

Question

我为 Django 的 MySQL 数据库后端设置了主从复制设置。 目前我只为 Master DB 读写，但我的仪表板是查询密集型的。 我正在寻找一个选项，我可以在其中定义如下 数据库

DATABASES = {
'default_slave': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '3306',
    },
'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  

对于仪表板、报告和各种其他应用程序，我想做的是：

尝试连接：default_slave：如果可以访问，则使用default_slave，否则使用default

也就是说，如果slave启动了，就从slave数据库自己获取reports，如果没有从master数据库获取reports。

Catch 是，slave 可以启动或关闭，我希望它可以根据可重复性动态选择用于获取报告的数据库。

这可能吗？我可以事先测试连接并继续前进吗？

有了这个，我将在 Master 中写入和 sync_db，如果 slave 启动，则始终从 Slave 读取。

需要raw queries 和orm queries 的一些解决方案/提示

路由器的概念看起来不错，但是备用从机无法访问，我不知道这种可能性。

更新

如何处理多数据库

数据库

DATABASES = {
'default_slave': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '3306',
    },
'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'linux': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'linux_slave': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'mac': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'mac_slave': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'pc': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  
'pc_slave': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'PASSWORD': '',
        'HOST': '', 
        'PORT': '3306',
    },
}  

现在，我有 1. 静态数据 2.动态数据

静态数据必须存储在 'default' 中，这将被复制到 'default_slave'

对于动态数据，查询首先需要判断动态数据可能在哪里：在'mac'或'pc'或'linux'中

为了实现这一点，我在“静态表”中添加了一个字段：“query_on”，其中包含 ['mac' or 'linux' or 'pc']

现在，使用查询集，我只是在写 static = Static.objects.get(pk = 1)
query_on = static.query_on dynamic = Dynamic.objects.get(static = static).using(alias=query_on)

这很好，查询路由到它需要执行的数据库，这里我需要判断：

1. 如果<'query_on'>_slave：连接已启动：使用：<'query_on'>_slave 或
2. 如果<'query_on'>_slave：连接断开：使用：<'query_on'>

该怎么做呢？

申请的更多详情：

1. 有一个数据库：默认（配置和分析数据库）：用于维护配置数据和报告分析数据
2. 有 20 个数据库（原始数据库）：如示例所示：mac、linux、rhel、windows、pc ....（示例名称）：用于收集原始数据，而不是用于分析的过程
3. 每个数据库都有一个或多个从属数据库，命名约定为：default_slave_0、default_slave_1、default_slave_2 等其他数据库也是如此

现在需要每 5 分钟、30 分钟、1 小时...首先查询分析数据，并且该查询需要发送到特定数据库，因为并非每个数据库都会携带分析所需的特定数据集。

为此，我们需要

1. 从（默认或其任何一个从属设备（从属部分是问题））获取配置数据
2. 完成配置后，我们可以轻松查看“原始”数据的位置
3. 查询原始数据，收集结果并分析 --> 将其存储在“默认”数据库中。

现在所有 30 个（原始）和 1 个默认数据库都需要“同步”，因为我们在所有节点中都保持相同的数据结构。

现在，由于我们正在查看所有数据库的 CPU 峰值，因此使用“从属”数据库来查询“原始”数据是有意义的。

因此需要 using 。我无法想象路由器在这里会有什么帮助？

Answer 1

您在使用路由器方面走在了正确的轨道上。我假设您的两个数据库定义相同的事实只是一个错字。

（仅供参考，我将使用the more sensitive master->follower 引用数据库层次结构）

在您的 db_for_read() 函数中，您可以检查与您的追随者的连接。这可能会产生更多开销，但这是为数据库设置自动故障转移的成本。一个示例数据库定义是：

DATABASES = {
'follower': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'follower',
        'USER': 'root',
        'HOST': '54.34.65.24',
        'PORT': '3306',
    },
'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'application',
        'USER': 'root',
        'HOST': '54.34.65.23',
        'PORT': '3306',
    },
}  

您可以通过快速尝试/除了this example 来测试连接。使用它的路由器可以满足您的需要：

from django.conf import settings
import socket


def test_connection_to_db(database_name):
    try:
        db_definition = getattr(settings, 'DATABASES')[database_name]
        s = socket.create_connection((db_definition['HOST'], db_definition['PORT']), 5)
        s.close()
        return True
    except (AttributeError, socket.timeout) as e:
        return False


class FailoverRouter(object):
    """A router that defaults reads to the follower but provides a failover back to the default"""

    def db_for_read(self, model, **hints):
        if test_connection_to_db('follower'):
            return 'follower'
        return 'default'

    def db_for_write(self, model, **hints):
        "Point all writes to the default db"
        return 'default'

    def allow_syncdb(self, db, model):
        "Make sure only the default db allows syncdb"
        return db == 'default'

这仍然会像你想要的那样在 master 中同步数据库。此外，您可以使 db_for_read() 和 db_for_write() 的逻辑更加复杂（例如，仅为查询报告的特定模型选择关注者数据库。

我不知道这个test_connection() 会为每次读取带来什么开销，因为这取决于 MySQL 服务器和超时。或许更好的架构是使用 memcached 缓存这些报告，或者只是解决从属服务器宕机的问题并首先在设置中更新您的数据库定义。