PolarDB 开源基础教程系列 3 安装部署-阿里云开发者社区

PolarDB 安装部署

本节阅读导航

0、人肉部署PolarDB数据库实例单机版

1、安装部署 PolarDB 单机版

2、安装部署 PolarDB 集群版(on ECS + ESSD)

3、更多部署环境

0、人肉部署PolarDB数据库实例单机版

手工初始化PolarDB数据库实例单机版(其实非严格意义的单机版, 还是把共享数据和计算节点数据拆成了2个目录.)

如果你想使用单机版, 尽量使用polardb_pg_local_instance镜像. 下面为了帮助大家理解初始化过程, 使用polardb_pg_binary分解演示初始化实例的过程.

拉取镜像

# 公开课系列采用PolarDB 11版本, 因为目前PolarDB 15版本还有一些功能还没有开源(例如mpp)无法进行学习  
docker pull registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_binary:11  
  
# 方便后续使用 polardb/polardb_pg_binary, 打个标记  
docker tag registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_binary:11 polardb/polardb_pg_binary

启动容器, 将数据放在宿主机中

mkdir ~/pb_local_single  
cd ~/pb_local_single  
POLAR_DATA_DIR=/var/polardb  
  
docker run -it -P -d \
    --cap-add=SYS_PTRACE \
    --cap-add SYS_ADMIN \
    --privileged=true \
    --name pb_local_single \
    --shm-size=1g \
    -v ${PWD}:${POLAR_DATA_DIR} \
    polardb/polardb_pg_binary

前面提到: 部署单机版, 建议尽量使用polardb_pg_local_instance镜像, 因为接下来的初始化过程还是参考了polardb_pg_local_instance镜像里的docker-entrypoint.sh

进入容器

docker exec -ti pb_local_single bash

初始化实例

POLAR_DATA_DIR=/var/polardb  
echo "POLAR_DATA_DIR=/var/polardb" >> ~/.bashrc  
echo "export PGDATA=\${POLAR_DATA_DIR}/primary" >> ~/.bashrc  
. ~/.bashrc  
  
initdb -k -U postgres -D ${POLAR_DATA_DIR}/primary

配置参数

echo "  
max_connections = 100  
polar_wal_pipeline_enable = true  
polar_create_table_with_full_replica_identity = off  
logging_collector = on  
log_directory = 'pg_log'  
shared_buffers = '1GB'  
synchronous_commit = on  
full_page_writes = off  
autovacuum_naptime = 10min  
max_worker_processes = 32  
polar_use_statistical_relpages = off  
polar_enable_persisted_buffer_pool = off  
polar_nblocks_cache_mode = 'all'  
polar_enable_replica_use_smgr_cache = on  
polar_enable_standby_use_smgr_cache = on  
polar_enable_flashback_log = on  
polar_enable_fast_recovery_area = on  
polar_vfs.localfs_mode = true  
polar_enable_localfs_test_mode = on  
polar_enable_shared_storage_mode = on  
listen_addresses = '0.0.0.0'  
polar_disk_name = 'var'  
polar_datadir = 'file-dio://${POLAR_DATA_DIR}/shared_datadir'  
shared_preload_libraries = 'polar_px,polar_vfs,polar_worker,pg_stat_statements,auth_delay,auto_explain,polar_monitor_preload,polar_stat_sql,timescaledb'  
port = 5432  
polar_hostid = 1  
polar_enable_px=0  
polar_px_enable_check_workers=0  
polar_px_enable_replay_wait=1  
polar_px_dop_per_node=3  
polar_px_max_workers_number=0  
polar_px_enable_cte_shared_scan=1  
polar_px_enable_partition=1  
polar_px_enable_left_index_nestloop_join=1  
polar_px_wait_lock_timeout=1800000  
polar_px_enable_partitionwise_join=1  
polar_px_optimizer_multilevel_partitioning=1  
polar_px_max_slices=1000000  
polar_px_enable_adps=1  
polar_px_enable_adps_explain_analyze=1  
polar_trace_heap_scan_flow=1  
polar_px_enable_spi_read_all_namespaces=1  
" >> ${POLAR_DATA_DIR}/primary/postgresql.conf  
  
