• linux——主从同步

    1. 保证主节点开始二进制日志，从节点配置中继日志
    2. 从节点的开启一个 I/O 线程读取主节点二进制日志的内容
    3. 从节点读取主节点的二进制日志之后，会将去读的内容写入从节点的中继日志
    4. 从节点开启 SQL 线程，读取中继日志的内容，并执行，来保证从节点的数据和主节点的数据保持一致
    缺点：
    1. 从节点只能从指定的偏移量开始同步数据，也就是说偏移量之前的数据无法通过主从同步去完善， 所以就需要通过逻辑备份等方式来导入到从节点。
    2. 二进制日志因为只记录数据变化状态，而不是记录真实有哪些数据存在
    主从同步的过程：
    1. 分别修改主从节点的配置文件，启用对应类型的日志，需要配置局域网内数据库服务的编号，以区别不同的节点 需要重启服务
    2. 在主节点授权，并导出二进制日志偏移量之前的数据，以方便后续数据的写入
    3. 在从节点，连接主节点的二进制日志，开启从节点的相关线程
    4. 检查从节点的主从同步状态
    5. 导入提前备份的主节点数据
    6. 在主节点新建数据，测试数据的同步的效果
    在从节点写入的数据是不会同步到主节点的！！！！！
    主节点： 192.168.110.50 - mysql-1
    从节点： 192.168.110.60 - mysql-2 
    1. 主节点：
    2. server-id 区别局域网内的mysql服务器
    3. log-bin 开启二进制日志。并制定二进制日志的文件名
    4. [root@mysql-1 ~]# cat /etc/my.cnf //如果my.cnf中没有[mysqld]，那么将下面的内
    5. 容写入 /etc/my.cnf.d./mysql-server.cnf
    6. 文件末尾新增如下内容，确保几行在[mysqld]的配置块中：
    7. log_bin=source-bin
    8. server_id=1
    9. validate_password.policy = low
    10. validate_password.length = 4
    11. validate_password.mixed_case_count = 0
    12. validate_password.special_char_count = 0
    13. validate_password.number_count = 0
    14. [root@mysql-1 ~]# rm -f /var/lib/mysql/source-bin.*
    15. [root@mysql-1 ~]# systemctl restart mysqld
    16. [root@mysql-1 ~]# firewall-cmd --add-service=mysql
    17. success
    18. [root@mysql-1 ~]# firewall-cmd --add-service=mysql --permanent
    19. success
    20. 从节点：
    21. server-id
    22. relay-log： 开启中继日志，并指定中继日志的文件名
    23. [root@mysql-2 ~]# cat /etc/my.cnf //如果my.cnf中没有[mysqld]，那么将下面的内容
    24. 写入 /etc/my.cnf.d./mysql-server.cnf
    25. #文件末尾新增，确保几行在[mysqld]的配置块中
    26. server_id = 2
    27. relay_log = relipca-relay
    28. relay_log_index = relipca-relay-index
    29. [root@mysql-2 ~]# rm -f /var/lib/mysql/reli*
    30. [root@mysql-2 ~]# ls /var/lib/mysql/rel*
    31. ls: cannot access '/var/lib/mysql/rel*': No such file or directory
    32. [root@mysql-2 ~]# systemctl restart mysqld
    2. 主节点创建同步用户 
    1. mysql> CREATE USER 'replica-user'@'192.168.110.%' IDENTIFIED BY
    2. 'redhat';
    3. Query OK, 0 rows affected (0.01 sec)
    4. mysql> select user from mysql.user where user = 'replica-user';
    5. +--------------+
    6. | user |
    7. +--------------+
    8. | replica-user |
    9. +--------------+
    10. 1 row in set (0.00 sec)
    11. mysql> GRANT REPLICATION SLAVE ON *.* TO 'replicauser'@'192.168.110.%';
    12. Query OK, 0 rows affected (0.00 sec)
    13. # 增加一个读锁，避免在成功建立主从复制架构前产生任何的数据读写
    14. mysql> FLUSH TABLES WITH READ LOCK;
    15. mysql> show master status;
    16. +-------------------+----------+--------------+------------------+-----
    17. --------------+
    18. | File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
    19. Executed_Gtid_Set |
    20. +-------------------+----------+--------------+------------------+-----
    21. --------------+
    22. | source-bin.000001 | 730 | | |
    23. |
    24. +-------------------+----------+--------------+------------------+-----
    25. --------------+
    26. 1 row in set (0.00 sec)
    3. 主节点需要在开始主从同步之前，将部分数据预先导入从数据库，避免后续 SQL 写入失败。
    1. 使用任意一种方式，实现数据迁移到从节点即可。
    mysqldump 导出主节点有但是从节点没有的数据
    mysql < dump.sql 从节点导入主节点备份的数据
    4. 从节点同步主节点二进制日志 
    1. 主节点：
    2. mysql> UNLOCK TABLES;
    3. 从：
    4. mysql> stop slave;
    5. Query OK, 0 rows affected, 2 warnings (0.00 sec)
    6. mysql> CHANGE REPLICATION SOURCE TO SOURCE_HOST='192.168.110.50',
    7. SOURCE_USER='replica-user', SOURCE_PASSWORD='redhat',
    8. -> SOURCE_LOG_FILE='source-bin.000001', SOURCE_LOG_POS=730,
    9. GET_MASTER_PUBLIC_KEY=1;
    10. Query OK, 0 rows affected, 3 warnings (0.01 sec)
    11. mysql> start slave;
    12. Query OK, 0 rows affected, 1 warning (0.02 sec)
    13. mysql> show slave status\G
    14. *************************** 1. row ***************************
    15. Slave_IO_State: Waiting for source to send event
    16. Master_Host: 192.168.110.50
    17. Master_User: replica-user
    18. Master_Port: 3306
    19. Connect_Retry: 60
    20. Master_Log_File: source-bin.000001
    21. Read_Master_Log_Pos: 730
    22. Relay_Log_File: relipca-relay.000002
    23. Relay_Log_Pos: 327
    24. Relay_Master_Log_File: source-bin.000001
    25. Slave_IO_Running: Yes //这两行的值必须是YES
    26. Slave_SQL_Running: Yes //这两行的值必须是YES
    27. Replicate_Do_DB:
    28. Replicate_Ignore_DB:
    29. Replicate_Do_Table:
    30. Replicate_Ignore_Table:
    31. Replicate_Wild_Do_Table:
    32. Replicate_Wild_Ignore_Table:
    33. Last_Errno: 0
    34. Last_Error:
    35. Skip_Counter: 0
    36. Exec_Master_Log_Pos: 730
    37. Relay_Log_Space: 535
    38. Until_Condition: None
    39. Until_Log_File:
    40. Until_Log_Pos: 0
    41. Master_SSL_Allowed: No
    42. Master_SSL_CA_File:
    43. Master_SSL_CA_Path:
    44. Master_SSL_Cert:
    45. Master_SSL_Cipher:
    46. Master_SSL_Key:
    47. Seconds_Behind_Master: 0
    48. Master_SSL_Verify_Server_Cert: No
    49. Last_IO_Errno: 0
    50. Last_IO_Error:
    51. Last_SQL_Errno: 0
    52. Last_SQL_Error:
    53. Replicate_Ignore_Server_Ids:
    54. Master_Server_Id: 1
    55. Master_UUID: 15bdf919-04f6-11ef-b4d0-000c29bbb601
    56. Master_Info_File: mysql.slave_master_info
    57. SQL_Delay: 0
    58. SQL_Remaining_Delay: NULL
    59. Slave_SQL_Running_State: Replica has read all relay log; waiting for
    60. more updates
    61. Master_Retry_Count: 86400
    62. Master_Bind:
    63. Last_IO_Error_Timestamp:
    64. Last_SQL_Error_Timestamp:
    65. Master_SSL_Crl:
    66. Master_SSL_Crlpath:
    67. Retrieved_Gtid_Set:
    68. Executed_Gtid_Set:
    69. Auto_Position: 0
    70. Replicate_Rewrite_DB:
    71. Channel_Name:
    72. Master_TLS_Version:
    73. Master_public_key_path:
    74. Get_master_public_key: 1
    75. Network_Namespace:
    76. 1 row in set, 1 warning (0.00 sec)
    4. 验证主从同步 
    1. 主节点创建库
    2. 从节点检查 同步成功
    3. 主：
    4. mysql> create database testa;
    5. Query OK, 1 row affected (0.01 sec)
    6. 从：
    7. mysql> show databases;
    8. +--------------------+
    9. | Database |
    10. +--------------------+
    11. | information_schema |
    12. | mysql |
    13. | performance_schema |
    14. | sys |
    15. | testa |
    16. +--------------------+
    17. 5 rows in set (0.01 sec)
    18. # 如果使用系统自带的mariadb数据库或者不是mysql 8.0.23以上的版本，实现下面的语句进行主节
    19. 点的连接参数配置
    20. mysql> CHANGE MASTER TO
    21. -> MASTER_HOST='source_host_name',
    22. -> MASTER_USER='replication_user_name',
    23. -> MASTER_PASSWORD='replication_password',
    24. -> MASTER_LOG_FILE='recorded_log_file_name',
    25. -> MASTER_LOG_POS=recorded_log_position;
    26. Or from MySQL 8.0.23:
    27. mysql> CHANGE REPLICATION SOURCE TO
    28. -> SOURCE_HOST='source_host_name',
    29. -> SOURCE_USER='replication_user_name',
    30. -> SOURCE_PASSWORD='replication_password',
    31. -> SOURCE_LOG_FILE='recorded_log_file_name',
    32. -> SOURCE_LOG_POS=recorded_log_position;
    5. 至此主从配置已经完成，但是部分数据还是未同步，现在在主节点上备份这个未同步的数据，并导
    入从节点即可，（结合自己架构中是否需要进行数据导入操作）
    1. 目前的演示环境下存在一个没有同步的 test 数据库，如果此时在主库从 test 库下的表进行写
    入，从节点会因为需要在在从节点上不存在的表写入数据，而停止 SQL 线程，于是我们需要
    将 test 的数据导入到从库中（演示插入了 5 ， ‘eee’ ） 从节点上 SQL 线程报错，同时也不存在
    test 库 和 a 表。 
    1. 主节点：
    2. [root@mysql-1 ~]# mysqldump -u root -predhat --databases test > dump.sql
    3. mysqldump: [Warning] Using a password on the command line interface can be
    4. insecure.
    5. [root@mysql-1 ~]# scp dump.sql root@192.168.110.60:/root
    6. The authenticity of host '192.168.110.60 (192.168.110.60)' can't be
    7. established.
    8. ECDSA key fingerprint is SHA256:96uJaydFGQSVWCqYUABOjb+GQYl4fNla/WbPreRvsK0.
    9. Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
    10. Warning: Permanently added '192.168.110.60' (ECDSA) to the list of known
    11. hosts.
    12. root@192.168.110.60's password:
    13. dump.sql
    14. 100% 2050 1.2MB/s 00:00
    15. 从节点：
    16. [root@mysql-2 ~]# mysql -u root -p'Redhat12~' < dump.sql
    17. mysql: [Warning] Using a password on the command line interface can be
    18. insecure.
    19. 主节点写入数据：
    20. mysql> insert into test.a values(6, 'fff');
    21. Query OK, 1 row affected (0.00 sec)
    22. mysql> insert into test.a values(7, 'ggg');
    23. Query OK, 1 row affected (0.00 sec)
    24. 从节点查看同步的数据：
    25. mysql> select * from test.a;
    26. +------+------+
    27. | id | name |
    28. +------+------+
    29. | 1 | aaa |
    30. | 2 | bbb |
    31. | 3 | ccc |
    32. | 5 | eee | //导入一次
    33. | 5 | eee | //主从同步一次
    34. | 6 | fff |
    35. | 7 | ggg |
    36. +------+------+
    37. 7 rows in set (0.01 sec)

    加入新的从节点

    两种方法：
    1. 在新的从节点上，配置 change 语句即可
    2. 从原本的从节点复制数据，修改配置文件并重启
    1. 在原本的从节点上打包数据目录，方便传输
    1. 原本从节点关闭数据库服务
    2. tar ，命令打包 
    1. [root@mysql-2 ~]# systemctl stop mysqld
    2. [root@mysql-2 ~]# cd /var/lib/mysql
    3. [root@mysql-2 mysql]# tar -czf /root/salve1.tar.gz .
    4. [root@mysql-2 ~]# scp slave1.tar.gz root@192.168.110.131:/root
    5. root@192.168.110.131's password:
    6. slave1.tar.gz
    7. 100% 2112KB 110.5MB/s
    8. 00:00
    2. 将压缩包复制到新的从节点上
    1. scp 传输压缩包
    2. 启动数据库服务 
    1. [root@mysql-2 ~]# scp salve1.tar.gz root@192.168.110.131:/root
    2. root@192.168.110.131's password:
    3. salve1.tar.gz
    4. 100% 2108KB 116.2MB/s
    5. 00:00
    6. [root@mysql-2 ~]# systemctl start mysqld
    3. 确保从节点上新的数据的安全上下文以及权限正确
    1. mysql 用户需要有完整的读写执行权限
    2. 直接使用 restorecon 恢复数据目录的安全上下文为默认的标签 
    1. [root@bogon ~]# rm -rf /var/lib/mysql
    2. [root@bogon ~]# mkdir /var/lib/mysql
    3. [root@bogon ~]# tar -xzf salve1.tar.gz -C /var/lib/mysql/
    4. [root@bogon ~]# chown mysql.mysql /var/lib/mysql
    5. [root@bogon ~]# restorecon -R /var/lib/mysql
    4. 在新的从节点上
    1. 删除 /var/lib/mysql/auto.cnf
    2. 修改配置文件
    1. server_id // 值和目前主从复制架构下的任何数据库的 server_id 的值不重复
    2. relay_log 相关的配置和原本的从节点保持一致
    3. skip_slave_start 在启动数据库时，跳过从节点复制线程的启动 
    1. [root@bogon ~]# rm -f /var/lib/mysql/auto.cnf
    2. [root@bogon ~]# vim /etc/my.cnf
    3. # 添加如下内容
    4. server_id=3
    5. skip-slave-start=1
    6. relay_log = relipca-relay
    7. relay_log_index = relipca-relay-index
    5. 新的从节点上，启动数据库服务
    1. 检查主从配置和原本从节点配置是否一致 show slave status （ host /user /log/pos ）
    2. 执行 start slave 启动从线程。 
    1. [root@bogon ~]# systemctl start mysqld
    2. [root@bogon ~]# mysql -uroot -p'Redhat12~'

    mysql> start slave;
    Query OK, 0 rows affected, 1 warning (0.01 sec)
    6. 测试数据同步的效果
    1. 在主节点写如任何数据，都会主动同步到所有的从节点上去完成 
    1. 主：
    2. mysql> insert into test.a values(8, 'hhh');
    3. Query OK, 1 row affected (0.00 sec)
    4. 从1：
    5. mysql> select * from test.a;
    6. +------+------+
    7. | id | name |
    8. +------+------+
    9. | 1 | aaa |
    10. | 2 | bbb |
    11. | 3 | ccc |
    12. | 5 | eee |
    13. | 5 | eee |
    14. | 6 | fff |
    15. | 7 | ggg |
    16. | 8 | hhh |
    17. +------+------+
    18. 8 rows in set (0.00 sec)
    19. 从2：
    20. mysql> select * from test.a;
    21. +------+------+
    22. | id | name |
    23. +------+------+
    24. | 1 | aaa |
    25. | 2 | bbb |
    26. | 3 | ccc |
    27. | 5 | eee |
    28. | 5 | eee |
    29. | 6 | fff |
    30. | 7 | ggg |
    31. | 8 | hhh |
    32. +------+------+
    33. 8 rows in set (0.04 sec)

  • 相关阅读:
    2022 年广西职业院校技能大赛高职组《云计算》赛项赛卷
    【Java 进阶篇】使用 JDBC 更新数据详解
    抖音矩阵系统，抖音矩阵系统，抖音矩阵系统。
    java8 线程
    springcloud适配mysql和oracle数据库
    Linux 2.0总结
    Spring Cloud Gateway过滤器配置
    使用 FastAPI 实现服务端的 CRUD
    【mmdetection】ROIExtractor中的featmap_strides和finest_scale
    干货！分享解决python脚本中涉及账号密码泄露的方案（pyarmor）
  • 原文地址：https://blog.csdn.net/Xinan_____/article/details/138526478