PolarDB 开源部署体验评测

产品介绍

PolarDB 是阿里云自主研发的新一代关系型云原生数据库，采用了存储计算分离、软硬一体化设计，这既拥有分布式设计的低成本优势，又具有集中式的易用性。它实现了计算节点及存储节点的分离，提供了即时生效的可扩展能力和运维能力。100%兼容 MySQL 和 PostgreSQL 生态，可以无缝迁移和兼容现有的应用程序。这使得用户可以轻松地将现有应用迁移到 PolarDB 上，无需进行大规模的代码修改。能为用户提供秒级弹性、高性能、海量存储、安全可靠的数据库服务。

在 2024 年 2 月的墨天轮中国数据库流行度榜单中，PolarDB 首次夺得榜首并刷新榜单记录，成功打破了 OceanBase 连续 14 个月的冠军地位，显示了云原生数据库的蓬勃发展态势。

根据引擎不同，PolarDB 分为 PolarDB MySQL 版、PolarDB-X、PolarDB-PG 以及 PolarDB-PG（兼容 Oracle）四种，下面将重点介绍 PolarDB-X、PolarDB-PG。

• PolarDB for PostgreSQL

PolarDB for PostgreSQL 采用了基于 Shared-Storage 的存储计算分离架构。数据库由传统的 Share-Nothing 架构，转变成了 Shared-Storage 架构——由原来的 N 份计算+N 份存储，转变成了 N 份计算+1 份存储；而 PostgreSQL 使用了传统的单体数据库架构，存储和计算耦合在一起。

• PolarDB-X

云原生数据库 PolarDB 分布式版 (PolarDB for Xscale，简称“PolarDB-X”) 最初为解决阿里巴巴天猫“双十一”核心交易系统数据库扩展性瓶颈而生，是一款面向超高并发、海量存储、复杂查询场景设计的云原生分布式数据库系统。其采用 Shared-nothing 与存储计算分离架构，支持水平扩展、分布式事务、混合负载等能力，具备企业级、云原生、高可用、高度兼容 MySQL 系统及生态等特点。

PolarDB 助力开发者和客户通过开源版本快速使用阿里云数据库产品技术。其中 PolarDB PostgreSQL 版 与 PolarDB 分布式版（PolarDB-X） 已经开源！下面就将针对这两款开源产品进行部署评测。

PolarDB-X 部署实践

部署 PolarDB-X 数据库的方式有四种，分别是 PXD、Kubernetes、源码编译和 RPM 包部署。接下来将分别体验，正式开始部署前需要提前准备好主机资源，这里为了方便，已经提前准备好了云主机 ECS（为了更好地体验，推荐主机规格至少是 8C16G 的）。

在开始安装部署前有必要了解下 PolarDB-X 的服务构成，由 4 个核心组件组成，包括：计算节点（CN），存储节点（DN），元数据服务（GMS）和日志节点（CDC）。

源码编译（方法一）

有了上面对服务构成的了解，这里的源码编译安装就很清晰了，首先按照要求分别编译这些组件，如下：

编译 PolarDB-X DN (存储节点，代号polardbx-engine)
编译 PolarDB-X CN (计算节点，代号polardbx-sql)
编译 PolarDB-X CDC（日志节点，代号polardbx-cdc）

编译 PolarDB-X 存储节点 DN

• 安装依赖

# 安装cmake
yum install -y cmake3
ln -s /usr/bin/cmake3 /usr/bin/cmake
# 安装GCC7
yum install -y centos-release-scl
yum install -y gcc+ gcc-c++
yum install -y devtoolset-7-gcc devtoolset-7-gcc-c++ devtoolset-7-binutils
echo "source /opt/rh/devtoolset-7/enable" >>/etc/profile
# 安装依赖
yum install -y make automake git openssl-devel ncurses-devel bison libaio-devel

• 下载源码

#下载 polardbx-engine 源码
git clone https://github.com/polardb/polardbx-engine.git
#下载 polardbx-sql 源码
git clone https://github.com/polardb/polardbx-sql.git
#下载 polardbx-cdc 源码
git clone https://github.com/polardb/polardbx-cdc.git

• 编译安装

# 进入 polardbx-engine 代码路径
cd polardbx-engine
# 安装boost1.77 (注：把boost放到仓库里避免下载）
#这里官网文档提供的是1.70版本，但编译时会提示需要1.77版本
wget https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.tar.bz2
cp boost_1_77_0.tar.bz2 extra/boost/
# 编译安装（此步骤非常耗时，建议耐心等待）
cmake .                                   \
    -DFORCE_INSOURCE_BUILD=ON           \
    -DCMAKE_BUILD_TYPE="Debug"          \
    -DSYSCONFDIR="/u01/mysql"           \
    -DCMAKE_INSTALL_PREFIX="/u01/mysql" \
    -DMYSQL_DATADIR="/u01/mysql/data"   \
    -DMYSQL_MAINTAINER_MODE=0           \
    -DWITH_SSL=openssl                  \
    -DWITH_BOOST="./extra/boost/boost_1_77_0.tar.bz2"
make V=1 -j8
make install

在执行 cmake 编译时会出现如下问题：

按照提示需要安装如下依赖：

yum install -y devtoolset-11-gcc devtoolset-11-gcc-c++ devtoolset-11-binutils

此处还提示需要 1.77 版本的 boost，官网文档这里写的是 1.70.0，需要格外注意一下。如下：

再次编译，提示成功，如下：

执行 make -j8 编译时再次遇到依赖问题，如下：

按照提示分别安装依赖

yum install bzip2-devel -y
yum install lz4 -y
ln -s /usr/lib64/liblz4.so.1 /usr/lib/liblz4.so
yum install snappy snappy-devel -y

再次编译，可以看到已经成功。

继续执行 make install，完成编译。如下：

编译 PolarDB-X 计算节点 CN

• 安装依赖

# 安装依赖 JDK
yum -y install java-11-openjdk-devel
#配置环境变量
vim /etc/profile
JAVA_HOME=/usr/lib/jvm/java-11-openjdk-11.0.23.0.9-2.el7_9.x86_64
PATH=$PATH:$JAVA_HOME/bin
export JAVA_HOME PATH
:wq
source /etc/profile
#测试
java -version

#安装Maven 3
#创建目录下载tar包
mkdir -p /usr/local/maven/
cd /usr/local/maven/
wget https://mirrors.aliyun.com/apache/maven/maven-3/3.9.5/binaries/apache-maven-3.9.5-bin.tar.gz
#解压
tar -zxvf apache-maven-3.9.5-bin.tar.gz
#设置环境变量
vim /etc/profile
M3_HOME=/usr/local/maven/apache-maven-3.9.5
export PATH=${M3_HOME}/bin:${PATH}
:wq
source /etc/profile
#测试
mvn --version

• 编译安装