echo "  
host  all all 0.0.0.0/0 md5  
" >> ${POLAR_DATA_DIR}/primary/pg_hba.conf  
  
echo "  
primary_conninfo = 'host=127.0.0.1 port=5432 user=postgres dbname=postgres application_name=replica1'  
primary_slot_name = 'replica1'  
polar_replica = on  
recovery_target_timeline = 'latest'  
" > ${POLAR_DATA_DIR}/primary/recovery.done

将共享数据从计算节点数据目录中剥离出去

mkdir ${POLAR_DATA_DIR}/shared_datadir/  
polar-initdb.sh ${POLAR_DATA_DIR}/primary/ ${POLAR_DATA_DIR}/shared_datadir/ localfs

启动PolarDB

pg_ctl start

此时只有一个RW节点, 存储如下:

计算节点数据文件目录 ${POLAR_DATA_DIR}/primary/
共享数据目录 ${POLAR_DATA_DIR}/shared_datadir/

$ psql  
psql (11.9)  
Type "help" for help.  
  
postgres=# select version();  
            version               
--------------------------------  
 PostgreSQL 11.9 (POLARDB 11.9)  
(1 row)  
postgres=# create table test (id int);  
CREATE TABLE  
postgres=# insert into test select generate_series(1,100);  
INSERT 0 100

1、安装部署 PolarDB 单机版

提示, 本文安装PolarDB都使用了阿里云预制docker镜像, 如果你想在物理机或ecs层面安装PolarDB, 有很多依赖包要安装, 不过不用担心, 可以参考PolarDB docker image制作文件Dockerfile, 支持大多数操作系统:

https://github.com/ApsaraDB/polardb-pg-docker-images/tree/main

ubuntu24.04: use ubuntu:24.04 as base OS
ubuntu22.04: use ubuntu:22.04 as base OS
ubuntu20.04: use ubuntu:20.04 as base OS
debian12: use debian:12 as base OS
debian11: use debian:11 as base OS
rocky9: use rockylinux:9 as base OS
rocky8: use rockylinux:8 as base OS
anolis8: use openanolis/anolisos:8.6 as base OS
centos7 (DEPRECATED): use centos:centos7 as base OS

PS:

前置条件, 请在本机先安装docker desktop.
注意将文中命令内出现的${your_data_dir}替换为你实际的目录全路径.

在单机文件系统（如 ext4）上部署 PolarDB-PG，适用于所有PolarDB计算节点都可以访问相同本地磁盘存储的场景。

单机版通常用于快速搭建PolarDB学习或开发环境.

1.1、拉取镜像

我们在 DockerHub 上提供了 PolarDB-PG 的本地实例镜像，里面已包含启动 PolarDB-PG 本地存储实例的入口脚本。镜像目前支持 linux/amd64 和 linux/arm64 两种 CPU 架构。

# 公开课系列采用PolarDB 11版本, 因为目前PolarDB 15版本还有一些功能还没有开源(例如mpp)无法进行学习
docker pull registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_local_instance:11
# 方便后续使用polardb/polardb_pg_local_instance, 打个标记
docker tag registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_local_instance:11 polardb/polardb_pg_local_instance

1.2、初始化数据库

在本机新建一个空白目录 ${your_data_dir} 作为 PolarDB-PG 实例的数据目录。启动容器时，将该目录作为 VOLUME 挂载到容器内，对数据目录进行初始化。在初始化的过程中，可以传入环境变量覆盖默认值：

POLARDB_PORT：PolarDB-PG 运行所需要使用的端口号，默认值为 5432；镜像将会使用三个连续的端口号（默认 5432-5434）
POLARDB_USER：初始化数据库时创建默认的 superuser（默认 postgres）
POLARDB_PASSWORD：默认 superuser 的密码

还可以传入其他变量(POLARDB_USER,POLARDB_PASSWORD,POLARDB_PORT,POLARDB_DATA_DIR,PGHOST), 有一些变量在docker-entrypoint.sh中会被用到. 可参考该镜像的Dockerfile: https://github.com/ApsaraDB/polardb-pg-docker-images/blob/main/Dockerfile-local-instance

