## 1. TiDB节点
– **CPU**：8-16核，高主频
– **内存**：32-64GB
– **磁盘**：SSD，200GB以上
– **网络**：万兆网络

## 2. TiKV节点
– **CPU**：16-32核
– **内存**：64-128GB
– **磁盘**：NVMe SSD，1TB以上
– **网络**：万兆网络

## 3. PD节点
– **CPU**：4-8核
– **内存**：16-32GB
– **磁盘**：SSD，100GB以上
– **网络**：万兆网络

## 4. 存储规划
– **TiKV存储**：使用NVMe SSD，提供高I/O性能
– **TiDB存储**：使用SSD，存储日志和临时文件
– **PD存储**：使用SSD，存储元数据

## 5. 网络规划
– **网络拓扑**：使用万兆交换机，确保节点间网络延迟低
– **网络带宽**：确保足够的网络带宽，避免网络瓶颈
– **网络隔离**：将业务网络和管理网络分离

## 6. 硬件推荐
– **TiDB节点**：
– CPU：Intel Xeon Gold 6248或更高
– 内存：64GB DDR4
– 磁盘：2×480GB SSD RAID1
– 网络：10GbE

– **TiKV节点**：
– CPU：Intel Xeon Gold 6248或更高
– 内存：128GB DDR4
– 磁盘：4×1.6TB NVMe SSD
– 网络：10GbE

– **PD节点**：
– CPU：Intel Xeon Gold 6248或更高
– 内存：32GB DDR4
– 磁盘：2×480GB SSD RAID1
– 网络：10GbE

## 1. TiDB配置
– **max-connections**：最大连接数，根据并发量设置
“`toml
max-connections = 10000
“`

– **txn-total-size-limit**：事务总大小限制，默认100MB
“`toml
txn-total-size-limit = 209715200 # 200MB
“`

– **stmt-count-limit**：单个语句的最大执行时间（秒）
“`toml
stmt-count-limit = 1000000
“`

– **tmp-storage-size**：临时存储大小
“`toml
tmp-storage-size = -1
“`

– **oom-action**：OOM时的操作
“`toml
oom-action = “cancel”
“`

## 2. TiKV配置
– **storage.block-cache.capacity**：块缓存大小，建议设置为内存的40%
“`toml
[storage.block-cache]
capacity = “64GB”
“`

– **raftstore.capacity**：Raft存储容量
“`toml
[raftstore]
capacity = “1.6TB”
“`

– **raftstore.raft-base-tick-interval**：Raft基础 tick 间隔
“`toml
[raftstore]
raft-base-tick-interval = “200ms”
“`

– **server.grpc-concurrency**：gRPC并发数，建议设置为CPU核心数
“`toml
[server]
grpc-concurrency = 32
“`

– **rocksdb.max-open-files**：RocksDB最大打开文件数
“`toml
[rocksdb]
max-open-files = 8192
“`

– **rocksdb.defaultcf.write-buffer-size**：写入缓冲区大小
“`toml
[rocksdb.defaultcf]
write-buffer-size = “1GB”
max-write-buffer-number = 4
“`

## 3. PD配置
– **replication.max-replicas**：最大副本数
“`toml
[replication]
max-replicas = 3
“`

– **schedule.leader-schedule-limit**： leader 调度限制
“`toml
[schedule]
leader-schedule-limit = 4
“`

– **schedule.region-schedule-limit**： region 调度限制
“`toml
[schedule]
region-schedule-limit = 2048
“`

– **schedule.replica-schedule-limit**：副本调度限制
“`toml
[schedule]
replica-schedule-limit = 64
“`

## 4. 系统配置
– **文件描述符限制**：
“`bash
echo “* soft nofile 65535” >> /etc/security/limits.conf
echo “* hard nofile 65535” >> /etc/security/limits.conf
“`

– **TCP参数**：
“`bash
echo “net.core.somaxconn = 4096” >> /etc/sysctl.conf
echo “net.ipv4.tcp_max_syn_backlog = 4096” >> /etc/sysctl.conf
echo “net.ipv4.tcp_fin_timeout = 30” >> /etc/sysctl.conf
echo “net.ipv4.tcp_tw_reuse = 1” >> /etc/sysctl.conf
sysctl -p
“`

– **I/O调度**：
“`bash
# 查看当前I/O调度
cat /sys/block/nvme0n1/queue/scheduler
# 设置为none调度器
echo none > /sys/block/nvme0n1/queue/scheduler
“`