# 进入代码目录 
cd polardbx-sql/
# 确保 polardbx-rpc 子模块 (polardbx-glue) 已初始化
git init
git submodule update --init
# 编译打包（构建过程非常耗时，需耐心等待）
mvn install -D maven.test.skip=true -D env=release 
# 解压运行
tar zxvf target/polardbx-server-5.4.12-SNAPSHOT.tar.gz

在 maven 构建时遇到如下报错，如下：

这个异常提示是获取资源超时，在网络无问题的情况下多重试几次，或者用国外区域的 ECS 来部署，比如我这里用的就是美国（硅谷）地区的 ECS，如果还是提示出错可以进入钉钉群（32432897）寻找帮助。

编译 PolarDB-X 日志节点 CDC

• 编译安装

# 进入CDC代码
# 编译打包
mvn install -D maven.test.skip=true -D env=release 
# 包在/polardbx-cdc-assemble/target/
# 解压运行
tar zxvf polardbx-binlog.tar.gz

启动 PolarDB-X DN

#这里需要以非root身份运行（如下的启动都需要非root运行），所以首先得新建一个用户
useradd -ms /bin/bash palarx
#设置用户密码
echo "polarx:polarx" |chpasswd
#允许用户在sudo时不需要输入密码
echo "polarx ALL=(all) NOPASSWD:ALL" >> /etc/sudoers
#创建数据库相关目录
mkdir -p /u01/my3306/{data,log,run,tmp,mysql}
#初始化数据库
/u01/mysql/bin/mysqld --defaults-file=my.cnf --initialize-insecure
#启动数据库
/u01/mysql/bin/mysqld --defaults-file=my.cnf

启动 PolarDB-X CN

首先需要修改默认得配置文件 conf/server.properties，如下：

# PolarDB-X 服务端口
serverPort=8527
# PolarDB-X RPC 端口
rpcPort=9090
 # MetaDB地址
metaDbAddr=127.0.0.1:4886
# MetaDB私有协议端口
metaDbXprotoPort=32886
# MetaDB用户
metaDbUser=polarx
metaDbName=polardbx_meta_db_polardbx
# PolarDB-X实例名
instanceId=polardbx-polardbx

初始化节点：

bin/startup.sh \
    -I \
    -P asdf1234ghjk5678 \
    -d 127.0.0.1:4886:32886 \
    -r "" \
    -u polardbx_root \
    -S "123456"

在初始化节点的过程中会生成密码，需要补充到配置文件 conf/server.properties 的 metaDbPasswd 参数中，以便后续访问。

#启动PolarDB-X
bin/startup.sh -P asdf1234ghjk5678
#连接PolarDB-X
mysql -h127.1 -P8527 -upolardbx_root

启动 PolarDB-X CDC

在启动之前，同样需要修改下配置文件 conf/config.properties，参照如下：

useEncryptedPassword=true
polardbx.instance.id=polardbx-polardbx
mem_size=16000
metaDb_url=jdbc:mysql://127.0.0.1:4886/polardbx_meta_db_polardbx?useSSL=false
metaDb_username=polarx
metaDbPasswd=HMqvkvXZtT7XedA6t2IWY8+D7fJWIJir/mIY1Nf1b58=
polarx_url=jdbc:mysql://127.0.0.1:8527/__cdc__
polarx_username=polardbx_root
polarx_password=H1AzXc2NmCs61dNjH5nMvA==
dnPasswordKey=asdf1234ghjk5678
storage.persistBasePath=${HOME}/logs/rocksdb
binlog.dir.path=${HOME}/binlog/

完成配置后，就可以启动了

#启动PolarDB-X CDC
bin/daemon.sh start

到此，通过最原始的源码编译部署 PolarDB-X 就算是完成了，是不是感觉非常耗费时间和精力，尤其是编译阶段时不时就会出错，好在错误日志提示的修复建议还是非常准确的。这里官网文档需要完善，比如标明涉及操作的具体主机和软件环境，尤其是版本号和依赖，如果一开始不解决好，后面编译报错就非常浪费时间。

源码编译（方法二）

其实除了官网文档提到的这类最原始的编译部署外，还有一种非常快速便捷的源码部署方式，非常适合小白尝鲜体验。具体实施如下：

首先需要准备一台云主机，这里就以 ECS 为例，规格是 16C16G 的 Centos 7.9，官网推荐不低于 8C16G。

• 开始依赖的安装：

#安装必要依赖
yum install -y sudo git make redhat-lsb-core

• 从 GitHub 仓库拉取源码

#首先创建一个用户，名为polarx
useradd -ms /bin/bash polarx
#设置用户密码
echo "polarx:polarx" |chpasswd
#设置sudo权限及免密
echo "polarx ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
#切换用户
su - polarx
#从git拉取源码
git clone https://github.com/polardb/polardbx.git

• 开始编译

#进入polardbx目录
cd polardbx/
#开始编译
make

整个编译过程受限于 ECS 规格及网络情况，需要耐心等待。完成编译如下：

当编译到了 88%时报出了如上异常，经过仔细比对 Makefile 文件发现，里面依赖的项存在差异，修改后重新编译正常。如下：

第一处：Makefile 要求的是 boost1_77_0 版本，却在下载的时候配置了 1_70_0 的地址。

第二处：通过源码编译方法一，可以发现是需要安装 devtoolset-11-gcc devtoolset-11-gcc-c++ devtoolset-11-binutils 依赖的，却在下载时没有配置。

完成编译后就是通过 maven 打包阶段。如下：

通过 maven 打包是极易出现问题的阶段，主要是所有组件都需要去 maven 官网下载，时不时就 timeout，非常考验你的耐心。下图是打包阶段需要完成下载的所有 jar 包：

期间如出现下图所示，就是完成编译并打包了。

接下来就是启动数据库服务并验证。如下：

#启动PolarDB-X数据库
su - polarx
cd polardbx
./build/run/bin/polardb-x.sh start
#查看是否有mysqld和mysqld_safe进程，观察jps是否有TddlLauncher进程
ps -ef |grep mysqld
jps
#连接数据库
mysql -h127.1 -P8527 -upolardbx_root
# 检查GMS 
select * from information_schema.schemata;
# 检查DN和CN
show storage ;  
show mpp ;
# 检查CDC
show master status ;
show binlog events in 'binlog.000001' from 4;

相比于第一种的源码编译部署方式，这一种虽然也是源码，但全程都是自动编译打包的，且配置也是自动完成的，可以称作是源码编译的自动版了。

PXD 部署（单机环境）

PXD 是 PolarDB-X 的部署工具，除了支持在本地一键快速拉起测试环境外，也支持在 Linux 集群中通过指定的拓扑的方式部署 PolarDB-X 分布式数据库。

开始部署前需要先准备 docker 环境，如下：

#安装docker依赖组件
yum install -y yum-utils device-mapper-persistent-data lvm2
#添加docker安装源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum makecache