ARG binary_image_tag=
FROM polardb/polardb_pg_binary:${binary_image_tag}
LABEL maintainer="mrdrivingduck@gmail.com"
ENV POLARDB_USER=
ENV POLARDB_PASSWORD=
ENV POLARDB_PORT=
ENV POLARDB_DATA_DIR=/var/polardb
ENV PGHOST=127.0.0.1
VOLUME ${POLARDB_DATA_DIR}
CMD [ "postgres" ]
WORKDIR /home/postgres/
COPY ./docker-entrypoint.sh ./docker-entrypoint.sh
ENTRYPOINT [ "./docker-entrypoint.sh" ]

使用如下命令初始化数据库(--rm表示执行后自动删除容器, 但是VOLUME目录由于在宿主机中, 所以其数据会被保留, 把VOLUME映射到POLARDB_DATA_DIR即可实现初始化数据库实例目的.)：

docker run -it --rm \
    --env POLARDB_PORT=5432 \
    --env POLARDB_USER=u1 \
    --env POLARDB_PASSWORD=your_password \
    -v ${your_data_dir}:/var/polardb \
    polardb/polardb_pg_local_instance \
    echo 'done'

例如:

mkdir /Users/digoal/polardb_data
cd /Users/digoal/polardb_data
docker run -it --rm \
    --env POLARDB_PORT=5432 \
    --env POLARDB_USER=postgres \
    --env POLARDB_PASSWORD=hellopwd123 \
    -v ${PWD}:/var/polardb \
    polardb/polardb_pg_local_instance \
    echo 'done'

1.3、启动 PolarDB-PG 服务

数据库初始化完毕后，使用 -d 参数以后台模式创建容器，启动 PolarDB-PG 服务。通常 PolarDB-PG 的端口需要暴露给外界使用，使用 -p 参数将容器内的端口范围暴露到容器外。比如，初始化数据库时使用的是 5432-5434 端口，如下命令将会把这三个端口映射到容器外的 54320-54322 端口：

docker run -it -d \
    --cap-add=SYS_PTRACE \
    --cap-add SYS_ADMIN \
    --privileged=true \
    --name polardb_pg \
    --shm-size=1g \
    -p 54320-54322:5432-5434 \
    -v ${your_data_dir}:/var/polardb \
    polardb/polardb_pg_local_instance

或者也可以直接让容器与宿主机共享网络(注意network=host会和宿主机共享网络, 如果你想在同一个宿主机运行多个容器, 监听端口请错开, 否则会端口冲突.)：

docker run -it -P -d \
    --cap-add=SYS_PTRACE \
    --cap-add SYS_ADMIN \
    --privileged=true \
    --name polardb_pg \
    --shm-size=1g \
    --network=host \
    -v ${your_data_dir}:/var/polardb \
    polardb/polardb_pg_local_instance

例如:

mkdir /Users/digoal/polardb_data
cd /Users/digoal/polardb_data
docker run -it -P -d \
    --cap-add=SYS_PTRACE \
    --cap-add SYS_ADMIN \
    --env POLARDB_PORT=5432 \
    --env POLARDB_USER=postgres \
    --env POLARDB_PASSWORD=hellopwd123 \
    --privileged=true \
    --name polardb_pg \
    --shm-size=1g \
    --network=host \
    -v ${PWD}:/var/polardb \
    polardb/polardb_pg_local_instance

进入该容器, 从docker-entrypoint.sh脚本可以了解到polardb/polardb_pg_local_instance会创建2个replica.

$ docker exec -ti polardb_pg bash
$ psql
psql (11.9)
Type "help" for help.
postgres=# select * from pg_stat_replication ;
 pid | usesysid | usename  | application_name | client_addr | client_hostname | client_port |         backend_start         | backend_xmin |   state   | sent_lsn  | write_lsn | flush_lsn | replay_lsn | 