## 1. 表结构设计
– **使用合适的数据类型**：选择合适的数据类型，减少存储空间
“`sql
— 优化前：使用VARCHAR(255)存储IP地址
CREATE TABLE test.table (ip VARCHAR(255));
— 优化后：使用INT UNSIGNED存储IP地址
CREATE TABLE test.table (ip INT UNSIGNED);
“`

– **避免使用TEXT/BLOB**：大字段会影响插入性能
“`sql
— 优化前：使用TEXT存储大文本
CREATE TABLE test.table (content TEXT);
— 优化后：使用VARCHAR或分离存储
CREATE TABLE test.table (content VARCHAR(1000));
“`

– **合理设置默认值**：为字段设置合适的默认值
“`sql
CREATE TABLE test.table (
id INT PRIMARY KEY AUTO_INCREMENT,
status INT DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
“`

## 2. 索引设计
– **减少索引数量**：过多的索引会影响插入性能
“`sql
— 优化前：多个索引
CREATE INDEX idx_name ON test.table(name);
CREATE INDEX idx_age ON test.table(age);
CREATE INDEX idx_address ON test.table(address);
— 优化后：只保留必要的索引
CREATE INDEX idx_name_age ON test.table(name, age);
“`

– **延迟创建索引**：先插入数据，再创建索引
“`sql
— 步骤1：创建表时不创建索引
CREATE TABLE test.table (
id INT PRIMARY KEY,
name VARCHAR(50),
age INT
);
— 步骤2：插入数据
INSERT INTO test.table (id, name, age) VALUES (1, ‘test1’, 20), (2, ‘test2’, 30), …;
— 步骤3：创建索引
CREATE INDEX idx_name ON test.table(name);
“`

## 3. 分区设计
– **使用分区表**：将数据分散到多个分区，提高插入性能
“`sql
— 按时间分区
CREATE TABLE test.table (
id INT PRIMARY KEY,
created_at DATETIME
) PARTITION BY RANGE (YEAR(created_at)) (
PARTITION p2023 VALUES LESS THAN (2024),
PARTITION p2024 VALUES LESS THAN (2025),
PARTITION p2025 VALUES LESS THAN (2026)
);
“`

– **使用哈希分区**：均匀分布数据，避免热点
“`sql
— 按ID哈希分区
CREATE TABLE test.table (
id INT PRIMARY KEY,
name VARCHAR(50)
) PARTITION BY HASH (id) PARTITIONS 8;
“`

## 4. 主键设计
– **使用自增主键**：避免热点问题
“`sql
— 使用自增主键
CREATE TABLE test.table (
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(50)
);
“`

– **避免使用UUID作为主键**：会导致数据分布不均匀
“`sql
— 优化前：使用UUID
CREATE TABLE test.table (
id VARCHAR(36) PRIMARY KEY,
name VARCHAR(50)
);
— 优化后：使用自增主键
CREATE TABLE test.table (
id INT PRIMARY KEY AUTO_INCREMENT,
uuid VARCHAR(36),
name VARCHAR(50)
);
“`

## 5. 其他设计建议
– **使用批量插入**：减少网络往返
“`sql
— 批量插入
INSERT INTO test.table (name, age) VALUES (‘test1’, 20), (‘test2’, 30), (‘test3’, 40);
“`

– **使用事务批量提交**：减少事务开销
“`sql
— 事务批量提交
START TRANSACTION;
INSERT INTO test.table (name) VALUES (‘test1’);
INSERT INTO test.table (name) VALUES (‘test2’);
INSERT INTO test.table (name) VALUES (‘test3’);
COMMIT;
“`

– **关闭自动提交**：减少事务开销
“`sql
— 关闭自动提交
SET autocommit = 0;
— 执行批量插入
INSERT INTO test.table (name) VALUES (‘test1’), (‘test2’), (‘test3’);
— 手动提交
COMMIT;
“`

## 1. 准备工作
– **步骤1**：分析数据特点
– 数据量大小
– 数据结构
– 插入频率

– **步骤2**：选择插入方法
– 批量插入
– LOAD DATA
– 并行插入
– 分批次插入

– **步骤3**：优化Schema
– 优化表结构
– 优化索引设计
– 优化分区策略

## 2. 配置优化
– **步骤1**：调整TiDB配置
– 增加max-connections
– 调整txn-total-size-limit
– 优化tmp-storage-size

– **步骤2**：调整TiKV配置
– 增加block-cache.capacity
– 调整write-buffer-size
– 优化grpc-concurrency