#查看yum源支持安装的版本列表
yum list docker-ce --showduplicates | sort -r
#安装docker
yum install -y docker-ce-19.03.15-3.el7 docker-ce-cli-19.03.15-3.el7 containerd.io-1.3.7-3.1.el7 docker-compose-plugin

#配置镜像加速器
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://【用户ID】.mirror.aliyuncs.com"]
}
EOF
systemctl daemon-reload
systemctl restart docker
#查看docker信息
docker info

运行一个 docker run hello-world ，看环境是否正常。如下则正常：

先更新一波依赖并安装 python 及 pip，如下：

#更新依赖
yum update -y
#安装python3（如果你用的也是centos7.9,此步可以忽略）
yum install -y python3
#安装pxd（官方源速度较慢，这里用阿里云镜像）
pip install --upgrade pip
pip install -i https://mirrors.aliyun.com/pypi/simple/ pxd

创建一个 Python3 的 virtual environment 环境并激活

python3 -m venv venv
source venv/bin/activate

如果此处出现如下提示，可以先创建一个不带 pip 的虚拟环境，而后在虚拟环境中安装 pip，如下：

python3 -m venv --without-pip venv
source venv/bin/activate
curl https://bootstrap.pypa.io/pip/3.6/get-pip.py |python

#查看pxd版本号
pxd version
注：三副本模式需要 pxd版本>=0.3.0；标准版集群创建依赖 pxd版本>=0.6.0

部署 PolarDB-X

正式开始部署前需要先准备一份 PolarDB-X 拓扑文件（分企业版和标准版），企业版是 GMS, CN, DN, CDC 节点各 1 个。标准版则是 GMS, CN, CDC 个数为 0，仅包含一个 DN 节点。

#一键部署PolarDB-X企业版
pxd tryout
注：tryout 模式创建的 GMS 和 DN 默认采用单副本模式，如果您想创建基于 Paxos 的三副本的集群，使用如下命令：
pxd tryout -leader_only false
#一键部署PolarDB-X标准版
pxd tryout -t standard
注：tryout 模式创建的集群采用单副本模式，如果您想创建基于 Paxos 的一主一备一日志的三节点集群，使用如下命令：
pxd tryout -t standard -leader_only false

• 企业版部署

此处如果之前执行了 pxd tryout 会有如下异常：

根据提示，执行 pxd delete pxc_test 即可。如下是企业版集群部署：

此处需要拉取镜像，耗时较长，需耐心等待，且 国内区域的 ECS 均会拉取失败，建议更换到国外区域的 ECS，因为多数镜像源都在国外，比如美国（硅谷）。 如下：

完成镜像拉取后，通过 docker images 查看，如下：

通过 docker ps 可以看到运行了四个容器服务，如下：

回到虚拟环境可以看到此时已经完成部署。如下：

#安装mysql客户端
yum -y install mysql mysql-devel 
#登录数据库（完成部署后会生成口令且仅出现这一次，请注意保存）
mysql -h127.0.0.1 -P57134 -upolardbx_root -pwULsQZoz
# 检查GMS 
select * from information_schema.schemata;
# 检查DN和CN
show storage ;  
show mpp ;
# 检查CDC
show master status ;
show binlog events in 'binlog.000001' from 4;

• 标准版部署：

完成镜像拉取后通过命令 docker images 查看情况，如下：

启动 DN 节点容器服务时会卡 50%，分析容器日志发现如下问题：

从日志来看似乎看不出来问题出在哪里，但从上述镜像大小来看，应该是拉取时没有获取到完整镜像导致的。重新执行一遍 pxd tryout -t standard，重新查看镜像，果然不一样了。继续观察日志，发现不再报错，完成部署。如下：

#安装mysql客户端
yum -y install mysql mysql-devel 
#登录数据库（完成部署后会生成口令且仅出现这一次，请注意保存）
mysql -h127.0.0.1 -P17612 -uadmin -pEBnUKuQI
#查看节点拓扑信息与状态
select * from information_schema.alisql_cluster_global;
#查看节点延迟信息
select * from information_schema.alisql_cluster_health;

#查看当前环境的 PolarDB-X 列表
pxd list
#清理本地环境所有的 PolarDB-X
pxd cleanup

PXD 部署（集群环境）

部署集群有别于单机模式，需要注意如下几点：

• 每个节点主机都需要安装 docker 环境，且 docker engine 版本需要大于等于 18.04
• 如果采用阿里云 ECS 部署，建议修改 docker registry mirror 配置，将其切换成上海交通大学的镜像源：docker.mirrors.sjtug.sjtu.edu.cn
• 集群机器间需配置免密登录。选择任意一台机器作为部署机，配置部署机到集群所有机器的免密登录（如果主机有多张网卡，建议使用内网网卡的 ip 进行免密配置，不要使用公网 ip）

这里准备三台 ECS 主机，先配置免密登录，如下：

# 三台机器：
#172.26.105.203 # PXD 部署机
#172.26.105.204
#172.26.105.205
# 则需要在172.26.105.203上执行如下命令完成免密配置：
ssh-keygen -t rsa
ssh-copy-id root@172.26.105.203
ssh-copy-id root@172.26.105.204
ssh-copy-id root@172.26.105.205

接下来需要在每台主机上安装 docker 环境，如下：

#安装docker依赖组件
yum install -y yum-utils device-mapper-persistent-data lvm2
#添加docker安装源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum makecache fast
#安装docker
yum install -y docker-ce-19.03.15-3.el7 docker-ce-cli-19.03.15-3.el7 containerd.io-1.3.7-3.1.el7 docker-compose-plugin
#修改docker registry mirror配置
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://docker.mirrors.sjtug.sjtu.edu.cn"]
}
EOF
systemctl restart docker

在部署机上安装 pxd，如下：

#安装python3（如果你用的也是centos7.9,此步可以忽略）
yum install -y python3
#在部署机上创建虚拟环境并激活
python3 -m venv venv
source venv/bin/activate
#安装pxd（官方源速度较慢，这里用阿里云镜像）
pip install --upgrade pip
pip install -i https://mirrors.aliyun.com/pypi/simple/ pxd
#获取 PolarDB-X 各个组件的最新镜像版本（需要填入YAML文件）
curl -s "https://polardbx-opensource.oss-cn-hangzhou.aliyuncs.com/scripts/get-version.sh" | sh
#一键部署集群
pxd create -file polardbx.yaml

准备企业版集群拓扑 YAML 文件，如下：

version: v1
type: polardbx
cluster:
  name: pxc_colony
  gms:
    image: polardbx/polardbx-engine:v2.4.0_8.4.19
    host_group: [172.26.105.203]
  cn:
    image: polardbx/polardbx-sql:v2.4.0_5.4.19
    replica: 2
    nodes:
      - host: 172.26.105.204
      - host: 172.26.105.205
    resources:
      mem_limit: 4G
  dn:
    image: polardbx/polardbx-engine:v2.4.0_8.4.19
    replica: 2
    nodes:
      - host_group: [172.26.105.204]
      - host_group: [172.26.105.205]
    resources:
      mem_limit: 4G
  cdc:
    image: polardbx/polardbx-cdc:v2.4.0_5.4.19
    replica: 1
    nodes:
      - host: 172.26.105.203
    resources:
      mem_limit: 4G