write_lag | flush_lag | replay_lag | sync_priority | sync_state 
-----+----------+----------+------------------+-------------+-----------------+-------------+-------------------------------+--------------+-----------+-----------+-----------+-----------+------------+-
----------+-----------+------------+---------------+------------
 171 |       10 | postgres | replica1         | 127.0.0.1   |                 |       61490 | 2025-01-17 09:34:54.643504+08 |              | streaming | 0/174E210 | 0/174E210 | 0/174E210 | 0/174E210  | 
          |           |            |             0 | async
 189 |       10 | postgres | replica2         | 127.0.0.1   |                 |       61502 | 2025-01-17 09:34:56.008966+08 |              | streaming | 0/174E210 | 0/174E210 | 0/174E210 | 0/174E210  | 
          |           |            |             0 | async
(2 rows)
postgres=# select version();
            version             
--------------------------------
 PostgreSQL 11.9 (POLARDB 11.9)
(1 row)

2、安装部署 PolarDB 集群版(on ECS + ESSD)

PS: 前置条件

ECS 的系统选择Linux, 最好选择PolarDB已支持的系统, 例如Debian 11 12, Ubuntu 20.04 22.04 24.04, anolis8, rocky 8 9.
需要在ECS系统中安装docker server/desktop, 以便运行打包好的 pfs/PolarDB 容器. 注意Docker不是必须的! 只是为了学习方便. 如果你需要在物理机或ECS中直接部署PolarDB, 可以参考《PolarDB 100 问 | 如何构建PolarDB Docker镜像 OR 本地编译PolarDB?》对应操作系统Dockerfile的内容, 把依赖包装好就可以编译PolarDB源码.

阿里云 ESSD（Enhanced SSD）云盘结合 25 GE 网络和 RDMA 技术，能够提供单盘高达 100 万的随机读写能力和单路低时延性能。阿里云 ESSD 云盘支持 NVMe 协议，且可以同时挂载到多台支持 NVMe 协议的 ECS（Elastic Compute Service）实例上，从而实现多个 ECS 实例并发读写访问，具备高可靠、高并发、高性能等特点。更新信息请参考阿里云 ECS 文档：

接下来指导您完成以下过程：

1、部署两台阿里云 ECS 作为计算节点
2、将一块 ESSD 云盘多重挂载到两台 ECS 上，作为共享存储
3、在任意一台ECS上将 ESSD 共享存储格式化为分布式文件系统 PFS
4、基于 PFS，在两台 ECS 上共同搭建一个存算分离、读写分离的 PolarDB 集群

2.1、部署阿里云 ECS

首先需要准备两台或以上的阿里云 ECS。目前，ECS 对支持 ESSD 多重挂载的规格有较多限制，详情请参考使用限制。仅部分可用区、部分规格（ecs.g7se、ecs.c7se、ecs.r7se, 现在可能更多型号了, 具体参考阿里云文档.）的 ECS 实例可以支持 ESSD 的多重挂载。如图，请务必选择支持多重挂载的 ECS 规格：

对 ECS 存储配置的选择，系统盘可以选用任意的存储类型，数据盘和共享盘暂不选择。后续再单独创建一个 ESSD 云盘作为共享盘：

如图所示，在同一可用区中建好两台 ECS：

2.2、准备 ESSD 云盘

在阿里云 ECS 的管理控制台中，选择 存储与快照 下的云盘，点击创建云盘。在与已经建好的 ECS 所在的相同可用区内，选择建立一个 ESSD 云盘，并勾选多实例挂载。如果您的 ECS 不符合多实例挂载的限制条件，则该选框不会出现。

ESSD 云盘创建完毕后，控制台显示云盘支持多重挂载，状态为待挂载：

接下来，把这个云盘分别挂载到两台 ECS 上：

挂载完毕后，查看该云盘，将会显示该云盘已经挂载的两台 ECS 实例：

2.3、检查云盘

通过 ssh 分别连接到两台 ECS 上，运行 lsblk 命令可以看到：

nvme0n1 是 40GB 的 ECS 系统盘，为 ECS 私有
nvme1n1 是 100GB 的 ESSD 云盘，两台 ECS 同时可见