– **步骤3**：调整系统配置
– 增加文件描述符限制
– 优化TCP参数
– 调整I/O调度

## 3. 插入执行
– **步骤1**：执行批量插入
“`sql
— 批量插入
INSERT INTO test.table (name, age) VALUES (‘test1’, 20), (‘test2’, 30), …, (‘test1000’, 40);
“`

– **步骤2**：使用LOAD DATA
“`sql
— LOAD DATA
LOAD DATA INFILE ‘/path/to/data.txt’ INTO TABLE test.table;
“`

– **步骤3**：并行插入
“`bash
# 使用多个线程并行插入
python parallel_insert.py
“`

– **步骤4**：分批次插入
“`bash
# 分批次插入
python batch_insert.py
“`

## 4. 监控和调优
– **步骤1**：监控插入性能
– 插入吞吐量
– 插入延迟
– 资源使用率

– **步骤2**：分析瓶颈
– 网络瓶颈
– CPU瓶颈
– I/O瓶颈
– 内存瓶颈

– **步骤3**：调整优化策略
– 调整批量大小
– 调整并发度
– 优化插入方法

## 5. 验证结果
– **步骤1**：验证数据完整性
“`sql
— 验证数据条数
SELECT COUNT(*) FROM test.table;
“`

– **步骤2**：验证性能指标
– 插入吞吐量
– 插入延迟
– 资源使用率

– **步骤3**：验证业务正常运行
– 测试查询性能
– 测试其他业务功能

## 1. 批量插入调优
– **调整批量大小**：
– 测试不同批量大小的性能
– 选择最佳批量大小（通常为1000-5000条）

– **使用参数化查询**：
“`java
// 使用参数化查询
String sql = “INSERT INTO test.table (name, age) VALUES (?, ?)”;
PreparedStatement pstmt = connection.prepareStatement(sql);
for (int i = 0; i < batchSize; i++) { pstmt.setString(1, "test" + i); pstmt.setInt(2, 20 + i % 30); pstmt.addBatch(); } pstmt.executeBatch(); ``` - **关闭自动提交**： ```java // 关闭自动提交 connection.setAutoCommit(false); try { // 执行批量插入 pstmt.executeBatch(); // 手动提交 connection.commit(); } catch (SQLException e) { connection.rollback(); e.printStackTrace(); } finally { connection.setAutoCommit(true); } ``` ## 2. LOAD DATA调优 - **使用LOCAL选项**： ```sql -- 使用LOCAL选项 LOAD DATA LOCAL INFILE '/path/to/data.txt' INTO TABLE test.table; ``` - **调整字段分隔符**： ```sql -- 调整字段分隔符 LOAD DATA INFILE '/path/to/data.txt' INTO TABLE test.table FIELDS TERMINATED BY ','; ``` - **调整行分隔符**： ```sql -- 调整行分隔符 LOAD DATA INFILE '/path/to/data.txt' INTO TABLE test.table LINES TERMINATED BY '\n'; ``` - **使用IGNORE选项**： ```sql -- 忽略重复键 LOAD DATA INFILE '/path/to/data.txt' INTO TABLE test.table IGNORE; ``` ## 3. 并行插入调优 - **使用多线程**： ```python import threading import pymysql def insert_data(start, end): conn = pymysql.connect(host='192.168.1.10', port=4000, user='root', password='password', db='test') cursor = conn.cursor() for i in range(start, end): sql = "INSERT INTO test.table (name) VALUES (%s)" cursor.execute(sql, ('test' + str(i),)) conn.commit() cursor.close() conn.close() # 创建多个线程 threads = [] batch_size = 10000 total = 100000 for i in range(0, total, batch_size): t = threading.Thread(target=insert_data, args=(i, i + batch_size)) threads.append(t) t.start() # 等待所有线程完成 for t in threads: t.join() ``` - **调整并发度**： - 根据CPU核心数和网络带宽调整并发度 - 避免过度并发导致性能下降 - **使用连接池**： ```java // 配置连接池 HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://192.168.1.10:4000/test"); config.setUsername("root"); config.setPassword("password"); config.setMaximumPoolSize(50); config.setMinimumIdle(20); HikariDataSource dataSource = new HikariDataSource(config); ``` ## 4. 分批次插入调优 - **计算批次大小**： - 根据数据量和内存大小计算批次大小 - 避免单次批次过大导致内存不足 - **使用游标**： ```python import pymysql # 读取数据文件 def read_data(file_path, batch_size): data = [] with open(file_path, 'r') as f: for line in f: data.append(line.strip().split(',')) if len(data) >= batch_size:
yield data
data = []
if data:
yield data