#YAML文件说明
version: 拓扑文件版本，无需修改
type: polardbx， 无需修改
cluster.name：PolarDB-X 集群名称
cluster.gms.image: gms docker 镜像名称，建议填上述命令的获取到的 DN 镜像，如不填，默认为最新镜像
cluster.gms.host_group: gms 机器 ip 列表，如果想创建单副本模式，列表中填写1个ip即可，如果想创建基于Paxos的三副本集群，列表中填3个ip即可，三副本集群的Leader节点将从前两个ip的节点上随机选出
cluster.cn
image: 计算节点镜像名称，建议填上述命令的获取到的 CN 镜像，如不填，默认为最新镜像。
replica: 计算节点数目，需要与nodes中的host数量对应
nodes: 计算节点的ip列表
resources: 计算节点使用的资源
mem_limit: 内存上限，默认 2G
cluster.dn
image: 数据节点镜像名称，建议填上述命令的获取到的 DN 镜像，如不填，默认为最新镜像
replica: 数据节点数目，需要与nodes中的 host_group 数量对应
nodes: 存储节点的host_group列表，一个 host_group 表示一个dn节点多副本的部署机器，比如Paxos三副本的话需要填入三个ip，三副本集群的Leader节点将从前两个ip的节点上随机选出
resources: 存储节点使用的资源
mem_limit: 内存上限，默认 2G
cluster.cdc
image: CDC 节点镜像名称，建议填上述命令的获取到的 CDC 镜像，如不填，默认为最新镜像
replica: CDC 节点数目，需要与nodes中的host数量对应
nodes: CDC 节点的ip列表
resources: CDC 节点使用的资源
mem_limit: 内存上限，默认 2G

部署完成后，跟单机环境最大的差异在，生成了两个登录口令，接下来我们分别在三台主机上执行 docker ps 及 docker images，看看有啥差异。如下：

从上可以很直观地看到，部署完全是按照 YAML 文件执行的，203 部署机上运行了 gms 及 cdc，204 和 205 节点上分别运行了 dn 及 cn。

#安装mysql客户端
yum -y install mysql mysql-devel 
#登录数据库（完成部署后会生成口令且仅出现这一次，请注意保存）
mysql -h172.26.105.204 -P54643 -upolardbx_root -phQSilarQ
mysql -h172.26.105.205 -P55886 -upolardbx_root -phQSilarQ
# 检查GMS 
select * from information_schema.schemata;
# 检查DN和CN
show storage ;  
show mpp ;
# 检查CDC
show master status ;
show binlog events in 'binlog.000001' from 4;

上面部署的 YAML 是企业版集群的拓扑，如果你只有一台机器，也是可以部署标准版集群的，YAML 文件如下：

version: v1
type: polardbx
cluster:
  name: pxc_colony
  dn:
    image: polardbx/polardbx-engine:v2.4.0_8.4.19
    replica: 1
    nodes:
      - host_group: [172.26.105.203,172.26.105.203,172.26.105.203]
    resources:
      mem_limit: 2G

version: 拓扑文件版本，无需修改
type: polardbx， 无需修改
cluster.name：PolarDB-X 集群名称
cluster.dn
image: 数据节点镜像名称，建议填上述命令的获取到的 DN 镜像，如不填，默认为最新镜像
replica: 数据节点数目，标准版中默认设置为 1
nodes: 存储节点的host_group列表，一个 host_group 表示一个dn节点多副本的部署机器，比如Paxos三副本的话需要填入三个ip，三副本集群的Leader节点将从前两个ip的节点上随机选出
resources: 存储节点使用的资源
mem_limit: 内存上限，默认 2G

其他部署步骤同企业版，这里就不再赘述。

Kubernetes 部署

Kubernetes 是一个基于 Go 语言开发的用于 Docker 容器的开源编排系统。对于刚接触这个体系的 DevOps 人员来说，在环境中完整部署一整套多节点的 Kubernetes 集群确实具有一定的难度。为了帮助这些 DevOps 人员克服这种难度，出现了一些工具和平台，如 Minikube 等。云服务提供商也提供了托管的 Kubernetes 服务，比如阿里云的 容器服务 ACK。

这里为了缩短部署过程将采用 Minikube 部署单节点 Kubernetes 集群并在其之上部署 PolarDB-X 数据库。

在正式开始部署之前需要明确几个前提条件，如下：

• 机器规格不小于 4c8g
• minikube >= 1.18.0
• docker >= 1.19.3
• minikube 要求使用非 root 账号进行部署
• 如果使用阿里云 ACK，请使用 ACK 托管版，勿使用 ACK Serverless 版本

部署 Kubernetes 之前需要先安装 Docker 及 minikube。如下：

#安装docker依赖组件
yum install -y yum-utils device-mapper-persistent-data lvm2
#添加docker安装源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum makecache fast
#安装docker
yum install -y docker-ce-19.03.15-3.el7 docker-ce-cli-19.03.15-3.el7 containerd.io-1.3.7-3.1.el7 docker-compose-plugin
#修改docker registry mirror配置
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://docker.mirrors.sjtug.sjtu.edu.cn"]
}
EOF
systemctl restart docker
如果这个镜像无法获取资源，可以更改为如下镜像仓库
cat > /etc/docker/daemon.json << EOF
   {
    "registry-mirrors": ["https://polardbx-opensource-registry.cn-beijing.cr.aliyuncs.com", "https://b9pmyelo.mirror.aliyuncs.com"],
    "exec-opts": ["native.cgroupdriver=systemd"]
  }
EOF

#系统初始化
systemctl stop firewalld && systemctl disable firewalld
swapoff -a
setenforce 0
cat <<EOF >  /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
EOF
#下载minikube（建议使用国内镜像源，如阿里云）
curl -Lo minikube http://kubernetes.oss-cn-hangzhou.aliyuncs.com/minikube/releases/v1.23.1/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/

#新建账号
useradd -ms /bin/bash polardbx
usermod -aG docker polardbx
#切换用户
su polardbx
#启动minikube
minikube start --cpus 4 --memory 7960 --image-mirror-country cn --registry-mirror=https://docker.mirrors.ustc.edu.cn

#下载kubectl
curl -LO "https://dl.k8s.io/release/1.22.1/bin/linux/amd64/kubectl"
#安装kubectl
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
#查看版本
kubectl version --client --output=yaml
#kubectl访问集群
kubectl cluster-info

此时可以开始部署 PolarDB-X Operator，并使用 Operator 部署一个完整的 PolarDB-X 集群。如下

#安装helm3
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
#查看版本
helm version