$ lsblk  
NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT  
nvme0n1     259:0    0   40G  0 disk  
└─nvme0n1p1 259:1    0   40G  0 part /etc/hosts  
nvme1n1     259:2    0  100G  0 disk

2.4、准备分布式文件系统(PFS)

2.4.1、PFS 编译安装

接下来，将在两台 ECS 上分别部署 PolarDB 的主节点和只读节点。作为前提，需要在 ECS 共享的 ESSD 块设备上格式化并挂载 PFS。

请先在ECS主机上安装Docker desktop/server. 具体步骤请参考docker官网文档( https://www.docker.com/ ), 书中略过.

拉取polardb_pg_binary镜像, 将在所有PolarDB计算节点(ECS)使用这个镜像的容器来运行pfs和数据库.

docker pull registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_binary:11
# 打个tag, 方便使用
docker tag registry.cn-hangzhou.aliyuncs.com/polardb_pg/polardb_pg_binary:11 polardb/polardb_pg_binary

在所有PolarDB计算节点(ECS) 启动容器

docker run -d -it --network=host \
    --cap-add=SYS_PTRACE --cap-add SYS_ADMIN \
    --privileged=true \
    --name polardb_pg \
    --shm-size=1g \
    polardb/polardb_pg_binary \
    /bin/bash

在PolarDB计算节点(ECS) 进入容器的方法:

docker exec -ti polardb_pg bash

2.4.2、块设备重命名(如果命名已符合pfs需求, 可略过. 例如 本节on ECS+ESSD 可略过该步骤.)

PFS 仅支持访问以特定字符开头的块设备（详情可见 PolarDB File System 源代码的 src/pfs_core/pfs_api.h 文件）：

#define PFS_PATH_ISVALID(path)                                  \
    (path != NULL &&                                            \
     ((path[0] == '/' && isdigit((path)[1])) || path[0] == '.'  \
      || strncmp(path, "/pangu-", 7) == 0                       \
      || strncmp(path, "/sd", 3) == 0                           \
      || strncmp(path, "/sf", 3) == 0                           \
      || strncmp(path, "/vd", 3) == 0                           \
      || strncmp(path, "/nvme", 5) == 0                         \
      || strncmp(path, "/loop", 5) == 0                         \
      || strncmp(path, "/mapper_", 8) ==0))

因此，为了保证能够顺畅完成后续流程，建议在所有访问块设备的节点上使用相同的软链接访问共享块设备。例如，在 NBD 服务端主机上，使用新的块设备名 /dev/nvme1n1 软链接到共享存储块设备的原有名称 /dev/vdb 上：

sudo ln -s /dev/vdb /dev/nvme1n1

在 NBD 客户端主机(PolarDB计算节点)上，使用同样的块设备名 /dev/nvme1n1 软链到共享存储块设备的原有名称 /dev/nbd0 上：

sudo ln -s /dev/nbd0 /dev/nvme1n1

这样便可以在服务端和客户端两台主机上使用相同的块设备名 /dev/nvme1n1 访问同一个块设备。

2.4.3、块设备格式化

使用任意一台主机的容器，在共享存储块设备上格式化 PFS 分布式文件系统：

sudo pfs -C disk mkfs nvme1n1
OR
sudo pfs -C disk mkfs -f nvme1n1  # 强制格式化, 一般不建议. 如果以前这个盘已经被格式化过并且是其他实例的块设备, 可能被误格式化掉.

PS: 格式化 PFS 分布式文件系统仅需在集群中任意一个计算节点执行一次即可.

2.4.4、PFS 文件系统挂载

在能够访问共享存储的 所有主机节点的容器中 上分别启动 PFS 守护进程，挂载 PFS 文件系统：

sudo /usr/local/polarstore/pfsd/bin/start_pfsd.sh -p nvme1n1 -w 2
# -w 2 表示pfsd的工作线程数, 越大可以获得越好的IO能力, 但是也会消耗更多的CPU资源.
# 建议根据服务器规格、共享存储的硬件配置、存储网络带宽等情况来进行配置.

2.5、PolarDB 读写节点部署

在作为PolarDB RW节点的主机的容器中进行部署.

初始化读写节点的本地数据目录 ~/primary/：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/initdb -D $HOME/primary

在共享存储的 /nvme1n1/shared_data/ 路径上创建共享数据目录，然后使用 polar-initdb.sh 脚本初始化共享数据目录：

# 使用 pfs 创建共享数据目录  
sudo pfs -C disk mkdir /nvme1n1/shared_data  
# 初始化 db 的本地和共享数据目录  
sudo $HOME/tmp_basedir_polardb_pg_1100_bld/bin/polar-initdb.sh \
    $HOME/primary/ /nvme1n1/shared_data/

编辑读写节点的配置。打开 ~/primary/postgresql.conf，增加配置项：

echo "
port=5432  
polar_hostid=1  
polar_enable_shared_storage_mode=on  
polar_disk_name='nvme1n1'  
polar_datadir='/nvme1n1/shared_data/'  
polar_vfs.localfs_mode=off  
shared_preload_libraries='\$libdir/polar_vfs,\$libdir/polar_worker'  
polar_storage_cluster_name='disk'  
logging_collector=on  
log_line_prefix='%p\t%r\t%u\t%m\t'  
log_directory='pg_log'  
listen_addresses='*'  
max_connections=1000  
# synchronous_standby_names='replica1' 
" >> ~/primary/postgresql.conf

编辑读写节点的客户端认证文件 ~/primary/pg_hba.conf，增加以下配置项，允许只读节点进行物理复制：

echo "
host  replication postgres  0.0.0.0/0 trust
" >> ~/primary/pg_hba.conf
# 注意, 如果你知道ECS主机的网段, 建议把 0.0.0.0/0 配置为ECS主机的网段网段. 例如 192.168.1.0/24

插入知识点开始.

在不同主机上的容器之间的通信问题请参考:

https://superuser.com/questions/1141553/communication-between-docker-containers-on-differents-hosts-in-the-same-local-ne

要使 Docker 容器在不同主机上彼此之间通过 IP 网络互相访问，你需要设置一个跨主机的网络。Docker 的内置解决方案是使用 overlay 网络。Overlay 网络允许容器分布在多个 Docker 守护进程主机上，并且这些容器能够安全地相互通信。

以下是设置容器跨主机通信的步骤：

2.5.1、安装 Docker Engine

确保所有的主机上都安装了 Docker Engine，并且版本都是 1.12 或更高。

2.5.2、设置 Docker Swarm

Overlay 网络需要 Docker Swarm，所以你要初始化 Swarm 模式。

在你选定的第一个主机（Manager Node）上运行：

docker swarm init --advertise-addr <MANAGER-IP>

其中 <MANAGER-IP> 是该主机的 IP 地址。

初始化 Swarm 之后，将其他主机加入为 Worker Nodes：

docker swarm join --token <SWARM-TOKEN> <MANAGER-IP>:2377

<SWARM-TOKEN> 通过在 Manager Node 上运行 docker swarm join-token worker 获得。

2.5.3、创建 Overlay 网络

在任何一个 Swarm Manager 上创建一个 overlay 网络：

docker network create --driver overlay --attachable my-overlay-network

这里 my-overlay-network 是你为 overlay 网络自定义的名称，使用 --attachable 参数允许非 Swarm 服务的容器连接到这个网络。

2.5.4、运行容器并加入网络

在任何 Swarm 节点上启动你的容器，并将其连接到先前创建的 overlay 网络：

docker run -d --name my-container --network my-overlay-network my-image

这里 my-container 是为你的容器指定的名字，my-image 是你容器的镜像。

2.5.5、容器间通信

容器现在可以使用容器名称作为主机名来互相通信。例如，如果你在 my-overlay-network 网络上启动了两个名为 container1 和 container2 的容器，那么 container1 可以通过 container2 的名称来解析 container2 的 IP 地址。

请注意，这些步骤假设所有的主机都能够相互访问。如果你的主机在不同的网络中，例如它们之间受到防火墙或者 NAT 的限制，你可能需要进行一些额外的网络配置，比如设置适当的防火墙规则或者使用 VPN 等。

另外，如果你使用的是 Docker Desktop（如在 Windows 或 Mac 上），Swarm 和 Overlay 网络的设置可能会有一些不同，因为 Docker Desktop 附带了一个内置的虚拟化环境。

插入知识点结束.

最后，启动读写节点：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/pg_ctl start -D $HOME/primary

检查读写节点能否正常运行：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/psql \
    -p 5432 \
    -d postgres \
    -c 'SELECT version();'  
            version  
--------------------------------  
 PostgreSQL 11.9 (POLARDB 11.9)  
(1 row)

在读写节点上，为对应的只读节点创建相应的复制槽，用于只读节点的物理复制：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/psql \
    -p 5432 \
    -d postgres \
    -c "SELECT pg_create_physical_replication_slot('replica1');"  
 pg_create_physical_replication_slot  
-------------------------------------  
 (replica1,)  
(1 row)

2.6、PolarDB 只读节点部署

在作为PolarDB RO节点的主机的容器中进行部署.

在只读节点本地磁盘的 ~/replica1 路径上创建一个空目录，然后通过 polar-replica-initdb.sh 脚本使用共享存储上的数据目录来初始化只读节点的本地目录。初始化后的本地目录中没有默认配置文件，所以还需要使用 initdb 创建一个临时的本地目录模板，然后将所有的默认配置文件拷贝到只读节点的本地目录下：

mkdir -m 0700 $HOME/replica1  
sudo ~/tmp_basedir_polardb_pg_1100_bld/bin/polar-replica-initdb.sh \
    /nvme1n1/shared_data/ $HOME/replica1/  
  
$HOME/tmp_basedir_polardb_pg_1100_bld/bin/initdb -D /tmp/replica1  
cp /tmp/replica1/*.conf $HOME/replica1/
rm -rf /tmp/replica1

编辑只读节点的配置。打开 ~/replica1/postgresql.conf，增加配置项：

echo "
port=5433  
polar_hostid=2  
polar_enable_shared_storage_mode=on  
polar_disk_name='nvme1n1'  
polar_datadir='/nvme1n1/shared_data/'  
polar_vfs.localfs_mode=off  
shared_preload_libraries='\$libdir/polar_vfs,\$libdir/polar_worker'  
polar_storage_cluster_name='disk'  
logging_collector=on  
log_line_prefix='%p\t%r\t%u\t%m\t'  
log_directory='pg_log'  
listen_addresses='*'  
max_connections=1000
" >> ~/replica1/postgresql.conf

创建只读节点的复制配置文件 ~/replica1/recovery.conf，增加读写节点的连接信息，以及复制槽名称：

RW_HOST=[读写节点所在IP]
echo "
polar_replica='on'  
recovery_target_timeline='latest'  
primary_slot_name='replica1'  
primary_conninfo='host=${RW_HOST} port=5432 user=postgres dbname=postgres application_name=replica1'
" >> ~/replica1/recovery.conf

最后，启动只读节点：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/pg_ctl start -D $HOME/replica1

检查只读节点能否正常运行：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/psql \
    -p 5433 \
    -d postgres \
    -c 'SELECT version();'  
            version  
--------------------------------  
 PostgreSQL 11.9 (POLARDB 11.9)  
(1 row)

2.7、PolarDB 集群检查和测试

部署完成后，需要进行实例检查和测试，确保读写节点可正常写入数据、只读节点可以正常读取。

登录读写节点，创建测试表并插入样例数据：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/psql -q \
    -p 5432 \
    -d postgres \
    -c "CREATE TABLE t (t1 INT PRIMARY KEY, t2 INT); INSERT INTO t VALUES (1, 1),(2, 3),(3, 3);"

登录只读节点，查询刚刚插入的样例数据：

$HOME/tmp_basedir_polardb_pg_1100_bld/bin/psql -q \
    -p 5433 \
    -d postgres \
    -c "SELECT * FROM t;"  
 t1 | t2  
----+----  
  1 |  1  
  2 |  3  
  3 |  3  
(3 rows)

在读写节点上插入的数据对只读节点可见，这意味着基于共享存储的 PolarDB 计算节点集群搭建成功。

3、更多部署环境

编译安装PolarDB软件, 以debian 11.x为例, 这两个镜像中已经包含了编译安装的PolarDB软件.

阿里云开源了dockerfile, 你可以根据操作系统的版本选择dockerfile查看它需要安装哪些依赖, 方便你在自己的OS中部署PolarDB:

https://github.com/ApsaraDB/polardb-pg-docker-images

ubuntu24.04: use ubuntu:24.04 as base OS
ubuntu22.04: use ubuntu:22.04 as base OS
ubuntu20.04: use ubuntu:20.04 as base OS
debian12: use debian:12 as base OS
debian11: use debian:11 as base OS
rocky9: use rockylinux:9 as base OS
rocky8: use rockylinux:8 as base OS
anolis8: use openanolis/anolisos:8.6 as base OS
centos7 (DEPRECATED): use centos:centos7 as base OS

详见: 《PolarDB 100 问 | 如何构建PolarDB Docker镜像 OR 本地编译PolarDB?》

X86_64 安装方法例子如下:

useradd -b /home/polardb -m -d /home/polardb -s /bin/bash polardb
apt-get install -y libldap2-dev libxerces-c-dev gettext tcl tcl-dev libperl-dev 
rm -f /usr/bin/python 
ln -s /usr/bin/python3 /usr/bin/python 
cd /tmp
git clone -b POLARDB_11_STABLE --depth 1 https://github.com/ApsaraDB/PolarDB-for-PostgreSQL
cd PolarDB-for-PostgreSQL
LLVM_CONFIG=/usr/bin/llvm-config-13 ./polardb_build.sh --withpx --noinit --basedir=/home/polardb/polardb_11_home
echo "#  add by digoal " >> /home/polardb/.bashrc
echo "alias rm='rm -i' " >> /home/polardb/.bashrc
echo "alias cp='cp -i' " >> /home/polardb/.bashrc
echo "alias ll='ls -larth' " >> /home/polardb/.bashrc
echo "alias mv='mv -i' " >> /home/polardb/.bashrc
echo "export PGHOME=/home/polardb/polardb_11_home " >> /home/polardb/.bashrc
echo "export PATH=\$PGHOME/bin:\$PATH " >> /home/polardb/.bashrc
# X86 
echo "export LD_LIBRARY_PATH=\$PGHOME/lib:/usr/local/lib:/usr/lib/x86_64-linux-gnu:\$LD_LIBRARY_PATH " >> /home/polardb/.bashrc
# ARM64
# echo "export LD_LIBRARY_PATH=\$PGHOME/lib:/usr/local/lib:/usr/lib/aarch64-linux-gnu:\$LD_LIBRARY_PATH " >> /home/polardb/.bashrc
echo "export PGDATA=/home/polardb/primary " >> /home/polardb/.bashrc
echo "export PGUSER=polardb " >> /home/polardb/.bashrc
echo "export PGHOST=\$PGDATA " >> /home/polardb/.bashrc
echo "export PGPORT=5432 " >> /home/polardb/.bashrc
echo "export PGDATABASE=postgres " >> /home/polardb/.bashrc
echo "export LC_ALL=en_US.UTF-8 " >> /home/polardb/.bashrc
# 初始化数据库实例
su - polardb -c " /home/polardb/polardb_11_home/bin/initdb -D /home/polardb/primary "
# 启动数据库
# su - polardb
# /home/polardb/polardb_11_home/bin/pg_ctl -D /home/polardb/primary -l logfile start
# 进入数据库SQL Shell
# su - polardb
# /home/polardb/polardb_11_home/bin/psql -h 127.0.0.1 -p 5432 -U polardb postgres

更多环境请参考 PolarDB for PostgreSQL 开源官方手册

curve 分布式存储
ceph 分布式存储
nbd
传统存储

PolarDB 开源基础教程系列 3 安装部署

PolarDB 安装部署

本节阅读导航

0、人肉部署PolarDB数据库实例单机版

1、安装部署 PolarDB 单机版

2、安装部署 PolarDB 集群版(on ECS + ESSD)

3、更多部署环境

PolarDB PostgreSQL 版

热门文章

最新文章

相关电子书