# 分批次插入
conn = pymysql.connect(host=’192.168.1.10′, port=4000, user=’root’, password=’password’, db=’test’)
cursor = conn.cursor()
batch_size = 1000

for batch in read_data(‘/path/to/data.txt’, batch_size):
sql = “INSERT INTO test.table (name, age) VALUES (%s, %s)”
cursor.executemany(sql, batch)
conn.commit()

cursor.close()
conn.close()
“`

– **监控批次执行**：
– 监控每个批次的执行时间
– 调整批次大小以获得最佳性能

## 5. 其他调优方法
– **禁用Binlog**：
“`sql
— 禁用Binlog
SET SESSION sql_log_bin = 0;
“`

– **调整事务隔离级别**：
“`sql
— 使用读已提交隔离级别
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
“`

– **使用临时表**：
“`sql
— 创建临时表
CREATE TEMPORARY TABLE temp_table LIKE test.table;
— 插入数据到临时表
INSERT INTO temp_table (name, age) VALUES (‘test1’, 20), (‘test2’, 30), …;
— 将数据插入到目标表
INSERT INTO test.table SELECT * FROM temp_table;
— 删除临时表
DROP TEMPORARY TABLE temp_table;
“`

– **优化网络传输**：
– 使用压缩传输
– 减少网络往返
– 使用本地连接

## 1. 准备环境
– **步骤1**：部署TiDB集群
“`bash
tiup cluster deploy fgedudb v6.1.0 topology.yaml –user root -p
tiup cluster start fgedudb
“`

– **步骤2**：创建测试数据库和表
“`sql
CREATE DATABASE test;
USE test;
CREATE TABLE sbtest1 (
id INT PRIMARY KEY,
k INT NOT NULL DEFAULT ‘0’,
c CHAR(120) NOT NULL DEFAULT ”,
pad CHAR(60) NOT NULL DEFAULT ”
);
“`

## 2. 准备测试数据
– **步骤1**：生成测试数据
“`bash
# 使用sysbench生成测试数据
sysbench –db-driver=mysql –mysql-host=192.168.1.10 –mysql-port=4000 –mysql-user=root –mysql-password=password –mysql-db=test –table-size=1000000 prepare
“`

– **步骤2**：导出测试数据
“`bash
# 导出测试数据
mysqldump -h 192.168.1.10 -P 4000 -u root -p test sbtest1 > sbtest1.sql
“`

## 3. 运行基准测试
– **步骤1**：测试单条插入
“`bash
# 单条插入测试
sysbench –db-driver=mysql –mysql-host=192.168.1.10 –mysql-port=4000 –mysql-user=root –mysql-password=password –mysql-db=test –table-size=1000000 –threads=64 –time=60 oltp_write_only run
“`

– **步骤2**：测试批量插入
“`bash
# 批量插入测试
python batch_insert_test.py
“`

– **步骤3**：测试LOAD DATA
“`bash
# LOAD DATA测试
time mysql -h 192.168.1.10 -P 4000 -u root -p test -e “LOAD DATA INFILE ‘sbtest1.txt’ INTO TABLE sbtest1;
“`

– **步骤4**：测试并行插入
“`bash
# 并行插入测试
python parallel_insert_test.py
“`

## 4. 分析测试结果
– **步骤1**：收集测试结果
– 插入吞吐量
– 插入延迟
– 资源使用率

– **步骤2**：分析瓶颈
– 网络瓶颈
– CPU瓶颈
– I/O瓶颈
– 内存瓶颈

– **步骤3**：比较不同插入方法的性能
– 单条插入 vs 批量插入
– 批量插入 vs LOAD DATA
– LOAD DATA vs 并行插入

## 5. 优化和验证
– **步骤1**：实施优化方案
– 调整批量大小
– 调整并发度
– 优化插入方法

– **步骤2**：重新运行基准测试
“`bash
# 重新运行测试
python batch_insert_test.py
“`

– **步骤3**：对比优化前后的结果
– 插入吞吐量提升
– 插入延迟降低
– 资源使用率优化

## 6. 生成报告
– **步骤1**：整理测试数据
– 不同插入方法的性能对比
– 不同批量大小的性能表现
– 不同并发度的性能表现

– **步骤2**：生成性能报告
– 测试环境
– 测试方法
– 测试结果
– 优化建议