#创建一个叫 polardbx-operator-system 的命名空间
kubectl create namespace polardbx-operator-system
#通过helm安装 PolarDB-X Operator
方法一：
helm install --namespace polardbx-operator-system polardbx-operator https://github.com/polardb/polardbx-operator/releases/download/v1.6.0/polardbx-operator-1.6.0.tgz
方法二：
helm repo add polardbx https://polardbx-charts.oss-cn-beijing.aliyuncs.com
helm install --namespace polardbx-operator-system polardbx-operator polardbx/polardbx-operator
#查看PolarDB-X Operator组件的运行情况
kubectl get pods --namespace polardbx-operator-system

等待片刻，各组件进入 Running 状态，表明 PolarDB-X Operator 已经安装完成，现在可以开始部署 PolarDB-X 集群了。如下：

• 部署企业版集群

#获取 PolarDB-X 各个组件的最新镜像版本（需要填入YAML文件）
curl -s "https://polardbx-opensource.oss-cn-hangzhou.aliyuncs.com/scripts/get-version.sh" | sh
#准备yaml文件
#创建集群
kubectl apply -f pxc-colony.yaml

apiVersion: polardbx.aliyun.com/v1
kind: PolarDBXCluster
metadata:
  name: pxc-colony
spec:
  topology:
    nodes:
      gms:
        template:
          image: polardbx/polardbx-engine:v2.4.0_8.4.19 
          resources:
            requests:
              cpu: 100m
              memory: 500Mi
            limits:
              cpu: 1
              memory: 1Gi
      cn:
        replicas: 1
        template:
          image: polardbx/polardbx-sql:v2.4.0_5.4.19
          resources:
            requests:
              cpu: 100m
              memory: 1Gi
            limits:
              cpu: 1
              memory: 2Gi
      dn:
        replicas: 1
        template:
          image: polardbx/polardbx-engine:v2.4.0_8.4.19
          resources:
            requests:
              cpu: 100m
              memory: 500Mi
            limits:
              cpu: 1
              memory: 1Gi
      cdc:
        replicas: 1
        template:
          image: polardbx/polardbx-cdc:v2.4.0_5.4.19
          resources:
            requests:
              cpu: 100m
              memory: 500Mi
            limits:
              cpu: 1
              memory: 1Gi

创建完成后，此时可以通过 kubectl get polardbxcluster -w 查看创建的状态。如下：

当状态显示为 Running 时，PolarDB-X 企业版集群已经部署完成。如下：

下面连接 PolarDB-X 集群看看。如下：

#安装mysql客户端
yum -y install mysql mysql-devel
#创建 PolarDB-X 集群时，PolarDB-X Operator 同时会为集群创建用于访问的服务，默认是 ClusterIP 类型。使用下面的命令查看用于访问的服务
kubectl get svc pxc-colony

#需要连接集群可以开一个nodeport对外访问的服务来暴露对外端口进行外网访问（修改子项 spec: type: ClusterIP 内容为 NodePort）
kubectl edit svc pxc-colony
#当然也可以使用 kubectl 提供的 port-forward 命名将服务的 3306 端口转发到本地，并且保持转发进程存活
kubectl port-forward svc/pxc-colony 3306

#Operator将为 PolarDB-X 集群默认创建一个账号，并将密码存放在 secret 中,使用以下命令查看默认的账号与密码
eval pxc=pxc-colony;eval user=$(kubectl get secret $pxc -o jsonpath={.data} | jq 'keys[0]'); echo "User: $user"; kubectl get secret $pxc -o jsonpath="{.data['$user']}" | base64 -d - | xargs echo "Password:"
执行该命令如出现“bash: jq: command not found”异常，需要执行yum install -y jq安装即可

#保持 port-forward 的运行，重新打开一个终端，执行如下命令连接集群
mysql -h127.0.0.1 -P3306 -upolardbx_root -ppmvn98rx

• 部署标准版集群

#获取 PolarDB-X 各个组件的最新镜像版本（需要填入YAML文件）
curl -s "https://polardbx-opensource.oss-cn-hangzhou.aliyuncs.com/scripts/get-version.sh" | sh
#准备yaml文件
#创建集群
kubectl apply -f pxc-standard.yaml

apiVersion: polardbx.aliyun.com/v1
kind: XStore
metadata:
  name: pxc-standard
spec:
  config:
    controller:
      RPCProtocolVersion: 1
  topology:
    nodeSets:
    - name: cand
      replicas: 2
      role: Candidate
      template:
        spec:
          image: polardbx/polardbx-engine:v2.4.0_8.4.19
          resources:
            limits:
              cpu: 2
              memory: 4Gi
    - name: log
      replicas: 1
      role: Voter
      template:
        spec:
          image: polardbx/polardbx-engine:v2.4.0_8.4.19
          resources:
            limits:
              cpu: 1
              memory: 2Gi

创建完成后，此时可以通过 kubectl get xstore -w 查看创建的状态。如下：

当状态显示为 Running 时，PolarDB-X 标准版集群已经部署完成。下面同样连接 PolarDB-X 集群看看。如下：

#查看用于访问的服务
kubectl get svc pxc-standard

#使用 kubectl 提供的 port-forward 命名将服务的 3306 端口转发到本地，并且保持转发进程存活
kubectl port-forward svc/pxc-standard 3306

#查看默认的账号与密码
eval pxc=pxc-standard;eval user=$(kubectl get secret $pxc -o jsonpath={.data} | jq 'keys[0]'); echo "User: $user"; kubectl get secret $pxc -o jsonpath="{.data['$user']}" | base64 -d - | xargs echo "Password:"
执行该命令如出现“bash: jq: command not found”异常，需要执行yum install -y jq安装即可

#保持 port-forward 的运行，重新打开一个终端，执行如下命令连接集群
mysql -h127.0.0.1 -P3306 -uadmin -pkbpzzvwg

RPM 安装包部署

获取 RPM 安装包的方式有两种，第一种就是直接在官网进行下载，第二种需要编译。

首先进入 PolarDB 官网，点击导航条的下载，进入 下载页，选择对应版本及 CPU 类型的 RPM 包，下载即可。如下：

编译生成 RPM 包可以按照如下步骤。

# 安装编译依赖
yum remove -y cmake
yum install -y git make centos-release-scl libaio-devel libarchive ncurses-devel bison zlib-devel snappy-devel lz4-devel bzip2-devel cmake3 mysql rpm-build openssl-devel autoconf libstdc++-static

ln -s /usr/bin/cmake3 /usr/bin/cmake

yum install -y devtoolset-10
echo "source /opt/rh/devtoolset-10/enable" | sudo tee -a /etc/profile
source /etc/profile
# 拉取代码
git clone https://github.com/polardb/polardbx-engine.git --depth 1
#rpm 包工作目录生成工具
yum install -y rpmdevtools
# 编译生成 rpm
cd polardbx-engine/rpm && rpmbuild -bb t-polardbx-engine.spec --nodeps
编译生成的 RPM 默认在 /root/rpmbuild/RPMS/x86_64/ 下

