一.配置示例
1.1. 基本配置示例
1.1.1. 开始
首先，我们必须学习如何在使用复制之前安装和配置 Pgpool-II 和数据库节点。
1.1.1.1. 安装 Pgpool-II
安装 Pgpool-II 非常简单。 在已解压源 tar ball 的目录中， 执行以下命令。
$ ./configure
$ make
$ make install
configure script 收集您的系统信息 并将其用于编译过程。您可以传递命令 line 参数来配置脚本以更改默认行为， 例如安装目录。默认情况下，pgpool-II 将安装到 /usr/local 目录下。
make 命令编译源代码，make install 将安装可执行文件。 您必须对安装目录具有写入权限。 在本教程中，我们将把 Pgpool-II 安装在默认的 /usr/local 目录下。
注意： Pgpool-II 需要 PostgreSQL 7.4 或更高版本的 libpq 库（版本 3 协议）。
如果 configure 脚本显示以下错误消息，则 libpq 库可能未安装，或者它不是版本 3
configure: error: libpq is not installed or libpq is old
如果库是版本 3，但仍显示上述消息，则 configure 脚本可能无法识别您的 libpq 库。 configure 脚本在 /usr/local/pgsql 下搜索 libpq 库。如果您将 PostgreSQL 安装在 /usr/local/pgsql 以外的目录中，请在使用 --with-pgsql 或 --with-pgsql-includedir 和 --with-pgsql-libdir 命令行选项时 执行 configure。
1.1.1.2. 配置文件
Pgpool-II 的配置参数保存在 pgpool.conf 文件中。该文件每行格式为 “parameter = value”。 当你安装 Pgpool-II 时，pgpool.conf.sample 会自动创建。 我们建议将其复制并重命名为 pgpool.conf，然后编辑 随你所欲。
$ cp /usr/local/etc/pgpool.conf.sample /usr/local/etc/pgpool.conf
Pgpool-II 只接受来自 localhost 的连接 默认使用端口 9999。如果您希望接收来自其他主机的连接， 将 listen_addresses 设置为 ‘*’。
listen_addresses = 'localhost'
port = 9999
在本教程中，我们将使用默认参数。
1.1.1.3. 配置 PCP 命令
Pgpool-II 有一个用于管理接口的 用于检索数据库节点信息、通过网络关闭 Pgpool-II 等。要使用 PCP 命令，需要用户身份验证。 此身份验证与 PostgreSQL 的用户身份验证不同。 需要在 pcp.conf 文件中定义用户名和密码。在文件中，用户名和密码在每行中成对列出。 它们用冒号 （😃.密码以 md5 哈希格式加密。
postgres:e1a41653151e21c69d0506501fb27fc5
当你安装 Pgpool-II 时，pcp.conf.sample 会自动创建。我们建议复制并重命名它 添加到 pcp.conf 中，然后对其进行编辑。
$ cp /usr/local/etc/pcp.conf.sample /usr/local/etc/pcp.conf
要将你的密码加密成 md5 哈希格式，请使用 pg_md5 命令，它作为 Pgpool-II 的 可执行文件。pg_md5 将文本作为命令行参数， 并显示其 MD5 哈希文本。 例如，将 “postgres” 作为命令行参数， pg_md5 在其标准输出上显示 MD5 哈希文本。
$ /usr/local/bin/pg_md5 postgres
e1a41653151e21c69d0506501fb27fc5
PCP 命令通过网络执行，因此必须配置端口号 在 pgpool.conf 文件中pcp_port参数。 在本教程中，我们将使用默认的 9898 作为 pcp_port。
pcp_port = 9898
1.1.1.4. 准备数据库节点
现在，我们需要为 Pgpool-II 设置后端 PostgreSQL 服务器。这些服务器可以放置在与 Pgpool-II 相同的主机中，或者放在不同的机器上。如果您决定 要将服务器放置在同一主机上，必须分配不同的端口号 对于每个服务器。如果服务器放置在不同的计算机上， 必须正确配置它们，以便它们可以接受网络 来自 Pgpool-II 的连接。 在此示例中，我们创建 3 个 PostgreSQL 服务器，并且 在以下参数中指定 PostgreSQL 信息。
backend_hostname0 = 'localhost'
backend_port0 = 5432
backend_weight0 = 1
backend_hostname1 = 'localhost'
backend_port1 = 5433
backend_weight1 = 1
backend_hostname2 = 'localhost'
backend_port2 = 5434
backend_weight2 = 1
对于 backend_hostname、backend_port backend_weight，设置节点的主机名、端口号、 和 ratio 进行负载平衡。在每个参数字符串的末尾， 节点 ID 必须通过添加从 0 开始的正整数（即 0、1、2…）来指定。
注意：所有节点的 backend_weight 参数均为 设置为 1，这意味着 SELECT 查询在 三个服务器。
1.1.1.5. 启动/停止 pgpool-II
要启动 Pgpool-II，请执行以下命令 命令。
$ pgpool
然而，上面的命令没有打印日志消息，因为 Pgpool-II 分离了终端。如果你想显示 Pgpool-II 的日志信息，你可以将 -n 选项传递给 pgpool 命令，这样 Pgpool-II 就会作为非守护进程执行，并且终端不会被分离。
$ pgpool -n &
日志消息打印在终端上，因此建议使用以下选项。
$ pgpool -n -d > /tmp/pgpool.log 2>&1 &
-d 选项允许生成调试消息。 上述命令不断将日志消息附加到 /tmp/pgpool.log 。如果需要轮换日志文件，请将日志传递给外部 命令，该命令具有对数轮换功能。 例如，您可以使用 Apache2 中的 rotatelogs：
$ pgpool -n 2>&1 | /usr/local/apache2/bin/rotatelogs \
-l -f /var/log/pgpool/pgpool.log.%A 86400 &
这将生成一个名为 “pgpool.log.Thursday” 的日志文件，然后在午夜 00：00 旋转它。如果文件已经 存在。要在轮换之前删除旧的日志文件，您可以使用 cron：
55 23 * * * /usr/bin/find /var/log/pgpool -type f -mtime +5 -exec /bin/rm -f '{}' \;
请注意，在某些发行版中，rotatelogs 可能以 /usr/sbin/rotatelogs2 的形式存在。-f 选项会在 rotatelogs 启动后立即生成日志文件，并在 apache2 2.2.9 或更高版本中可用。 也可以使用 cronolog。
$ pgpool -n 2>&1 | /usr/sbin/cronolog \
--hardlink=/var/log/pgsql/pgpool.log \
'/var/log/pgsql/%Y-%m-%d-pgpool.log' &
要停止 Pgpool-II，请执行以下命令。
$ pgpool stop
如果任何客户端仍然连接，Pgpool-II 等待它断开连接，然后终止自身。运行以下命令 命令来代替，如果你想强制关闭 Pgpool-II。
$ pgpool -m fast stop
1.1.2. 您的第一次复制
复制（请参阅本机复制模式）启用 要复制到多个数据库节点的相同数据。 在本节中，我们将使用我们已经设置的三个数据库节点 up 在 Section 1.1.1 中，并带你一步一步地进入 创建数据库复制系统。 要复制的示例数据将由 pgbench 基准测试程序生成。
1.1.2.1. 配置复制
要启用数据库复制功能，请在 pgpool.conf 文件中将本地复制模式设置为 on。
replication_mode = true
当本地复制模式开启时，Pgpool-II 会将接收到的查询的副本发送到所有数据库节点。 此外，当 load_balance_mode 设置为 true 时，Pgpool-II 将分发 SELECT 查询 在数据库节点之间。
load_balance_mode = true
在本节中，我们将启用本机复制模式和 load_balance_mode。
1.1.2.2. 检查复制
为了在 pgpool.conf 中反映上述更改，必须重新启动 Pgpool-II。 请参考 “启动/停止 pgpool-II” 第 1.1.1.5 节。 在配置 pgpool.conf 并重启 Pgpool-II 之后，让我们尝试实际的复制 并查看是否一切正常。 首先，我们需要创建一个要复制的数据库。我们将其命名为 “bench_replication”。需要创建此数据库 在所有节点上。通过 Pgpool-II 使用 createdb 命令，数据库将被创建 在所有节点上。
$ createdb -p 9999 bench_replication
然后，我们将使用 -i 选项执行 pgbench。-i 选项使用预定义的表和数据初始化数据库。
$ pgbench -i -p 9999 bench_replication
下表是表和数据的摘要，它们将由 pgbench -i 创建。如果在所有节点上，列出的表和 数据，复制工作正常。
表 1-1.数据汇总
| 表名称 | 行数 |
|---|---|
| pgbench_branches | 1 |
| pgbench_tellers | 10 |
| pgbench_accounts | 100000 |
| pgbench_history | 0 |
| 让我们使用一个简单的 shell 脚本来检查所有节点上的上述内容。 以下脚本将显示 pgbench_branches 中的行数， 所有节点上的 pgbench_tellers、pgbench_accounts 和 pgbench_history 表（5432、5433、5434）。 |
$ for port in 5432 5433 5434; do
> echo $port
> for table_name in pgbench_branches pgbench_tellers pgbench_accounts pgbench_history; do
> echo $table_name
> psql -c "SELECT count(*) FROM $table_name" -p $port bench_replication
> done
> done
1.2. pgpool-II + 看门狗设置示例
本节展示了一个使用 Pgpool-II 的流式复制配置示例。在这个例子中，我们使用 3 个 Pgpool-II 服务器来管理 PostgreSQL 服务器，以创建一个健壮的集群系统，避免单点故障或裂脑。
此配置示例中使用 PostgreSQL 16。 所有脚本均已使用 PostgreSQL 10 及更高版本进行了测试。
1.2.1. 要求
我们假设所有的 Pgpool-II 服务器和 PostgreSQL 服务器都在同一个子网中。
1.2.2. 集群系统配置
我们使用三台安装了 Rocky Linux 8 的服务器，并且 这三个服务器的主机名分别为 server1、server2 和 server3。 我们在每台服务器上安装 PostgreSQL 和 Pgpool-II。
注意： Leader、Standby、Primary、Standby 的角色不是固定的，可能会通过进一步的操作来改变。
表 1-2.主机名和 IP 地址
| Hostname | IP Address | Virtual IP |
|---|---|---|
| server1 | 192.168.100.51 | 192.168.100.50 |
| server2 | 192.168.100.52 | |
| server3 | 192.168.100.53 | |
| 表 1-3.PostgreSQL 版本和配置 |
| Item | Value | Detail |
|---|---|---|
| PostgreSQL Version | 16.0 | - |
| port | 5432 | - |
| $PGDATA | /var/lib/pgsql/16/data | - |
| Archive mode | on | /var/lib/pgsql/archivedir |
| Replication Slots | Enabled | In this configuration example, replication slots are automatically created or deleted in the scripts which are executed during failover or online recovery. These scripts use the hostname specified in backend_hostnameX as the replication slot name. |
| Async/Sync Replication | Async | - |
| 表 1-4.Pgpool-II 版本和配置 |
| Item | Value | Detail |
|---|---|---|
| Pgpool-II Version | 4.5.0 | - |
| port | 9999 | Pgpool-II accepts connections |
| 9898 | PCP process accepts connections | |
| 9000 | watchdog accepts connections | |
| 9694 | UDP port for receiving Watchdog’s heartbeat signal | |
| Config file | /etc/pgpool-II/pgpool.conf | Pgpool-II config file |
| User running Pgpool-II | postgres (Pgpool-II 4.1 or later) | Pgpool-II 4.0 or before, the default user running Pgpool-II is root |
| Running mode | streaming replication mode | - |
| Watchdog | on | Life check method: heartbeat |
Table 1-5. Various sample scripts included in rpm package
表 1-5.rpm 包中包含的各种示例脚本
| 特征 | 脚本 | 细节 |
|---|---|---|
| 故障转移 | /etc/pgpool-II/sample_scripts/failover.sh.sample | 由 failover_command 运行以执行故障转移 |
| /etc/pgpool-II/sample_scripts/follow_primary.sh.sample | 由 follow_primary_command 运行，以在故障转移后将备用数据库与新的主数据库同步 | |
| 在线恢复 | /etc/pgpool-II/sample_scripts/recovery_1st_stage.sample | Run by recovery_1st_stage_command 以恢复备用节点 |
| /etc/pgpool-II/sample_scripts/pgpool_remote_start.sample | Run after recovery_1st_stage_command 以启动 Standby 节点 | |
| 看门狗 | /etc/pgpool-II/sample_scripts/escalation.sh.sample | 可选配置。由 wd_escalation_command 运行以安全地切换 Leader/Standby Pgpool-II |
上述脚本包含在 RPM 包中，可以根据需要进行自定义。
1.2.3. 安装
在此示例中，我们使用 YUM 安装 Pgpool-II 和 PostgreSQL RPM 包。
从 PostgreSQL YUM 存储库安装 PostgreSQL。
[all servers]# dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-8-x86_64/pgdg-redhat-repo-latest.noarch.rpm
[all servers]# dnf -qy module disable postgresql
[all servers]# dnf install -y postgresql16-server
由于 Pgpool-II 相关的包也包含在 PostgreSQL YUM 仓库中， 将 “exclude” 设置添加到 /etc/yum.repos.d/pgdg-redhat-all.repo 中，这样 Pgpool-II 就不会从 PostgreSQL YUM 仓库安装。
[all servers]# vi /etc/yum.repos.d/pgdg-redhat-all.repo
以下是 /etc/yum.repos.d/pgdg-redhat-all.repo 的设置示例。
[pgdg-common]
...
exclude=pgpool*
[pgdg16]
...
exclude=pgpool*
[pgdg15]
...
exclude=pgpool*
[pgdg14]
...
exclude=pgpool*
[pgdg13]
...
exclude=pgpool*
[pgdg12]
...
exclude=pgpool*
[pgdg11]
...
exclude=pgpool*
从 Pgpool-II YUM 仓库安装 Pgpool-II。
[all servers]# dnf install -y https://www.pgpool.net/yum/rpms/4.5/redhat/rhel-8-x86_64/pgpool-II-release-4.5-1.noarch.rpm
[all servers]# dnf install -y pgpool-II-pg16-*
1.2.4. 开始之前
在开始配置过程之前，请检查以下先决条件。
1.2.4.1. 在 Primary 上设置流复制
在主服务器上设置 PostgreSQL 流复制。 在此示例中，我们使用 WAL 存档。
首先，我们创建目录 /var/lib/pgsql/archivedir 以在所有服务器上存储 WAL 段。在此示例中，只有主节点在本地存档 WAL。
[all servers]# su - postgres
[all servers]$ mkdir /var/lib/pgsql/archivedir
在主服务器上初始化 PostgreSQL。
[server1]# su - postgres
[server1]$ /usr/pgsql-16/bin/initdb -D $PGDATA
然后我们在 server1（主）上编辑配置文件 $PGDATA/postgresql.conf，如下所示。启用 wal_log_hints 以使用 pg_rewind。 由于 Primary 稍后可能会成为 Standby ，因此我们将 hot_standby = on。
listen_addresses = '*'
archive_mode = on
archive_command = 'cp "%p" "/var/lib/pgsql/archivedir/%f"'
max_wal_senders = 10
max_replication_slots = 10
wal_level = replica
hot_standby = on
wal_log_hints = on
在 server1 上启动 PostgreSQL 主服务器。
[server1]# su - postgres
[server1]$ /usr/pgsql-16/bin/pg_ctl start -D $PGDATA
1.2.4.2. 在 Standby 上设置 Streaming Replication
有多种方法可以设置备用服务器，例如：
使用 pg_basebackup 从备用数据库备份主数据库的数据目录。
使用 Pgpool-II 的在线恢复功能 （第 5.11 节）自动 设置备用服务器。
在这个例子中，我们使用 Pgpool-II 的 在线恢复以设置备用服务器 在 Section 1.2.1.2 中，在 Pgpool-II 的配置完成后。
1.2.4.3. 设置 PostgreSQL 用户
PostgreSQL 用户需要使用 Pgpool-II 的 运行状况检查和复制延迟检查功能。 出于安全原因，我们创建了一个名为 pgpool 的专用用户，用于流复制延迟检查和 运行状况检查。 并创建一个名为 repl 的专用用户进行复制。 由于在线恢复功能需要超级用户权限，因此 我们在这里使用 postgres user。
从 Pgpool-II 4.0 开始，支持 scram-sha-256 身份验证。 此配置示例使用 scram-sha-256 身份验证方法。 首先，设置 password_encryption = ‘scram-sha-256’，然后创建用户。
表 1-6.用户
用户名 密码 细节
举报 举报 PostgreSQL 复制用户
pgpool pgpool Pgpool-II 健康检查 （health_check_user） 和复制延迟检查 （sr_check_user） 用户
postgres postgres 运行联机恢复的用户
[server1]# psql -U postgres -p 5432
postgres=# SET password_encryption = 'scram-sha-256';
postgres=# CREATE ROLE pgpool WITH LOGIN;
postgres=# CREATE ROLE repl WITH REPLICATION LOGIN;
postgres=# \password pgpool
postgres=# \password repl
postgres=# \password postgres
要在 SHOW POOL NODES 命令结果中显示 replication_state 和 replication_sync_state 列，角色 pgpool 需要是 PostgreSQL 超级用户或pg_monitor组（Pgpool-II 4.1 或更高版本）。 向 pgpool 授予 pg_monitor：
GRANT pg_monitor TO pgpool;
注意： 如果你打算使用 detach_false_primary（Pgpool-II 4.0 或更高版本）， 角色 “pgpool” 需要是 PostgreSQL 超级用户 或在 pg_monitor 组中使用此功能。
假设所有的 Pgpool-II 服务器和 PostgreSQL 服务器都在同一个子网中，并且编辑 pg_hba.conf 来 启用 scram-sha-256 身份验证方法。
host all pgpool samenet scram-sha-256
host all postgres samenet scram-sha-256
host replication repl samenet scram-sha-256
1.2.4.4. 设置 SSH 公钥身份验证
要使用 Pgpool-II 的自动故障转移和在线恢复， 配置 SSH 公钥身份验证是必需的 （无密码 SSH 登录）到所有使用 postgres 用户的后端服务器（默认用户 Pgpool-II 运行身份。 Pgpool-II 4.0 或之前的版本，默认用户是 root）。
在所有服务器上执行以下命令，以使用 RSA 算法。在此示例中，我们假设生成的密钥文件 name 为 id_rsa_pgpool。
[all servers]# su - postgres
[all servers]$ mkdir ~/.ssh
[all servers]$ chmod 700 ~/.ssh
[all servers]$ cd ~/.ssh
[all servers]$ ssh-keygen -t rsa -f id_rsa_pgpool
然后将公钥 id_rsa_pgpool.pub 添加到 /var/lib/pgsql/.ssh/authorized_keys 文件中 在每个服务器上。
设置 SSH 后，请确保可以运行 ssh postgres@serverX -i ~/.ssh/id_rsa_pgpool 命令 以 Postgres 用户身份登录每个服务器 无需输入密码。
注意： 如果您使用 SSH 公钥身份验证登录失败，请检查以下内容：
确保在 /etc/ssh/sshd_config 中允许使用公钥身份验证选项 PubkeyAuthentication：
PubkeyAuthentication yes
如果启用了 SELinux，SSH 公钥身份验证（无密码 SSH）可能会失败。 您需要在所有服务器上运行以下命令。
[all servers]# su - postgres
[all servers]$ restorecon -Rv ~/.ssh
1.2.4.5. 创建 .pgpass
允许 repl 用户而不指定流式密码 复制和在线恢复，以及使用 Postgres 执行pg_rewind，我们 在 postgres 用户的主目录中创建 .pgpass 文件，并在每个 PostgreSQL 服务器上将权限更改为 600。 此文件允许 repl 用户和 postgres 用户，而无需提供用于流式复制和故障转移的密码。
[all servers]# su - postgres
[all servers]$ vi /var/lib/pgsql/.pgpass
server1:5432:replication:repl:<repl user password>
server2:5432:replication:repl:<repl user password>
server3:5432:replication:repl:<repl user password>
server1:5432:postgres:postgres:<postgres user password>
server2:5432:postgres:postgres:<postgres user password>
server3:5432:postgres:postgres:<postgres user password>
[all servers]$ chmod 600 /var/lib/pgsql/.pgpass
1.2.4.6. 设置防火墙
当连接到 Pgpool-II 和 PostgreSQL 服务器时，必须通过启用防火墙管理软件来访问目标端口。以下是 Rocky Linux 8/RHEL 8 的示例。
[all servers]# firewall-cmd --permanent --zone=public --add-service=postgresql
[all servers]# firewall-cmd --permanent --zone=public --add-port=9999/tcp --add-port=9898/tcp --add-port=9000/tcp --add-port=9694/udp
[all servers]# firewall-cmd --reload
1.2.5. 创建 pgpool_node_id
从 Pgpool-II 4.2 开始，现在所有主机上的配置参数都是相同的。 如果启用了 watchdog 功能，为了区分哪个主机是哪个， 需要 pgpool_node_id 文件。 您需要创建一个 pgpool_node_id 文件并指定 pgpool （watchdog） 节点号 （例如 0， 1， 2 …） 来识别 pgpool （看门狗） 主机。
服务器 1
[server1]# cat /etc/pgpool-II/pgpool_node_id
0
服务器 2
[server2]# cat /etc/pgpool-II/pgpool_node_id
1
服务器 3
[server3]# cat /etc/pgpool-II/pgpool_node_id
2
1.2.6. PCP 连接身份验证
要使用 PCP 命令，PCP 用户名和 md5 加密密码必须为 在 pcp.conf 中以格式声明 “username：encrypted password” 的密码。
在这个例子中，我们将 PCP 用户名设置为 “pgpool” 和 password 设置为 “pgpool_password”。 使用 pg_md5 为 pgpool 用户创建加密的密码条目，如下所示：
[all servers]# echo 'pgpool:'`pg_md5 pgpool_password` >> /etc/pgpool-II/pcp.conf
[all servers]# cat /etc/pgpool-II/pcp.conf
# USERID:MD5PASSWD
pgpool:4aa0cb9673e84b06d4c8a848c80eb5d0
1.2.7. pgpool-II 配置
当使用 YUM 安装 Pgpool-II 时，Pgpool-II 配置文件 pgpool.conf 安装在 /etc/pgpool-II 中。
从 Pgpool-II 4.2 开始，所有的配置参数都是 在所有主机上都是相同的，你可以在任何 pgpool 节点上编辑 pgpool.conf 并将编辑后的 pgpool.conf 文件复制到其他 pgpool 节点。
1.2.7.1. 集群模式
Pgpool-II 有几种集群模式。设置聚类 模式，可以使用 backend_clustering_mode。在此配置中 例如，使用流式复制模式。
backend_clustering_mode = 'streaming_replication'
1.2.7.2. listen_addresses
要允许 Pgpool-II 和 PCP 接受所有传入的连接，请设置以下内容 参数设置为 ‘*’。
listen_addresses = '*'
pcp_listen_addresses = '*'
1.2.7.3. 端口
指定 Pgpool-II 监听的端口号。
port = 9999
1.2.7.4. 流复制检查
在 sr_check_user 和 sr_check_password 中指定复制延迟检查用户和密码。在此示例中，我们将 sr_check_password 留空，并在 pool_passwd 中创建条目。有关如何在 pool_passwd 中创建条目的信息，请参见 Section 1.2.7.9。 从 Pgpool-II 4.0 开始，如果这些参数留空，Pgpool-II 将首先尝试获取该参数的密码 特定用户pool_passwd file 之前。
sr_check_user = 'pgpool'
sr_check_password = ''
1.2.7.5. 健康检查
启用健康检查，以便 Pgpool-II 执行故障转移。此外，如果网络不稳定， 即使后端正常运行，运行状况检查也会失败，可能会发生故障转移或退化操作。 为了防止这种健康检查的错误检测，我们设置 health_check_max_retries = 3。 指定 health_check_user 和 health_check_password 就像 sr_check_user 和 sr_check_password 一样。
health_check_period = 5
health_check_timeout = 30
health_check_user = 'pgpool'
health_check_password = ''
health_check_max_retries = 3
1.2.7.6. 后端设置
指定 PostgreSQL 后端信息。 可以通过在参数名称末尾添加一个数字来指定多个后端。
#- Backend Connection Settings -
backend_hostname0 = 'server1'
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/var/lib/pgsql/16/data'
backend_flag0 = 'ALLOW_TO_FAILOVER'
backend_hostname1 = 'server2'
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/var/lib/pgsql/16/data'
backend_flag1 = 'ALLOW_TO_FAILOVER'
backend_hostname2 = 'server3'
backend_port2 = 5432
backend_weight2 = 1
backend_data_directory2 = '/var/lib/pgsql/16/data'
backend_flag2 = 'ALLOW_TO_FAILOVER'
要在 SHOW POOL NODES 命令结果中显示replication_state和replication_sync_state列，backend_application_name参数是必需的。 在这里，我们在这些参数中指定每个后端的主机名 （Pgpool-II 4.1 或更高版本）。 确保 backend_application_nameX 中设置的值与 application_name of primary_conninfo 中设置的值匹配。
...
backend_application_name0 = 'server1'
...
backend_application_name1 = 'server2'
...
backend_application_name2 = 'server3'
1.2.7.7. 故障转移配置
指定在 failover_command 中发生失效切换时将执行的脚本。使用三个或更多时 PostgreSQL 服务器，需要指定 follow_primary_command 才能同步备用数据库 替换为新的主数据库。如果有两个 PostgreSQL 服务器，则不需要设置 follow_primary_command。
注意： 当使用 pcp_promote_node 执行切换时，在 Pgpool-II 4.3 中添加了切换选项， 如果要将以前的主数据库自动转换为备用数据库，则需要设置 follow_primary_command 即使有两个 PostgreSQL 服务器。
Pgpool-II 将以下特殊字符替换为后端特定的 信息。 有关每个角色的更多详细信息，请参阅 failover_command 和 follow_primary_command。
failover_command = '/etc/pgpool-II/failover.sh %d %h %p %D %m %H %M %P %r %R %N %S'
follow_primary_command = '/etc/pgpool-II/follow_primary.sh %d %h %p %D %m %H %M %P %r %R'
注意： %N 和 %S 是在 Pgpool-II 4.1 中添加的。 请注意，如果使用 Pgpool-II 4.0 或更早版本，则无法指定这些字符。
failover.sh 和 follow_primary.sh 示例脚本安装在 /etc/pgpool-II/ 中。使用以下示例文件创建故障转移脚本。
[all servers]# cp -p /etc/pgpool-II/sample_scripts/failover.sh.sample /etc/pgpool-II/failover.sh
[all servers]# cp -p /etc/pgpool-II/sample_scripts/follow_primary.sh.sample /etc/pgpool-II/follow_primary.sh
[all servers]# chown postgres:postgres /etc/pgpool-II/{failover.sh,follow_primary.sh}
基本上，如果您根据 PostgreSQL 安装目录。
[all servers]# vi /etc/pgpool-II/failover.sh
...
PGHOME=/usr/pgsql-16
...
[all servers]# vi /etc/pgpool-II/follow_primary.sh
...
PGHOME=/usr/pgsql-16
...
确保在 follow_primary.sh 的 PCP_USER 中指定的 PCP 用户的条目是在 pcp.conf 中创建的。 在此示例中，我们在 Section 1.2.6 中创建了
# cat /etc/pgpool-II/follow_primary.sh
...
PCP_USER=pgpool
...
由于follow_primary.sh脚本必须在没有 输入密码后，我们需要在每个服务器的 Postgres 用户主目录中创建 .pcppass （用户 Pgpool-II 的主目录运行）。 .pcppass 的格式为 “hostname：port：username：password” 来获取。
在这个例子中，我们假设 PCP 用户是 pgpool，密码是 pgpool_password。
[all servers]# su - postgres
[all servers]$ echo 'localhost:9898:pgpool:pgpool_password' > ~/.pcppass
[all servers]$ chmod 600 ~/.pcppass
注意： follow_primary.sh 脚本不支持表空间。 如果您使用的是表空间，则需要修改脚本以支持表空间。
1.2.7.8. pgpool-II 在线恢复配置
接下来，配置所需的参数以执行在线恢复。 由于执行联机恢复需要 PostgreSQL 中的超级用户权限，因此我们在 recovery_user 中指定 postgres 用户。在此示例中，我们将 recovery_password 留空，并在 pool_passwd 中创建条目。有关如何在 pool_passwd 中创建条目的信息，请参见 Section 1.2.7.9。
recovery_user = 'postgres'
recovery_password = ''
recovery_1st_stage_command = 'recovery_1st_stage'
然后，我们在 PostgreSQL 主服务器 （server1） 的数据库集群目录中创建 recovery_1st_stage 和 pgpool_remote_start。
在线恢复 recovery_1st_stage 和 pgpool_remote_start 的示例脚本安装在 /etc/pgpool-II/ 中。将这些文件复制到主服务器 （server1） 的数据目录。
[server1]# cp -p /etc/pgpool-II/sample_scripts/recovery_1st_stage.sample /var/lib/pgsql/16/data/recovery_1st_stage
[server1]# cp -p /etc/pgpool-II/sample_scripts/pgpool_remote_start.sample /var/lib/pgsql/16/data/pgpool_remote_start
[server1]# chown postgres:postgres /var/lib/pgsql/16/data/{recovery_1st_stage,pgpool_remote_start}
基本上，如果您根据 PostgreSQL 安装目录更改 PGHOME，它应该可以工作。
[server1]# vi /var/lib/pgsql/16/data/recovery_1st_stage
...
PGHOME=/usr/pgsql-16
...
[server1]# vi /var/lib/pgsql/16/data/pgpool_remote_start
...
PGHOME=/usr/pgsql-16
...
为了使用在线恢复功能，需要 、 、 的功能，因此我们需要安装在 PostgreSQL 服务器 server1 的 template1 上。pgpool_recoverypgpool_remote_startpgpool_switch_xlogpgpool_recovery
[server1]# su - postgres
[server1]$ psql template1 -c "CREATE EXTENSION pgpool_recovery"
注意： recovery_1st_stage 脚本不支持表空间。 如果您使用的是表空间，则需要修改脚本以支持表空间。
1.2.7.9. 客户端身份验证配置
因为在 开始之前 部分， 我们已经将 PostgreSQL 认证方式设置为 scram-sha-256，因此需要通过 Pgpool-II 设置客户端认证才能连接到后端节点。 当使用 RPM 安装时，Pgpool-II 配置文件 pool_hba.conf 位于 /etc/pgpool-II 中。 默认情况下，pool_hba身份验证处于禁用状态，请将 enable_pool_hba = on 设置为启用它。
enable_pool_hba = on
pool_hba.conf 文件的格式如下 PostgreSQL 的 pg_hba.conf 格式非常接近。 设置 pgpool 和 postgres 用户的 authentication 方法设置为 scram-sha-256。在此示例中， 假设连接到 Pgpool-II 的应用程序在同一个子网中。
host all pgpool samenet scram-sha-256
host all postgres samenet scram-sha-256
注意： 请注意，在 Pgpool-II 4.0 中，只有 AES 加密密码或明文密码 可以在 health_check_password、sr_check_password、wd_lifecheck_password recovery_password pgpool.conf 中指定。
用于身份验证的默认密码文件名为 pool_passwd。 要使用 scram-sha-256 身份验证，请将解密密钥更改为 需要解密密码。我们在 postgres 用户的主目录中创建 .pgpoolkey 文件 （用户 Pgpool-II 运行身份。Pgpool-II 4.0 或更早版本，Pgpool-II 默认以 root 身份运行）
[all servers]# su - postgres
[all servers]$ echo 'some string' > ~/.pgpoolkey
[all servers]$ chmod 600 ~/.pgpoolkey
执行命令 pg_enc -m -k /path/to/.pgpoolkey -u username -p 注册用户 文件名和 AES 加密密码 pool_passwd。 如果 pool_passwd 还不存在，它将在与 pgpool.conf 相同的目录中创建。
[all servers]# su - postgres
[all servers]$ pg_enc -m -k ~/.pgpoolkey -u pgpool -p
db password: [pgpool user's password]
[all servers]$ pg_enc -m -k ~/.pgpoolkey -u postgres -p
db password: [postgres user's password]
# cat /etc/pgpool-II/pool_passwd
pgpool:AESheq2ZMZjynddMWk5sKP/Rw==
postgres:AESHs/pWL5rtXy2IwuzroHfqg==
1.2.7.10. 看门狗配置
在 server1、server2、server3 上启用看门狗功能。
use_watchdog = on
将 虚拟 IP 地址设置为 delegate_ip。 确保尚未使用 IP 地址。
delegate_ip = '192.168.100.50'
为了启动/关闭虚拟 IP 并发送 ARP 请求，我们设置了 if_up_cmd、if_down_cmd 和 arping_cmd。 此示例中使用的网络接口为 “enp0s8”。 由于执行 if_up/down_cmd 或 arping_cmd 命令需要 root 权限，因此在这些命令上使用 setuid 或允许 postgres 用户（Pgpool-II 运行的用户身份）在没有密码的情况下运行 sudo 命令。
注意： 如果 Pgpool-II 是使用 RPM 安装的，postgres 用户已经被配置为通过 sudo 运行 ip/arping，而不使用 密码。
postgres ALL=NOPASSWD: /sbin/ip
postgres ALL=NOPASSWD: /usr/sbin/arping
这里我们配置以下参数来运行 if_up/down_cmd 或使用 sudo arping_cmd。
if_up_cmd = '/usr/bin/sudo /sbin/ip addr add $_IP_$/24 dev enp0s8 label enp0s8:0'
if_down_cmd = '/usr/bin/sudo /sbin/ip addr del $_IP_$/24 dev enp0s8'
arping_cmd = '/usr/bin/sudo /usr/sbin/arping -U $_IP_$ -w 1 -I enp0s8'
注意： 如果在 /etc/sudoers 中设置了 “Defaults requiretty”， 请确保 Pgpool-II 正在运行的用户可以在没有 tty 的情况下执行 if_up_cmd、if_down_cmd 和 arping_cmd 命令。
arping_path if_cmd_path根据 命令路径。 如果 if_up/down_cmd 或 arping_cmd 以 “/” 开头，则这些参数将被忽略。
if_cmd_path = '/sbin'
arping_path = '/usr/sbin'
指定所有 Pgpool-II 节点信息以配置看门狗。 使用第 1.2.7.3 节的 port 中指定的端口号指定 pgpool_portX。
hostname0 = 'server1'
wd_port0 = 9000
pgpool_port0 = 9999
hostname1 = 'server2'
wd_port1 = 9000
pgpool_port1 = 9999
hostname2 = 'server3'
wd_port2 = 9000
pgpool_port2 = 9999
配置 lifecheck wd_lifecheck_method 的方法和 lifecheck interval wd_interval。 在这里，我们使用 heartbeat 方法执行看门狗 lifecheck。
wd_lifecheck_method = ‘heartbeat’
wd_interval = 10
指定发送和接收心跳信号的所有 Pgpool-II 节点信息。
heartbeat_hostname0 = 'server1'
heartbeat_port0 = 9694
heartbeat_device0 = ''
heartbeat_hostname1 = 'server2'
heartbeat_port1 = 9694
heartbeat_device1 = ''
heartbeat_hostname2 = 'server3'
heartbeat_port2 = 9694
heartbeat_device2 = ''
如果 wd_lifecheck_method 设置为 heartbeat，则 指定检测故障的时间 wd_heartbeat_deadtime 和 发送检测信号的间隔wd_heartbeat_deadtime。
wd_heartbeat_keepalive = 2
wd_heartbeat_deadtime = 30
此设置是可选的。 当 Watchdog 进程异常终止时， 虚拟 IP 可能在旧的和新的活跃 pgpool 节点上都处于 “up” 状态。 为了防止这种情况，配置 wd_escalation_command 来关闭其他 Pgpool-II 节点上的虚拟 IP 在新的领导 Pgpool-II 节点上启动虚拟 IP。
wd_escalation_command = '/etc/pgpool-II/escalation.sh'
escalation.sh 示例脚本安装在 /etc/pgpool-II/。
[all servers]# cp -p /etc/pgpool-II/sample_scripts/escalation.sh.sample /etc/pgpool-II/escalation.sh
[all servers]# chown postgres:postgres /etc/pgpool-II/escalation.sh
基本上，如果您根据环境更改以下变量，它应该可以正常工作。 PGPOOLS 是运行 Pgpool-II 的主机名列表。 VIP 是设置为 delegate_ip 的虚拟 IP 地址。 DEVICE 是虚拟 IP 的网络接口。
[all servers]# vi /etc/pgpool-II/escalation.sh
...
PGPOOLS=(server1 server2 server3)
VIP=192.168.100.50
DEVICE=enp0s8
...
注意： 如果您的看门狗节点数为偶数，则需要开启enable_consensus_with_half_votes参数。
注意： 如果 use_watchdog = on，请确保 pgpool 节点编号在 pgpool_node_id 文件中指定。 有关详细信息，请参见 Section 1.2.5 。
1.2.7.11. 日志记录
从 Pgpool-II 4.2 开始，实现了日志收集器进程。 在示例中，我们启用了日志记录收集器。
log_destination = 'stderr'
logging_collector = on
log_directory = '/var/log/pgpool_log'
log_filename = 'pgpool-%a.log'
log_truncate_on_rotation = on
log_rotation_age = 1d
log_rotation_size = 10MB
在所有服务器上创建日志目录。
[all servers]# mkdir /var/log/pgpool_log/
[all servers]# chown postgres:postgres /var/log/pgpool_log/
server1 上的 pgpool.conf 配置完成。 复制 pgpool.conf 到其他 Pgpool-II 节点（server2 和 server3）。
[server1]# scp -p /etc/pgpool-II/pgpool.conf root@server2:/etc/pgpool-II/pgpool.conf
[server1]# scp -p /etc/pgpool-II/pgpool.conf root@server3:/etc/pgpool-II/pgpool.conf
1.2.8. 如何使用
让我们开始使用 Pgpool-II。
1.2.8.1. 启动/停止 pgpool-II
启动 pgpool-II
首先，让我们启动 Pgpool-II。
在启动 Pgpool-II 之前， PostgreSQL 主服务器必须已在运行。 如果 PostgreSQL 主服务器未运行，请先启动它 使用以下命令。
[server1]# su - postgres
[server1]$ /usr/pgsql-16/bin/pg_ctl start -D $PGDATA
使用以下命令在 server1、server2、server3 上启动 Pgpool-II。
[all servers]# systemctl start pgpool.service
停止 pgpool-II
当停止 PostgreSQL 时，必须先停止 Pgpool-II。
[all servers]# systemctl stop pgpool.service
1.2.8.2. 设置 PostgreSQL 备用服务器
首先，我们应该通过以下方式设置 PostgreSQL 备用服务器 使用 Pgpool-II 在线恢复功能。
通过虚拟 IP 连接到 Pgpool-II 以检查后端节点的状态。 如结果所示，主服务器在 server1 上运行， server2 和 server3 上的备用服务器处于 “down” 状态。
[any server]# psql -h 192.168.100.50 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | primary | primary | 0 | true | 0 | | | 2023-11-10 15:30:14
1 | server2 | 5432 | down | down | 0.333333 | standby | unknown | 0 | false | 0 | | | 2023-11-10 15:30:14
2 | server3 | 5432 | down | down | 0.333333 | standby | unknown | 0 | false | 0 | | | 2023-11-10 15:30:14
(3 rows)
在运行pcp_recovery_node命令之前， 确保 recovery_1st_stage 和 pgpool_remote_start 脚本存在于 PostgreSQL 主服务器 （server1） 的 data 目录。
[any server]# pcp_recovery_node -h 192.168.100.50 -p 9898 -U pgpool -n 1 -W
Password:
pcp_recovery_node -- Command Successful
[any server]# pcp_recovery_node -h 192.168.100.50 -p 9898 -U pgpool -n 2 -W
Password:
pcp_recovery_node -- Command Successful
执行pcp_recovery_node命令后， 验证 PostgreSQL 备用服务器 在 server2 和 server3 上运行。
[any server]# psql -h 192.168.100.50 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | primary | primary | 0 | false | 0 | | | 2023-11-10 15:30:14
1 | server2 | 5432 | up | up | 0.333333 | standby | standby | 0 | true | 0 | streaming | async | 2023-11-10 16:32:33
2 | server3 | 5432 | up | up | 0.333333 | standby | standby | 0 | false | 0 | streaming | async | 2023-11-10 16:33:08
(3 rows)
1.2.8.3. 切换 leader/standby 看门狗
使用 pcp_watchdog_info 确认 watchdog 状态。首先启动的 Pgpool-II 服务器以 LEADER 运行。
[any server]# pcp_watchdog_info -h 192.168.100.50 -p 9898 -U pgpool -W
Password:
3 3 YES server1:9999 Linux server1 server1
server1:9999 Linux server1 server1 9999 9000 4 LEADER 0 MEMBER # The Pgpool-II server started first becomes "LEADER".
server2:9999 Linux server2 server2 9999 9000 7 STANDBY 0 MEMBER # running as STANDBY
server3:9999 Linux server3 server3 9999 9000 7 STANDBY 0 MEMBER # running as STANDBY
如果 server1 上的 LEADER Pgpool-II 宕机，server2 或 server3 上的备用 Pgpool-II 将成为新的 LEADER。
要验证此行为，您可以停止 Pgpool-II 服务或关闭整个系统。在这里，我们停止 Pgpool-II 服务。
[server1]# systemctl stop pgpool.service
[server1]# pcp_watchdog_info -p 9898 -h 192.168.100.50 -U pgpool -W
Password:
3 3 YES server2:9999 Linux server2 server2
server2:9999 Linux server2 server2 9999 9000 4 LEADER 0 MEMBER # server2 becomes LEADER
server1:9999 Linux server1 server1 9999 9000 10 SHUTDOWN 0 MEMBER # server1 is stopped
server3:9999 Linux server3 server3 9999 9000 7 STANDBY 0 MEMBER # server3 is running as a STANDBY
在 server1 上重启已停止的 Pgpool-II，并验证它是否正在运行 作为备用数据库。
[server1]# systemctl start pgpool.service
[server1]# pcp_watchdog_info -p 9898 -h 192.168.100.50 -U pgpool -W
Password:
3 3 YES server2:9999 Linux server2 server2
server2:9999 Linux server2 server2 9999 9000 4 LEADER 0 MEMBER
server1:9999 Linux server1 server1 9999 9000 7 STANDBY 0 MEMBER
server3:9999 Linux server3 server3 9999 9000 7 STANDBY 0 MEMBER
1.2.8.4. 故障转移
首先，使用 psql 通过虚拟 IP 连接到 PostgreSQL， 并验证后端信息。
# psql -h 192.168.100.50 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | primary | primary | 0 | false | 0 | | | 2023-11-10 15:30:14
1 | server2 | 5432 | up | up | 0.333333 | standby | standby | 0 | false | 0 | streaming | async | 2023-11-10 16:32:33
2 | server3 | 5432 | up | up | 0.333333 | standby | standby | 0 | true | 0 | streaming | async | 2023-11-10 16:33:08
(3 rows)
接下来，停止主 PostgreSQL 服务器 在 server1 上，验证是否执行了故障转移 自然而然。
[server1]$ pg_ctl -D /var/lib/pgsql/16/data -m immediate stop
在 server1 上停止 PostgreSQL 后，将发生故障转移。server2 上的 PostgreSQL 成为新的主数据库， server3 上的备用服务器配置为新主服务器的备用服务器。
[any server]# psql -h 192.168.100.50 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | down | down | 0.333333 | standby | unknown | 0 | false | 0 | | | 2023-11-10 17:05:40
1 | server2 | 5432 | up | up | 0.333333 | primary | primary | 0 | false | 0 | | | 2023-11-10 17:05:40
2 | server3 | 5432 | up | up | 0.333333 | standby | standby | 0 | true | 0 | streaming | async | 2023-11-10 17:05:51
(3 rows)
server3 作为新的主 server2 的备用服务器运行。
[server3]# psql -h server3 -p 5432 -U pgpool postgres -c "select pg_is_in_recovery()"
pg_is_in_recovery
-------------------
t
[server2]# psql -h server2 -p 5432 -U pgpool postgres -c "select pg_is_in_recovery()"
pg_is_in_recovery
-------------------
f
[server2]# psql -h server2 -p 5432 -U pgpool postgres -c "select * from pg_stat_replication" -x
-[ RECORD 1 ]----+------------------------------
pid | 7198
usesysid | 16385
usename | repl
application_name | server3
client_addr | 192.168.100.53
client_hostname |
client_port | 40916
backend_start | 2023-11-10 17:10:03.067241+00
backend_xmin |
state | streaming
sent_lsn | 0/12000260
write_lsn | 0/12000260
flush_lsn | 0/12000260
replay_lsn | 0/12000260
write_lag |
flush_lag |
replay_lag |
sync_priority | 0
sync_state | async
reply_time | 2023-11-10 17:17:23.886477+00
1.2.8.5. 在线恢复
这里，我们使用 Pgpool-II 在线恢复 功能将 Server1 上的前一个主数据库恢复为备用数据库。
[any server]# pcp_recovery_node -h 192.168.100.50 -p 9898 -U pgpool -n 0 -W
Password:
pcp_recovery_node -- Command Successful
然后验证 server1 上的 PostgreSQL 是否为 作为备用 RUNNING 运行。
[any server]# psql -h 192.168.100.50 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | lb_weight | role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | standby | standby | 0 | true | 0 | streaming | async | 2023-11-10 17:22:03
1 | server2 | 5432 | up | up | 0.333333 | primary | primary | 0 | false | 0 | | | 2023-11-10 17:05:40
2 | server3 | 5432 | up | up | 0.333333 | standby | standby | 0 | false | 0 | streaming | async | 2023-11-10 17:05:51
(3 rows)
1.3. 复制模式和快照隔离模式配置示例
本节展示了如何配置 Pgpool-II 复制模式和快照隔离模式的示例。
在第 1.2 节中描述的流复制模式下， 复制由 PostgreSQL 的流式复制功能执行。 然而，在本地复制模式下，Pgpool-II 通过将写查询路由到所有 PostgreSQL 服务器来执行复制。
快照隔离模式类似于本机复制模式，只是它添加了 节点之间的可见性一致性。
本配置示例使用 PostgreSQL 14。 所有脚本均已使用 PostgreSQL 10 及更高版本进行了测试。
1.3.1. 集群结构
在这个例子中，我们使用一个 Pgpool-II 和 三个 PostgreSQL 服务器来描述如何配置和使用 Pgpool-II 的 复制。
在此示例中，我们使用 3 台安装了 CentOS 7.9 的服务器。 让这些服务器是 server1、server2、server3。 我们在所有服务器上安装了 PostgreSQL，在 server1 上安装了 Pgpool-II。
在此示例中，我们使用最低设置来配置复制。 在生产环境中，建议开启 Watchdog 以避免单点故障。 有关 Watchdog 配置的更多详细信息，请参阅 Section 1.2.7.10。
表 1-7.主机名和 IP 地址
| Hostname | IP Address | Virtual IP |
|---|---|---|
| server1 | 192.168.137.101 | PostgreSQL node0, Pgpool-II |
| server2 | 192.168.137.102 | PostgreSQL node1 |
| server3 | 192.168.137.103 | PostgreSQL node2 |
| 表 1-8.PostgreSQL 版本和配置 |
| Item | Value | Detail |
|---|---|---|
| PostgreSQL Version | 14.0 | - |
| port | 5432 | - |
| $PGDATA | /var/lib/pgsql/14/data | - |
| Archive mode | on | /var/lib/pgsql/archivedir |
| 表 1-9.Pgpool-II 版本和配置 |
| Item | Value | Detail |
|---|---|---|
| Pgpool-II Version | 4.3.0 | - |
| port | 9999 | Pgpool-II accepts connections |
| 9898 | PCP process accepts connections | |
| Config file | /etc/pgpool-II/pgpool.conf | Pgpool-II config file |
| Pgpool-II start user | postgres (Pgpool-II 4.1 or later) | Pgpool-II 4.0 or before, the default startup user is root |
| Clustering mode | native replication mode | - |
| snapshot isolation mode | - |
1.3.2. 安装
在此示例中，我们使用 YUM 安装 Pgpool-II 和 PostgreSQL RPM 包。
从 PostgreSQL YUM 存储库安装 PostgreSQL。
[all servers]# yum install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-7-x86_64/pgdg-redhat-repo-latest.noarch.rpm
[all servers]# yum install -y postgresql14-server
由于 Pgpool-II 相关的包也包含在 PostgreSQL YUM 仓库中， 将 “exclude” 设置添加到 /etc/yum.repos.d/pgdg-redhat-all.repo 中，这样 Pgpool-II 就不会从 PostgreSQL YUM 仓库安装。
[all servers]# vi /etc/yum.repos.d/pgdg-redhat-all.repo
以下是 /etc/yum.repos.d/pgdg-redhat-all.repo 的设置示例。
[pgdg-common]
...
exclude=pgpool*
[pgdg14]
...
exclude=pgpool*
[pgdg13]
...
exclude=pgpool*
[pgdg12]
...
exclude=pgpool*
[pgdg11]
...
exclude=pgpool*
[pgdg10]
...
exclude=pgpool*
[pgdg96]
...
exclude=pgpool*
使用 Pgpool-II YUM 仓库安装 Pgpool-II。
[all servers]# yum install -y https://www.pgpool.net/yum/rpms/4.4/redhat/rhel-7-x86_64/pgpool-II-release-4.4-1.noarch.rpm
[all servers]# yum install -y pgpool-II-pg14-*
1.3.3. 开始之前
在开始配置过程之前，请检查以下先决条件。
1.3.3.1. 设置 postgres 用户的密码
执行以下命令，在每台服务器上设置 postgres 用户的密码。
[all servers]# passwd postgres
1.3.3.2. 配置无密码 SSH 登录
要使用 Pgpool-II 的在线恢复， 允许所有 SSH 使用无密码 SSH 的设置 服务器是必需的。 在所有服务器上执行以下命令以设置无密码 SSH。 生成的密钥文件名为 id_rsa_pgpool。
[all servers]# su - postgres
[all servers]$ cd ~/.ssh
[all servers]$ ssh-keygen -t rsa -f id_rsa_pgpool
[all servers]$ ssh-copy-id -i id_rsa_pgpool.pub postgres@server1
[all servers]$ ssh-copy-id -i id_rsa_pgpool.pub postgres@server2
[all servers]$ ssh-copy-id -i id_rsa_pgpool.pub postgres@server3
设置 SSH 后，使用 ssh postgres@serverX -i ~/.ssh/id_rsa_pgpool 命令 确保无需输入密码即可登录。如有必要，请编辑 /etc/ssh/sshd_config 并重新启动 sshd。
1.3.3.3. 创建 .pgpass
允许 repl 用户执行在线恢复脚本 在不指定密码的情况下，我们创建 .pgpass 文件 在 Postgres 用户的主目录中，并将 权限设置为 600。
[all servers]# su - postgres
[all servers]$ vi /var/lib/pgsql/.pgpass
server1:5432:replication:repl:<repl user password>
server2:5432:replication:repl:<repl user password>
server3:5432:replication:repl:<repl user password>
server1:5432:postgres:postgres:<postgres user password>
server2:5432:postgres:postgres:<postgres user password>
server3:5432:postgres:postgres:<postgres user password>
[all servers]$ chmod 600 /var/lib/pgsql/.pgpass
1.3.3.4. 配置防火墙
当连接到 Pgpool-II 和 PostgreSQL 服务器时，必须通过启用防火墙管理软件来访问目标端口。以下是 CentOS/RHEL7 的示例。
[all servers]# firewall-cmd --permanent --zone=public --add-service=postgresql
[all servers]# firewall-cmd --permanent --zone=public --add-port=9999/tcp --add-port=9898/tcp
[all servers]# firewall-cmd --reload
如果启用了 Watchdog，您还需要开放 9000 和 9694 端口。
[all servers]# firewall-cmd --permanent --zone=public --add-port=9000/tcp --add-port=9694/udp
1.3.4. PostgreSQL 配置
本节介绍如何创建和配置 PostgreSQL 服务器。
在此示例中，我们使用 WAL 存档。 首先，我们创建目录 /var/lib/pgsql/archivedir 以在所有服务器上存储 WAL 段。
[all servers]# su - postgres
[all servers]$ mkdir /var/lib/pgsql/archivedir
在 server1 上仅创建一个 PostgreSQL 服务器。 另外两个 PostgreSQL 服务器是使用 Pgpool-II 的在线 恢复功能。
执行以下命令，在 server1 上创建 PostgreSQL 数据库集群。
[server1]# su - postgres
[server1]$ /usr/pgsql-14/bin/initdb -E UTF8 --no-locale
然后在 server1 上编辑 $PGDATA/postgresql.conf。
[server1]$ vi $PGDATA/postgresql.conf
listen_addresses = '*'
archive_mode = on
archive_command = 'cp "%p" "/var/lib/pgsql/archivedir/%f"'
假设所有的 Pgpool-II 服务器和 PostgreSQL 服务器都在同一个子网中，并且编辑 pg_hba.conf 来 启用 scram-sha-256 身份验证方法。
[server1]$ vi $PGDATA/pg_hba.conf
host all all samenet scram-sha-256
host replication all samenet scram-sha-256
执行以下命令以启动 PostgreSQL 服务器。
[server1]$ /usr/pgsql-14/bin/pg_ctl start
创建 PostgreSQL 用户。
表 1-10.PostgreSQL 用户
| 用户名 | 密码 | 细节 |
|---|---|---|
| repl | repl | PostgreSQL 复制用户 |
| pgpool | pgpool | 执行运行状况检查的用户 （health_check_user) |
| postgres | postgres | 执行在线恢复的用户 |
[server1]$ psql -U postgres -p 5432
postgres=# SET password_encryption = 'scram-sha-256';
postgres=# CREATE ROLE pgpool WITH LOGIN;
postgres=# CREATE ROLE repl WITH REPLICATION LOGIN;
postgres=# \password pgpool
postgres=# \password repl
postgres=# \password postgres
1.3.4.1. 快照隔离模式的设置
快照隔离模式仅在 PostgreSQL 的事务隔离时可用 level 是 “repeatable read” 的。 如果要使用快照隔离模式，请在 postgresql.conf 中设置 default_transaction_isolation =‘repeatable read’。
[server1]$ vi $PGDATA/postgresql.conf
default_transaction_isolation = 'repeatable read'
1.3.5. 配置 pgpool-II
当使用 RPM 安装 Pgpool-II 时，Pgpool-II 的配置示例文件位于 /etc/pgpool-II 中。
1.3.5.1. 集群模式
首先，在 backend_clustering_mode 中指定 Pgpool-II 集群模式。
本机复制模式
backend_clustering_mode = 'native_replication'
快照隔离模式
backend_clustering_mode = 'snapshot_isolation'
1.3.5.2. listen_addresses
为了允许 Pgpool-II 接受所有传入的连接，我们设置 listen_addresses = ‘*’。
listen_addresses = '*'
1.3.5.3. 健康检查
启用健康检查以允许 Pgpool-II 检测 PostgreSQL 故障。 此外，如果网络不稳定，即使后端正在运行，运行状况检查也会失败 正确地，可能会发生故障转移或退化操作。 为了防止这种健康检查的错误检测，我们设置 health_check_max_retries = 3。 指定 health_check_user 和 health_check_password。 在此示例中，我们将 sr_check_password 留空，并创建条目 在 pool_passwd。 有关如何在 pool_passwd 中创建条目的信息，请参见 Section 1.3.5.6。 从 Pgpool-II 4.0 开始，如果这些参数留空，Pgpool-II 将首先尝试获取该参数的密码 在使用空口令之前pool_passwd 文件中的特定用户。
health_check_period = 5
health_check_timeout = 30
health_check_user = 'pgpool'
health_check_password = ''
health_check_max_retries = 3
1.3.5.4. 后端设置
指定 PostgreSQL 后端信息。 可以通过在参数名称末尾添加一个数字来指定多个后端。
#- Backend Connection Settings -
backend_hostname0 = 'server1'
backend_port0 = 5432
backend_weight0 = 1
backend_data_directory0 = '/var/lib/pgsql/14/data'
backend_flag0 = 'ALLOW_TO_FAILOVER'
backend_hostname1 = 'server2'
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = '/var/lib/pgsql/14/data'
backend_flag1 = 'ALLOW_TO_FAILOVER'
backend_hostname2 = 'server3'
backend_port2 = 5432
backend_weight2 = 1
backend_data_directory2 = '/var/lib/pgsql/14/data'
backend_flag2 = 'ALLOW_TO_FAILOVER'
1.3.5.5. 在线恢复
接下来，为了执行在线恢复，我们指定 PostgreSQL 用户名和在线恢复命令 recovery_1st_stage_command 和 recovery_2nd_stage_command。 由于执行联机恢复需要 PostgreSQL 中的超级用户权限，因此我们在 recovery_user 中指定 postgres 用户。
recovery_user = 'postgres'
recovery_password = ''
recovery_1st_stage_command = 'recovery_1st_stage'
recovery_2nd_stage_command = 'recovery_2nd_stage'
示例脚本 replication_mode_recovery_1st_stage.sample， replication_mode_recovery_2nd_stage.sample 和 pgpool_remote_start.sample 安装在 /etc/pgpool-II/ 中。 从示例脚本中创建 online recovery 命令使用的脚本，并将这些文件复制到数据库集群目录。
[server1]# cp -p /etc/pgpool-II/sample_scripts/replication_mode_recovery_1st_stage.sample /var/lib/pgsql/14/data/recovery_1st_stage
[server1]# cp -p /etc/pgpool-II/sample_scripts/replication_mode_recovery_2nd_stage.sample /var/lib/pgsql/14/data/recovery_2nd_stage
[server1]# cp -p /etc/pgpool-II/sample_scripts/pgpool_remote_start.sample /var/lib/pgsql/14/data/pgpool_remote_start
[server1]# chown postgres:postgres /var/lib/pgsql/14/data/{recovery_1st_stage,recovery_2nd_stage,pgpool_remote_start}
基本上，如果您根据 PostgreSQL 安装目录更改 PGHOME，它应该可以工作。
[server1]# vi /var/lib/pgsql/14/data/recovery_1st_stage
...
PGHOME=/usr/pgsql-14
...
[server1]# vi /var/lib/pgsql/14/data/recovery_2nd_stage
...
PGHOME=/usr/pgsql-14
...
[server1]# vi /var/lib/pgsql/14/data/pgpool_remote_start
...
PGHOME=/usr/pgsql-14
...
为了使用在线恢复功能，需要 、 、 的功能，因此我们需要安装在 PostgreSQL 服务器 server1 的 template1 上。pgpool_recoverypgpool_remote_startpgpool_switch_xlogpgpool_recovery
[server1]# su - postgres
[server1]$ psql template1 -c "CREATE EXTENSION pgpool_recovery"
注意： recovery_1st_stage 脚本不支持表空间。 如果您使用的是表空间，则需要修改脚本以支持表空间。
1.3.5.6. 客户端身份验证配置
在 client 和 Pgpool-II 之间启用客户端身份验证。 当使用 RPM 安装时，Pgpool-II 配置文件 pool_hba.conf 位于 /etc/pgpool-II 中。 默认情况下，pool_hba身份验证处于禁用状态，请将 enable_pool_hba = on 设置为启用它。
enable_pool_hba = on
pool_hba.conf 文件的格式与 PostgreSQL 的 pg_hba.conf 格式非常接近。将 pgpool 和 postgres 用户的身份验证方法设置为 scram-sha-256。
[server1]# vi /etc/pgpool-II/pool_hba.conf
host all pgpool 0.0.0.0/0 scram-sha-256
host all postgres 0.0.0.0/0 scram-sha-256
注意： 请注意，在 Pgpool-II 4.0 中，只有 AES 加密密码或明文密码 可以在 health_check_password、sr_check_password、wd_lifecheck_password recovery_password pgpool.conf 中指定。
用于身份验证的默认密码文件名为 pool_passwd。 要使用 scram-sha-256 身份验证，请使用解密密钥来解密密码 是必需的。我们在 Pgpool-II 启动用户 postgres（Pgpool-II 4.1 或更高版本）的主目录中创建 .pgpoolkey 文件。 （Pgpool-II 4.0 或更早版本，默认情况下 Pgpool-II 以 root 身份启动)
[server1]# su - postgres
[server1]$ echo 'some string' > ~/.pgpoolkey
[server1]$ chmod 600 ~/.pgpoolkey
执行命令 pg_enc -m -k /path/to/.pgpoolkey -u username -p 注册用户 文件名和 AES 加密密码 pool_passwd。 如果 pool_passwd 还不存在，它将在与 pgpool.conf 相同的目录中创建。
[server1]# su - postgres
[server1]$ pg_enc -m -k ~/.pgpoolkey -u pgpool -p
db password: [pgpool user's password]
[server1]$ pg_enc -m -k ~/.pgpoolkey -u postgres -p
db password: [postgres user's password]
[server1]$ cat /etc/pgpool-II/pool_passwd
pgpool:AESheq2ZMZjynddMWk5sKP/Rw==
postgres:AESHs/pWL5rtXy2IwuzroHfqg==
1.3.5.7. PCP 密码
由于使用 PCP 命令需要用户身份验证，因此 我们需要在 pcp.conf 中以 “username：encrypted password” 格式指定用户名和 MD5 加密密码。
我们使用 pg_md5 为 pgpool 用户创建加密的密码条目，如下所示：
[server1]# echo 'pgpool:'`pg_md5 PCP password` >> /etc/pgpool-II/pcp.conf
1.3.5.8. 日志记录
从 Pgpool-II 4.2 开始，实现了日志收集器进程。 在示例中，我们启用了日志记录收集器。
log_destination = 'stderr'
logging_collector = on
log_directory = '/var/log/pgpool_log'
log_filename = 'pgpool-%Y-%m-%d_%H%M%S.log'
log_truncate_on_rotation = on
log_rotation_age = 1d
log_rotation_size = 10MB
在 server1 上创建日志目录。
[server1]# mkdir /var/log/pgpool_log/
[server1]# chown postgres:postgres /var/log/pgpool_log/
1.3.6. 启动/停止 Pgpool-II
在启动 Pgpool-II 之前，请先启动 PostgreSQL 服务器。 此外，在停止 PostgreSQL 时， 有必要先停止 Pgpool-II。 运行以下命令来启动或停止 Pgpool-II。
启动 pgpool-II
#systemctl start pgpool.service
停止 pgpool-II
#systemctl stop pgpool.service
1.3.7. 如何使用
配置完成后，让我们开始使用 Pgpool-II。
首先，让我们启动 Pgpool-II。
[server1]# systemctl start pgpool.service
1.3.7.1. 使用在线恢复创建 PostgreSQL 服务器
然后，我们使用在线恢复创建 PostgreSQL node1 和 node2。 确保 recovery_1st_stage、recovery_2nd_stage 和 pgpool_remote_start 命令使用的脚本pcp_recovery_node位于数据库中 cluster 目录。
[server1]# pcp_recovery_node -h server1 -p 9898 -U pgpool -n 1
Password:
pcp_recovery_node -- Command Successful
[server1]# pcp_recovery_node -h server1 -p 9898 -U pgpool -n 2
Password:
pcp_recovery_node -- Command Successful
如果 pcp_recovery_node 已成功运行， 验证 PostgreSQL node0 是否作为主节点启动， node1 和 node2 作为副本启动。
# psql -h server1 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | main | main | 0 | true | 0 | | | 2021-12-02 16:48:21
1 | server2 | 5432 | up | up | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:48:21
2 | server3 | 5432 | up | up | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:48:21
(3 rows)
1.3.7.2. 验证复制
接下来，让我们使用基准测试工具 pgbench 验证复制功能。
[server1]# /usr/pgsql-14/bin/createdb test -U postgres -p 9999
[server1]# /usr/pgsql-14/bin/pgbench -h server1 -U postgres -i -p 9999 test
要检查复制是否正常工作，请直接连接到每个 PostgreSQL server 查看它们是否返回相同的结果。
[server1]# /usr/pgsql-14/bin/psql -h server1 -U postgres -p 5432 test
test=# \d
List of relations
Schema | Name | Type | Owner
--------+------------------+-------+----------
public | pgbench_accounts | table | postgres
public | pgbench_branches | table | postgres
public | pgbench_history | table | postgres
public | pgbench_tellers | table | postgres
(4 rows)
[server1]# /usr/pgsql-14/bin/psql -h server2 -U postgres -p 5432 test
test=# \d
List of relations
Schema | Name | Type | Owner
--------+------------------+-------+----------
public | pgbench_accounts | table | postgres
public | pgbench_branches | table | postgres
public | pgbench_history | table | postgres
public | pgbench_tellers | table | postgres
(4 rows)
[server1]# /usr/pgsql-14/bin/psql -h server3 -U postgres -p 5432 test
test=# \d
List of relations
Schema | Name | Type | Owner
--------+------------------+-------+----------
public | pgbench_accounts | table | postgres
public | pgbench_branches | table | postgres
public | pgbench_history | table | postgres
public | pgbench_tellers | table | postgres
(4 rows)
server1、server2 和 server3 返回相同的结果。
接下来，让我们运行 pgbench 一段时间并检查结果。
[server1]# /usr/pgsql-14/bin/pgbench -h server1 -U postgres -p 9999 -T 10 test
所有 PostgreSQL 服务器返回相同的结果。
[server1]# /usr/pgsql-14/bin/psql -h server1 -U postgres -p 5432 test -c "SELECT sum(abalance) FROM pgbench_accounts"
Password for user postgres:
sum
--------
-99710
(1 row)
[server1]# /usr/pgsql-14/bin/psql -h server2 -U postgres -p 5432 test -c "SELECT sum(abalance) FROM pgbench_accounts"
Password for user postgres:
sum
--------
-99710
(1 row)
[server1]# /usr/pgsql-14/bin/psql -h server3 -U postgres -p 5432 test -c "SELECT sum(abalance) FROM pgbench_accounts"
Password for user postgres:
sum
--------
-99710
(1 row)
1.3.7.3. PostgreSQL 失败
接下来，停止 server1 上的 PostgreSQL 主节点 并验证主节点的切换。
[server1]# su - postgres -c "/usr/pgsql-14/bin/pg_ctl -m i stop"
在 server1 上停止 PostgreSQL 后， 发生切换，server2 上的 PostgreSQL 成为新的主节点。
[server1]# psql -h server1 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | down | down | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:57:45
1 | server2 | 5432 | up | up | 0.333333 | main | main | 1 | true | 0 | | | 2021-12-02 16:48:21
2 | server3 | 5432 | up | up | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:48:21
(3 rows)
1.3.7.4. 在线恢复
在这里，我们使用 Pgpool-II 在线恢复功能来 还原 server1 上的 PostgreSQL node0。
#pcp_recovery_node -h server1 -p 9898 -U pgpool -n 0
Password:
pcp_recovery_node – Command Successful
然后验证 server1 是否已作为主节点启动。
#psql -h server1 -p 9999 -U pgpool postgres -c "show pool_nodes"
Password for user pgpool:
node_id | hostname | port | status | pg_status | lb_weight | role | pg_role | select_cnt | load_balance_node | replication_delay | replication_state | replication_sync_state | last_status_change
---------+----------+------+--------+-----------+-----------+---------+---------+------------+-------------------+-------------------+-------------------+------------------------+---------------------
0 | server1 | 5432 | up | up | 0.333333 | main | main | 0 | true | 0 | | | 2021-12-02 16:57:45
1 | server2 | 5432 | up | up | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:48:21
2 | server3 | 5432 | up | up | 0.333333 | replica | replica | 0 | false | 0 | | | 2021-12-02 16:48:21
(3 rows)
1.4. AWS 配置示例
本教程演示了设置虚拟 IP 的示例 在 AWS 上使用 watch dog 时。
有几种方法可以在 AWS 上设置虚拟 IP。此示例描述了以下方法：
节 1.4.1分配弹性公网 IP
节 1.4.2更新路由表
1.4.1. 分配弹性 IP
本节介绍如何使用弹性 IP 地址作为虚拟 IP 并将其与领导者 Pgpool-II（看门狗）实例相关联。
1.4.1.1. AWS 设置
当使用这种方法时，假设 Pgpool-II EC2 实例被放置在一个公共子网中，并且客户端通过 Internet 连接到 Pgpool-II。该方法支持多个可用区。
在这个例子中，我们将使用三个节点 Pgpool-II（看门狗）集群。因此，我们将创建三个 EC2 实例和一个弹性 IP 地址。
完成以下步骤以设置 AWS：
启动三个 EC2 实例。
配置 Pgpool-II 实例的安全组。
允许 Pgpool-II 和看门狗使用的端口上的入站流量。
由于 Pgpool-II（看门狗）将 ping 虚拟 IP 以检查连接性， 允许来自弹性 IP（源）的入站 ICMP 流量。
在每个实例上安装 Pgpool-II。
AWS CLI 是 一种在 EC2 实例上管理 AWS 服务的工具。 在每个 Pgpool-II 实例上安装 AWS CLI。
此外，以 Pgpool-II 启动用户身份运行 aws configure 以创建配置和凭证文件，以便 Pgpool-II 启动用户可以运行 AWS CLI。 如果 Pgpool-II 是使用 RPM 软件包安装的，则 Pgpool-II 默认以 postgres 用户运行。
分配弹性 IP 地址。 在此示例中，我们将使用 “35.163.178.3”。
1.4.1.2. Pgpool-II 配置
本节介绍如何配置 pgpool-II。 主要是 Pgpool-II 的配置 example 将与 Section 1.2 中的内容相同，但 使用 if_up_cmd/if_down_cmd 为领导 Pgpool-II 实例分配/删除弹性 IP 地址。
指定要delegate_ip的弹性 IP 地址。
use_watchdog = on
delegate_ip = '35.163.178.3'
指定用于将弹性 IP 地址分配/删除给 if_up_cmd 和 if_down_cmd 的脚本。if_up_cmd 是看门狗执行的脚本，用于 当 watchdog 成为领导节点时，将弹性 IP 分配给实例。if_down_cmd 是 watchdog 执行的脚本，用于 当看门狗从领导节点退出时，从实例中删除弹性 IP。
if_up_cmd = '<path to script> up $_IP_$ <path to awscli>'
if_down_cmd = '<path to script> down $_IP_$ <path to awscli>'
<脚本路径>：指定用于分配或删除弹性 IP 地址的脚本的路径。
<aws cli 的路径>：指定 AWS CLI 命令的路径。
在此示例中，我们使用以下设置。将它们替换为您自己的设置。
if_up_cmd = '/etc/pgpool-II/aws_eip_if_cmd.sh up $_IP_$ /usr/local/bin/aws'
if_down_cmd = '/etc/pgpool-II/aws_eip_if_cmd.sh down $_IP_$ /usr/local/bin/aws'
由于 AWS 上不需要 arping，因此请将其设置为“true”以始终返回成功退出状态。
arping_cmd = 'true'
1.4.1.3. 弹性 IP 分配/删除脚本
在每个 Pgpool-II 实例上创建 if_up_cmd/if_down_cmd 执行的脚本。
在此示例中，我们使用示例脚本 aws_eip_if_cmd.sh。如有必要，请对其进行修改。
(run the following command on each Pgpool-II instance)
# cp -p /etc/pgpool-II/sample_scripts/aws_eip_if_cmd.sh.sample /etc/pgpool-II/aws_eip_if_cmd.sh
1.4.1.4. 试用
在每个 Pgpool-II 实例上启动 Pgpool-II。 尝试使用弹性 IP 地址连接到 Pgpool-II。
[user@someserver]$ psql -h 35.163.178.3 -p 9999 -U postgres -c "show pool_nodes"
停止领导者 Pgpool-II。 然后弹性 IP 地址被重新分配给新的领导者 pgpool-II。 验证你是否可以使用弹性 IP 地址连接到 Pgpool-II，即使领导 Pgpool-II 已经切换。
[user@someserver]$ psql -h 35.163.178.3 -p 9999 -U postgres -c "show pool_nodes"
1.4.2. 更新路由表
本节描述了如何控制领导者 Pgpool-II（看门狗）的路由 通过更新路由表条目。
在此方法中，私有 IP 地址用作虚拟 IP 并分配给 leader Pgpool-II 实例。如果发生故障转移，请重新分配虚拟 IP。 并将目标地址为虚拟 IP 的流量路由到新的领导 Pgpool-II 实例。
1.4.2.1. AWS 设置
使用此方法时，假设 Pgpool-II EC2 实例放置在私有子网中，并且客户端应用程序连接到同一 VPC 中的 Pgpool-II。此方法支持多个可用区。
在这个例子中，我们将使用三个节点 Pgpool-II（看门狗）集群。所以我们将创建三个 跨多个可用区的 EC2 实例。
完成以下步骤以设置 AWS：
创建一个具有 1 个公有子网和 3 个私有子网的 VPC， 并且每个私有子网位于不同的可用区中。 有关详细信息，请参阅文档。
创建两个与公有子网和私有子网关联的路由表 分别。有关详细信息，请参阅此文档。
在公有子网中启动一个应用程序 EC2 实例，然后 三个 Pgpool-II EC2 实例位于不同的私有子网中。
配置允许来自 VPC CIDR 块范围的流量的安全组 在 Pgpool-II 和 watchdog 使用的端口上。
在每个 Pgpool-II EC2 实例上安装 Pgpool-II。
AWS CLI 是 一种在 EC2 实例上管理 AWS 服务的工具。 在每个 Pgpool-II 实例上安装 AWS CLI。
此外，以 Pgpool-II 启动用户身份运行 aws configure 以创建配置和凭证文件，以便 Pgpool-II 启动用户可以运行 AWS CLI。 如果 Pgpool-II 是使用 RPM 软件包安装的，则 Pgpool-II 默认以 postgres 用户运行。
分配或删除虚拟 IP 地址需要 root 权限。 如果你以非 root 用户身份启动 Pgpool-II， 配置 sudoers 文件并允许此用户运行 sudo，而无需 要求输入密码。 如果 Pgpool-II 是使用 RPM 软件包安装的，则 PostgreSQL 用户的设置会自动添加到 Sudoers 中。
选择要用作虚拟 IP 的 IPv4 地址。 由于无法在多个子网之间重新分配辅助 IP 地址，因此 您需要选择一个不应属于的私有 IP 地址 VPC 的 IP 地址范围。 在此示例中，我们使用 “20.0.0.50”。
1.4.2.2. Pgpool-II 配置
本节介绍如何配置 pgpool-II。 主要是 Pgpool-II 的配置 example 将与 Section 1.2 中的内容相同，但 使用 if_up_cmd 和 if_down_cmd 分配虚拟 IP 并更新路由表。
指定要delegate_ip的虚拟 IP。
use_watchdog = on
delegate_ip = '20.0.0.50'
指定用于将路由表更新为 if_up_cmd 和 if_down_cmd 的脚本。if_up_cmd 是 watchdog 执行的脚本，用于 分配虚拟 IP 并在 Watchdog 成为领导节点时更新路由表。if_down_cmd 是 watchdog 执行的脚本，用于 当看门狗从领导节点退出时，删除虚拟 IP 并更新路由表。
if_up_cmd = '<path to script> up $_IP_$ <interface> <route table ID> <path to awscli>'
if_down_cmd = '<path to script> down $_IP_$ <interface> <route table ID> <path to awscli>'
<脚本路径>：指定用于分配虚拟 IP 和更新路由表的脚本路径。
：指定要分配虚拟 IP 的网络接口。
<路由表 ID>： 指定要更新的路由表 ID（例如客户端应用程序或 Pgpool-II 实例）。 您可以指定多个以逗号分隔的路由表 ID。
<aws cli 的路径>：指定 AWS CLI 命令的路径。
在此示例中，我们使用以下设置。将它们替换为您自己的设置。 指定与应用程序所在的公有子网关联的路由表 ID EC2 实例位于 Pgpool-II EC2 实例所在的私有子网。
if_up_cmd = '/etc/pgpool-II/aws_rtb_if_cmd.sh up $_IP_$ eth0 rtb-012345abcd,rtb-67890abcd /usr/local/bin/aws'
if_down_cmd = '/etc/pgpool-II/aws_rtb_if_cmd.sh down $_IP_$ eth0 rtb-012345abcd,rtb-67890abcd /usr/local/bin/aws'
由于 AWS 上不需要 arping，因此请将其设置为“true”以始终返回成功退出状态。
arping_cmd = 'true'
1.4.2.3. 路由表更新脚本
在每个 Pgpool-II 实例上创建 if_up_cmd/if_down_cmd 执行的脚本。
在此示例中，我们使用示例脚本 aws_rtb_if_cmd.sh。如有必要，请对其进行修改。
(run the following command on each Pgpool-II instance)
# cp -p /etc/pgpool-II/sample_scripts/aws_rtb_if_cmd.sh.sample /etc/pgpool-II/aws_rtb_if_cmd.sh
1.4.2.4. 禁用源/目标检查
AWS EC2 实例检查收到的任何 traffics 的 Traffic。你必须在每个 Pgpool-II 实例上禁用源/目标检查，以路由虚拟 IP 的流量 添加到目标实例中。
在所有 Pgpool-II 实例的网络接口设置中禁用 “source/destination check”。 它可以通过 AWS 管理控制台进行配置 或使用 AWS CLI。使用 AWS CLI 时，请执行以下命令。 将 LOCAL_INTERFACE 设置为将添加虚拟 IP 的网络接口。 在这个例子中，我们使用 eth0。
$ sudo su - postgres
$ TOKEN=$(curl -sX PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
$ LOCAL_INTERFACE=eth0
$ MAC_ADDR=$(ip -br link show dev ${LOCAL_INTERFACE} | tr -s ' ' | cut -d ' ' -f3)
$ EC2_NETWORK_INTERFACE_ID=$(curl -H "X-aws-ec2-metadata-token: ${TOKEN}" -s http://169.254.169.254/latest/meta-data/network/interfaces/macs/${MAC_ADDR}/interface-id)
$ aws ec2 modify-network-interface-attribute --network-interface-id ${EC2_NETWORK_INTERFACE_ID} --no-source-dest-check
1.4.2.5. 试用
在每个 Pgpool-II 实例上启动 Pgpool-II。 尝试使用虚拟 IP 连接到 Pgpool-II 从应用程序实例。
[user@application instance]$ psql -h 20.0.0.50 -p 9999 -U postgres -c "show pool_nodes"
停止领导者 Pgpool-II。 然后虚拟 IP 被重新分配给新的领导 Pgpool-II。 验证您可以使用应用程序实例的弹性 IP 地址连接到 Pgpool-II，即使领导 Pgpool-II 已经切换。
[user@application instance]$ psql -h 20.0.0.50 -p 9999 -U postgres -c "show pool_nodes"
1.5. Aurora 配置示例
适用于 PostgreSQL 的 Amazon Aurora 兼容性 （Aurora） 是 PostgreSQL 的托管服务。从用户的角度来看 view 中，Aurora 可以看作是一个 流式复制集群，但有一些例外。第一 管理 Failover Over 和 Online Recovery 由 Aurora 提供。所以你不需要 set failover_command、 follow_primary_command、 以及与恢复相关的参数。在本节中，我们将解释 如何为 Aurora 设置 Pgpool-II。
1.5.1. 为 Aurora 设置 pgpool.conf
从 pgpool.conf.sample 创建 pgpool.conf。 确保你的 pgpool.conf 包含以下行：
backend_clustering_mode = 'streaming_replication'
将 sr_check_period 设置为 0 到 禁用流复制延迟检查。这 是因为 Aurora 确实 没有提供必要的函数来检查 复制延迟。
sr_check_period = 0
启用 enable_pool_hba 以启用，以便打开 已启用 MD5 身份验证 （Aurora 始终使用 md5 authentication） 的 Authentication）。
enable_pool_hba = on
创建 pool_password。有关更多详细信息，请参见 Section 6.2.3 。
将 Aurora集群终端节点的 backend_hostname 设置为 0。 将 Aurora读取器终端节点backend_hostname 1。 像往常一样设置适当的backend_weight。 您无需设置backend_data_directory。
backend_hostname0 = 'cluster endpoint'
backend_hostname1 = 'reader endpoint'
将 ALWAYS_PRIMARY flag 设置为 backend_hostname0 的 backend_flag。
由于故障转移由 Aurora 管理，因此DISALLOW_TO_FAILOVER标志设置为 backend_hostname0 和 backend_hostname1 的backend_flag。
backend_flag0 = 'ALWAYS_PRIMARY|DISALLOW_TO_FAILOVER'
backend_flag1 = 'DISALLOW_TO_FAILOVER'
将 health_check_period 设置为 0 以禁用运行状况检查。
health_check_period = 0
禁用 failover_on_backend_error 以避免在连接到后端时进行故障转移，或者 执行时检测后端错误 查询。