如果上述依赖安装有问题，在通过 rpmbuild 制作 RPM 包时会报如下依赖问题。

如果确认依赖项安装没有问题时，可以用 rpmbuild 的--nodeps 参数来忽略检查依赖项。完成编译后，包在目录/root/rpmbuild/RPMS/x86_64/下，如图：

将 rpm 包转到主机上，先对比下 md5 值，确保文件完整，再执行 rpm -ivh 安装。如下：

进入到程序主目录/opt/polardbx_engine, 如下：

#创建启动用户并赋予权限
useradd -ms /bin/bash polarx
echo "polarx:polarx" | chpasswd
echo "polarx    ALL=(ALL)    NOPASSWD: ALL" >> /etc/sudoers
#切换用户并创建目录（如下操作均需要在非root下执行）
su - polarx
mkdir -p polardbx-engine/{log,mysql,run,data,tmp}

要启动数据库服务前，需要先准备一个数据库配置文件 my.cnf。如下：

[mysqld]
basedir = /opt/polardbx-engine
log_error_verbosity = 2
default_authentication_plugin = mysql_native_password
gtid_mode = ON
enforce_gtid_consistency = ON
#开启binlog，row模式
log_bin = mysql-binlog
binlog_format = row
binlog_row_image = FULL
master_info_repository = TABLE
relay_log_info_repository = TABLE

# change me if needed
#数据文件目录
datadir = /home/polarx/polardbx-engine/data
#临时目录
tmpdir = /home/polarx/polardbx-engine/tmp
#socket文件目录
socket = /home/polarx/polardbx-engine/tmp.mysql.sock
#错误日志目录
log_error = /home/polarx/polardbx-engine/log/alert.log
#端口号
port = 4886
#实例ID
cluster_id = 7981
cluster_info = 127.0.0.1:14886@1

[mysqld_safe]
pid_file = /home/polarx/polardbx-engine/run/mysql.pid

# 初始化数据库
/opt/polardbx_engine/bin/mysqld --defaults-file=my.cnf --initialize-insecure
# 启动服务
/opt/polardbx_engine/bin/mysqld_safe --defaults-file=my.cnf &
#验证服务是否正常
ps -ef |grep mysql

#安装mysql客户端
yum -y install mysql mysql-devel 
#登录数据库
mysql -h127.0.0.1 -P4886 -uroot
#查询副本角色
SELECT * FROM INFORMATION_SCHEMA.ALISQL_CLUSTER_LOCAL \G
#检查GMS
select * from information_schema.schemata;
#检查CDC
show master status ;

PolarDB-PG 部署实践

PolarDB for PostgreSQL 采用了基于 Shared-Storage 的存储计算分离架构。数据库由传统的 Shared-Nothing 架构，转变成了 Shared-Storage 架构——由原来的 N 份计算 + N 份存储，转变成了 N 份计算 + 1 份存储。而 PostgreSQL 使用了传统的单体数据库架构，存储和计算耦合在一起。

部署 PolarDB-X 数据库的方式同样有四种，基于单机文件系统部署、基于 PFS 文件系统部署、基于 PFS for CurveBS 文件系统部署、基于 PolarDB Stack 共享存储部署。这里因为环境有限，只体验其中的两种。基于单机文件系统部署、基于 PFS 文件系统部署。

还是非常欢迎有条件的朋友们体验所有的部署方式，如此不仅可以全方面了解产品，也能多角度多维度学习使用产品。

基于单机文件系统部署

• 快速部署

源码编译作为最原始也是最具挑战的一种部署方式，如今已被自动化工具所替代。为了更好地了解底层构建过程，这里给大家部署体验一把。

相比于 PolarDB-X 的部署条件，PolarDB-PG 的要求就宽松很多，只需要满足如下即可：

• CPU 架构为 AMD64/ARM64
• 可用内存 4GB 以上
• 已安装 Docker

#安装docker依赖组件
yum install -y yum-utils device-mapper-persistent-data lvm2
#添加docker安装源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum makecache fast
#安装docker
yum install -y docker-ce-19.03.15-3.el7 docker-ce-cli-19.03.15-3.el7 containerd.io-1.3.7-3.1.el7 docker-compose-plugin
#修改docker registry mirror配置
mkdir -p /etc/docker
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://docker.mirrors.sjtug.sjtu.edu.cn"]
}
EOF
systemctl restart docker
#拉取 PolarDB-PG 镜像
docker pull polardb/polardb_pg_local_instance
#创建并运行容器
sudo docker run \
    -it --cap-add=SYS_PTRACE --privileged=true \
    --name polardb_pg \
    polardb/polardb_pg_local_instance \
    bash
#验证
psql -h 127.0.0.1 -c 'select version();'

如果这里你启动容器使用的是 docker run -it --rm polardb/polardb_pg_local_instance psql，将会出现如下异常，提示内存已满。如下：

这块应该是个 BUG，因为你即使指定内存启动依旧会报该问题。

• 源码编译

#下载源码（如网络受限可以访问国内Gitee镜像,稳定分支为POLARDB_11_STABLE）
yum install -y git
git clone -b POLARDB_11_STABLE https://github.com/ApsaraDB/PolarDB-for-PostgreSQL.git
或者国内镜像 git clone -b POLARDB_11_STABLE https://gitee.com/mirrors/PolarDB-for-PostgreSQL
#进入源码目录
cd PolarDB-for-PostgreSQL/
#拉取PolarDB for PostgreSQL的开发镜像
docker pull polardb/polardb_pg_devel
#创建并运行容器
sudo docker run -it \
    -v $PWD:/home/postgres/polardb_pg \
    --shm-size=512m --cap-add=SYS_PTRACE --privileged=true \
    --name polardb_pg_devel \
    polardb/polardb_pg_devel \
    bash
#获取权限并编译部署(单节点实例)
cd polardb_pg
sudo chmod -R a+wr ./
sudo chown -R postgres:postgres ./
./polardb_build.sh
这里根据场景的不同编译出不同形态的实例，编译选项及说明详见polardb_build.sh脚本
#单节点实例（一个读写节点）                   ./polardb_build.sh
#多节点实例（一个读写、一个只读）              ./polardb_build.sh --withrep --repnum=1
#多节点备库实例（一个读写、一个只读、一个备库）   ./polardb_build.sh --withrep --repnum=1 --withstandby
#多节点HTAP实例（一个读写、两个只读）           ./polardb_build.sh --initpx

完成编译部署将出现下图：

#查看版本
psql -h 127.0.0.1 -c 'select version();'
#查看启动时间
psql -h 127.0.0.1 -c 'select pg_postmaster_start_time();'
#查看所有表
psql -h 127.0.0.1 -c 'select pg_database.datname, pg_size_pretty(pg_database_size(pg_database.datname)) AS size from pg_database;'

• 多节点实例（一个读写、一个只读） ./polardb_build.sh --withrep --repnum = 1。编译过程大差不差，唯一的区别在于多了副本。如下：

• 多节点备库实例（一个读写、一个只读、一个备库） ./polardb_build.sh --withrep --repnum = 1 --withstandby。可以看出比上面的多节点多了一个备库。如下：

• 多节点 HTAP 实例（一个读写、两个只读） ./polardb_build.sh --initpx。相比于其他实例，HTAP 实例部署耗时稍微多半分钟。如下：

接下来做下实例回归测试

#普通实例回归测试
./polardb_build.sh --withrep -r -e -r-external -r-contrib -r-pl --with-tde
#HTAP实例回归测试
./polardb_build.sh -r-px -e -r-external -r-contrib -r-pl --with-tde
#DMA实例回归测试
./polardb_build.sh -r -e -r-external -r-contrib -r-pl --with-tde --with-dma

这里以 HTAP 实例举例，如下：

回归测试耗时蛮久，需要耐心等待。

基于 PFS 文件系统部署

为保证所有计算节点能够以相同的可见性视角访问分布式块存储设备，PolarDB 需要使用分布式文件系统 PolarDB File System（PFS）来访问块设备。

如果所有计算节点都可以本地访问同一个块存储设备，那么也可以不使用 PFS，直接使用本地的单机文件系统（如 ext4）。比如上面的基于单机文件系统的部署。

当前支持的 PFS 有四种，分别是 ESSD 云盘、CurveBS、Ceph 和 NBD。接下来将着重介绍如何基于阿里云 ECS+ESSD 云盘共享存储，完成 PolarDB-PG 读写节点和只读节点部署安装。

• 基于阿里云 ECS+ESSD 云盘共享存储

阿里云 ESSD 云盘支持 NVMe 协议，且可以同时挂载到多台支持 NVMe 协议的 ECS（Elastic Compute Service）实例上，从而实现多个 ECS 实例并发读写访问，具备高可靠、高并发、高性能等特点。

整体部署架构是这样的。如下：

接下来将按照如下步骤开始部署：

• 部署两台阿里云 ECS 作为计算节点

（一）选择 ECS 规格时要注意其是否支持 NVMe 协议，这里要用到 NVMe 云盘挂载。只有如下实例规格族支持多重挂载功能：

• • 存储增强通用型实例规格族 g7se
  • 存储增强计算型实例规格族 c7se
  • 存储增强内存型实例规格族 r7se
  • 通用型实例规格族 g8y
  • 计算型实例规格族 c8y
  • 内存型实例规格族 r8y
  • 通用平衡增强型实例规格族 g8ae
  • 计算平衡增强型实例规格族 c8ae
  • 内存平衡增强型实例规格族 r8ae
  • 通用型实例规格族 g8i
  • 计算型实例规格族 c8i
  • 内存型实例规格族 r8i

（二）此外对于主机操作系统的选择也有要求，需要包含 NVMe 协议的相关驱动，目前仅如下 Linux/Windows 公共镜像支持了 NVMe 驱动：

• • Alibaba Cloud Linux 2.1903 及以上版本
  • Ubuntu 16.04 及以上版本
  • Debian GNU/Linux 10 及以上版本
  • CentOS 7.6 及以上版本（CentOS 7 系列）
  • CentOS 8.0 及以上版本（CentOS 8 系列）
  • OpenSUSE 15.2 及以上版本
  • Fedora 33 及以上版本
  • Fedora CoreOS
  • Windows Server 2016 及以上版本

因此这里我选择 CentOS7.9, g7se 规格的，其他保持默认。输入想要的规格族进行搜索，如下：

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

如下所示，同一区域的两台 ECS 已准备好。

• 将一块 ESSD 云盘多重挂载到两台 ECS 上，作为共享存储

在阿里云 ECS 的管理控制台中，选择 存储与快照 下的 云盘，点击 创建云盘。在与已经建好的 ECS 所在的相同可用区内，选择建立一个 ESSD 云盘，并勾选 多实例挂载。如下：

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

接下来，把这个云盘分别挂载到两台 ECS 上。点击云盘操作项中的“挂载”，如下：

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

分别登录两台ECS检查下云盘，如下：

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

• 在 ESSD 共享存储上格式化分布式文件系统 PFS

接下来，将在两台 ECS 上分别部署 PolarDB 的主节点和只读节点。作为前提，需要在 ECS 共享的 ESSD 块设备上 格式化并挂载 PFS。首先安装PFS工具，可以编译安装，也可以直接使用编译完毕的 PFS容器镜像。这里选用容器镜像。如下：

#如果没有docker环境，则需要先安装docker-ce环境
#安装docker依赖组件
yum install -y yum-utils device-mapper-persistent-data lvm2
#添加docker安装源
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo 
yum makecache fast
#安装docker
yum install -y docker-ce-19.03.15-3.el7 docker-ce-cli-19.03.15-3.el7 containerd.io-1.3.7-3.1.el7 docker-compose-plugin
#启动docker
systemctl start docker
#获取PFS工具镜像
docker pull polardb/polardb_pg_binary
如果这里遇到无法拉取的情况，可以直接下载RPM包进行安装
wget https://github.com/ApsaraDB/PolarDB-FileSystem/releases/download/pfsd4pg-release-1.2.42-20220419/t-pfsd-opensource-1.2.42-1.el7.x86_64.rpm
rpm -ivh t-pfsd-opensource-1.2.42-1.el7.x86_64.rpm
#运行工具（如果已经使用RPM包安装，此步忽略）
docker run -it \
    --cap-add=SYS_PTRACE \
    --privileged=true \
    --name polardb_pg \
    --shm-size=512m \
    polardb/polardb_pg_binary \
    bash
#使用任意一台主机，在共享存储块设备上格式化PFS分布式文件系统
sudo pfs -C disk mkfs nvme1n1
#分别在两台主机上启动PFS守护进程，挂载PFS文件系统
sudo /usr/local/polarstore/pfsd/bin/start_pfsd.sh -p nvme1n1 -w 2

在启动PFS守护进程时，如遇到如下异常，需要执行如下命令：

wget https://github.com/HardySimpson/zlog/archive/refs/tags/1.2.17.tar.gz
tar zxvf 1.2.17.tar.gz
cd zlog-1.2.17
make && make install
echo "/usr/local/lib" >>/etc/ld.so.conf
ldconfig

• 基于 PFS，在两台 ECS 上共同搭建一个存算分离、读写分离的 PolarDB 集群

正式部署前需要对各节点进行初始化部署：

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

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

  # 使用 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，增加配置项：

  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/pg_hba.conf，增加以下配置项，允许只读节点进行物理复制：

  host    replication    postgres    0.0.0.0/0    trust

  • 启动读写节点

  $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();'

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

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

• • 在只读节点本地磁盘的 ~/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/

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

  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/recovery.conf，增加读写节点的连接信息，以及复制槽名称

  polar_replica='on'
  recovery_target_timeline='latest'
  primary_slot_name='replica1'
  primary_conninfo='host=[读写节点所在IP] port=5432 user=postgres dbname=postgres application_name=replica1'

  • 启动只读节点

  $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();'

  部署完成后，需要进行实例检查和测试，确保读写节点可正常写入数据、只读节点可以正常读取。首先登录 读写节点，创建测试表并插入样例数据：

  $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;"

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

体验总结

这是测评以来耗时最久的一次，前前后后总共花费了一周时间，把能够部署的方式全部来了一遍。期间购买ECS及其他资源频繁，订购是大增啊，好在花费还算可以，因为基本是按量付费或者抢占式实例。如下：

从截图上来看，基本花销在ECS及云盘，流量没花钱，是因为带宽计费方式升级成了CDT（按使用流量），每月可以获得200GB的流量，其中国内20GB。而本次测评部署所需的资源基本在国外，所以非常适合。

之所以耗时这么久，八成是因为部署所需资源的获取上遇到了问题，如果你选择的ECS在国内区域一定是会遇到该类问题的，国内区域的 ECS 基本没有任何速度，尤其是晚上。小白用户想搞个测试环境捣鼓在没有耐心的情况下基本是无解的。强烈建议把资源放到国内仓库。基本前三天我都是在这种环境下磕磕绊绊部署的，后面换了一种思路，考虑到资源在国外，为啥不选用国外地域的ECS来部署呢。带着这样的想法，我果断选择了美国（硅谷）地域的ECS，后面几天部署进度就非常快。另外的二成是因为部署组件之间存在依赖，如果部署前没有完整安装所有依赖的话，就会卡在编译打包过程中多次。而这块内容官网又是缺失的。

PolarDB-X的几种部署方式，我会首选RPM，因为它是唯一不用考虑资源下载和依赖项的，主打一个开箱即用，非常适合小白用户体验。如果不考虑资源获取效率的情况下，我会优先选择PXD的一键部署，因为它会把所有依赖项自动化地完整安装。对于两种源码编译方式，我会首选方法二，因为它把各个模块间的必要配置和依赖全部集成在了一个file中，如果安装过程有问题可以第一时间通过这个file来排查处理。至于最后的Kubernetes方式，可谓是当下最流行也是对部署人员技术要求最高的一种，用它的好处是部署人员只需准备好yaml文件，其他的就交给Operator来完成就好了，部署人员无需关注部署过程本身，大大节约部署成本。

PolarDB-PG的部署方式相对于PolarDB-X会简约许多，无论是源码编译还是标准部署只需要有docker环境就行，通过拉取镜像运行服务即可完成部署。部署过程最大的问题也在这，拉取的镜像资源全部在dockerhub上，拉取过程时不时就会timeout，甚至很久都会一直无响应，强烈建议把镜像资源放到国内来。

PolarDB-PG的官网文档做的是要优于PolarDB-X的，尤其是在层次结构上给人一种循序渐进，而PolarDB-X就没有这方面的感受，有时跟着文档走还会很疑惑，需要通过其他文案来协助。尤其是在某些细节的描述上不是很到位。比如：

这块应该描述为“需要通过如下命令实现组件的初始化”，因为多数人在获取源码的时候会连同gule包一起git clone到本地，其实是完全没必要的，这一步就会重复git clone一遍。

这个地方说了要安装JDK1.8和Maven3，可没有任何命令，可能是因为编写者以为我们知道要安装那个具体版本的。实际上现在git镜像是需要jdk11+的。而PolarDB-PG针对这个问题，文档是这么写的。如下：

通过README，你可以很清楚地了解到该如何编译安装。

此外文档结构上不够严谨，比如PolarDB-X的“快速体验”和“通过PXD部署集群”，其实看作是PXD的两种不同的部署方式，“快速体验”针对的是单机环境下的集群部署，而“通过PXD部署集群”则是基于多台主机通过YAML拓扑文件来部署。

PolarDB-PG在这方面就没有问题，很好地描述了什么是快速部署，什么是进阶部署。

还有一处需要说明的是文档中描述的部署环境及其依赖项比较老旧了，需要做更新。对应的部署底层环境也没有交代清楚，只给出了大概。比如：

这块实际上用现在git上的源码是需要1.77版本的，这个编译过程中也会报异常提示（上面过程过程有详细的说明，这里就不再赘述）

而这里实际上是要devtoolset-11-gcc devtoolset-11-gcc-c++ devtoolset-11-binutils。

为了大家部署时少走弯路，下面罗列下PolarDB-X部署时需要的所有依赖：

#CentOS依赖项
sudo yum remove -y cmake
sudo rm /usr/bin/cmake -f
sudo ln -s /usr/bin/cmake3 /usr/bin/cmake
sudo yum install -y epel-release
sudo yum install -y wget java-11-openjdk-devel cmake3 automake bison openssl-devel ncurses-devel libaio-devel mysql snappy-devel lz4-devel bzip2-devel autoconf libstdc++-static libarchive gcc gcc-c++ centos-release-scl devtoolset-10
echo "source /opt/rh/devtoolset-10/enable" | sudo tee -a /etc/profile

除了部署外，想继续深入了解并学习 PolarDB 产品的你可以继续点击下面链接前往。

下面罗列的都是视频学习资料，欢迎前来学习。

• 视频课程

云原生数据库 PolarDB 产品概述

PolarDB 分布式版数据库入门到精通实操

PolarDB-X 开源系列课程

PolarDB-X 如何应用实践？

PolarDB-X 的核心技术有哪些？

PolarDB-X 动手实践

如何在 PolarDB-X 中优化慢 SQL

如何在 PolarDB-X 中进行 Online DDL

如何对 PolarDB-X 集群做动态扩缩容

如何将 PolarDB-X 与大数据等系统互通

使用 PolarDB-X 开发应用

PolarDB for PostgreSQL 入门

7 天突破 PolarDB for PostgreSQL

PolarDB for PostgreSQL 内核解读系列课程

PolarDB for PostgreSQL 开源人才初级认证培训课程

高校精品课-华东师范大学-云原生数据库

数据库开源校企合作“数据库内核从入门到精通 ”系列课

「大师课」PolarDB 高手课

PolarDB 训练营-NL2SQL

• 资料好文

PolarDB 开发者大会主题资料下载

PolarDB 分布式版 2023 年度干货合集

一文熟悉 PolarDB-PG 分区表核心特性

PolarDB-X 存储引擎核心技术 | 索引回表优化

PolarDB-X 助攻《香肠派对》百亿好友关系实现毫秒级查询

PolarDB 助力欧派家居核心系统去 O 上云，每秒处理万次事务

PolarDB-X CDC 之 "兼容 MySQL, 高于 MySQL"