利用Keepalived构建高可用的MySQL
公司大牛让用keepalived构建高可用的MySQL,在网上看到一篇很完整的文章,于是乎照着前辈的足迹,加上自己补充。如上述均正确配置
前言:公司大牛让用keepalived构建高可用的MySQL,在网上看到一篇很完整的文章,于是乎照着前辈的足迹,加上自己补充。
环境拓扑如下:
MySQL-VIP:192.168.1.150
MySQL-master1:192.168.1.151
MySQL-master2:192.168.1.152
OS版本:RedHat 5.4
MySQL版本:5.0.77
Keepalived版本:1.1.20
一、MySQL master-master的安装及配置
1、安装mysql
#yum install mysql-server -y \\为了节省时间,这里两台server都直接yum装,希望你配好了yum源。
2、修改配置文件
On server1:
#vim /etc/my.cnf
[mysqld]
server-id = 10
log-bin = mysql-bin
replicate-do-db = ccledb
auto-increment-increment = 2
auto-increment-offset = 1
On server2 :
#vim /etc/my.cnf
[mysqld]
server-id = 20
log-bin = mysql-bin
replicate-do-db = ccledb
auto-increment-increment = 2
auto-increment-offset = 2
3、建立授权用户
On server1:
mysql> grant replication client,replication slave on *.* to cclo1@’192.168.1.%’ identified by ‘123456’;
On server2:
mysql> grant replication client,replication slave on *.* to cclo2@’192.168.1.%’ identified by ‘123456’;
4、指定主服务器
On server1
mysql> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| MySQL-bin.000003 | 374 | | |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)
mysql> change master to master_host='192.168.1.152',master_user='cclo2',master_password='123456',master_log_file='mysql-bin.000003',master_log_pos=374;
Query OK, 0 rows affected (0.05 sec)
On server2
mysql> show master status;
+------------------+----------+--------------+------------------+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| MySQL-bin.000003 | 374 | | |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)
mysql> change master to master_host='192.168.1.151',master_user='cclo1',master_password='123456',master_log_file='mysql-bin.000003',master_log_pos=374;
Query OK, 0 rows affected (0.05 sec)
5、开启主主服务
mysql> start slave; \\两台server分别执行
MySQL> show slave status\G \\查看主主状态
Slave_IO_Running: Yes
Slave_SQL_Running: Yes \\如果此2项都为yes,master-master配置即成功
如上述均正确配置,现在在任何一台MySQL上更新数据都会同步到另一台MySQL。
二、keepalived安装及配置
1、192.168.1.151服务器上keepalived安装及配置
安装keepalived
#tar zxvf keepalived-1.1.20.tar.gz
#cd keepalived-1.1.20
#./configure --prefix=/usr/local/keepalived --with-kernel-dir=/usr/src/kernels/2.6.18-164.el5-i686
\\此处一定确保你的linux中有/usr/src/kernels/2.6.18-164.el5-i686这个目录,如果没有请安装kernel- devel包,建议最好是下载和你的linux系统内核版本相同的devel包安装(一般安装镜像有),此处直接#yum install -y kernel-devel
#make && make install
配置keepalived
此处需新建一个配置文件,默认情况下keepalived启动时会去/etc/keepalived目录下找配置文件
#mkdir /etc/keepalived
#vim /etc/keepalived/keepalived.conf \\配置文件内容如下:
! Configuration File for keepalived
global_defs {
notification_email {
cclo@cer.cn
}
notification_email_from cclo@cer.cn
smtp_server 127.0.0.1
smtp_connect_timeout 30
router_id MySQL-ha
}
vrrp_instance VI_1 {
state BACKUP #两台配置此处均是BACKUP
interface eth0
virtual_router_id 51
priority 100 #优先级,另一台改为90
advert_int 1
nopreempt #不主动抢占资源,只在优先级高的机器上设置即可,优先级低的机器不设置
authentication {
auth_type PASS
auth_pass 1111
}
virtual_ipaddress {
192.168.1.150
}
}
virtual_server 192.168.1.150 3306 {
delay_loop 2 #每个2秒检查一次real_server状态
lb_algo wrr #LVS算法
lb_kind DR #LVS模式
persistence_timeout 60 #会话保持时间
protocol TCP
real_server 192.168.1.151 3306 {
weight 3
notify_down /usr/local/my/my.sh #检测到服务down后执行的脚本
TCP_CHECK {
connect_timeout 10 #连接超时时间
nb_get_retry 3 #重连次数
delay_before_retry 3 #重连间隔时间
connect_port 3306 #健康检查端口
}
}
编写检测服务down后所要执行的脚本:
#vim /usr/local/my/my.sh
#!/bin/sh
pkill keepalived
#chmod +x /usr/local/my/my.sh
注:此脚本是上面配置文件notify_down选项所用到的,keepalived使用notify_down选项来检查real_server的服务状态,当发现real_server服务故障时,便触发此脚本;我们可以看到,脚本就一个命令,通过pkill keepalived强制杀死keepalived进程,从而实现了MySQL故障自动转移。另外,,我们不用担心两个MySQL会同时提供数据更新操作,因为每台MySQL上的keepalived的配置里面只有本机MySQL的IP+VIP,而不是两台MySQL的IP+VIP
启动keepalived:
#/usr/local/keepalived/sbin/keepalived –D
#ps -aux | grep keepalived
测试
找一台局域网PC,然后去ping MySQL的VIP,这时候MySQL的VIP是可以ping的通的
停止MySQL服务,#ps -aux | grep keepalived 看keepalived健康检查程序是否会触发我们编写的脚本

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Golang est un langage de programmation efficace, concis et sûr qui peut aider les développeurs à mettre en œuvre des systèmes distribués hautement disponibles. Dans cet article, nous explorerons comment Golang implémente des systèmes distribués hautement disponibles et fournirons quelques exemples de code spécifiques. Défis des systèmes distribués Un système distribué est un système dans lequel plusieurs participants collaborent. Les participants à un système distribué peuvent être différents nœuds répartis sous plusieurs aspects tels que l'emplacement géographique, le réseau et la structure organisationnelle. Lors de la mise en œuvre d'un système distribué, de nombreux défis doivent être relevés, tels que :

Linux et Docker : Comment implémenter un cluster de conteneurs hautement disponible ? Résumé : Avec le développement de la technologie des conteneurs, de plus en plus d'entreprises déploient progressivement des applications dans des conteneurs. Dans un environnement de production, il est essentiel d'obtenir une haute disponibilité pour un cluster de conteneurs. Cet article expliquera comment utiliser Linux et Docker pour créer un cluster de conteneurs hautement disponible et démontrera la méthode d'implémentation spécifique à travers des exemples de code. Construire un cluster DockerSwarm DockerSwarm est une gestion native de cluster de conteneurs fournie par Docker

Avec le développement rapide de la technologie du cloud computing et de la conteneurisation, les systèmes d'orchestration de conteneurs sont devenus un élément important du déploiement et de la gestion des applications modernes. Le système d'orchestration de conteneurs peut planifier, déployer et gérer automatiquement plusieurs conteneurs, offrant ainsi une haute disponibilité et une évolutivité. Parmi les nombreux langages de programmation, le langage Go a reçu une large attention en raison de ses puissantes fonctionnalités de concurrence et de ses hautes performances, et est utilisé par de nombreux systèmes d'orchestration de conteneurs bien connus tels que Docker et Kubernetes. Cet article explique comment utiliser le langage Go pour développer un système d'orchestration de conteneurs hautement disponible.

Comment utiliser l'architecture de base de données distribuée pour créer un cluster MySQL hautement disponible Avec le développement d'Internet, la demande de haute disponibilité et d'évolutivité des bases de données devient de plus en plus élevée. L'architecture de bases de données distribuées est devenue l'un des moyens efficaces de répondre à ces besoins. Cet article explique comment utiliser une architecture de base de données distribuée pour créer un cluster MySQL hautement disponible et fournit des exemples de code pertinents. Construire un cluster de réplication maître-esclave MySQL La réplication maître-esclave MySQL est la solution de base à haute disponibilité fournie par MySQL. Grâce à la réplication maître-esclave, les données peuvent être

Comment obtenir une haute disponibilité et un équilibrage de charge en Java À l'ère d'Internet d'aujourd'hui, la haute disponibilité et l'équilibrage de charge sont l'un des éléments clés dans la construction d'un système stable et fiable. En tant que langage de programmation largement utilisé, Java dispose d'une multitude de bibliothèques et d'outils qui peuvent nous aider à atteindre une haute disponibilité et un équilibrage de charge. Cet article explique comment implémenter la haute disponibilité et l'équilibrage de charge en Java et fournit des exemples de code spécifiques. 1. Haute disponibilité La haute disponibilité signifie que le système peut maintenir un fonctionnement stable pendant une longue période, quelles que soient les circonstances. En Java, vous pouvez

Avec le développement rapide d’Internet, de plus en plus de données doivent être stockées et traitées. Afin de garantir la sécurité et la fiabilité des données, les systèmes de stockage distribués deviennent de plus en plus importants. Cet article présentera comment utiliser le langage Go pour développer un système de stockage distribué hautement disponible et explorera certains des concepts et technologies clés dans la pratique. Avant de commencer, comprenons d'abord les principes de base des systèmes de stockage distribués. Un système de stockage distribué est composé de plusieurs nœuds de stockage et chaque nœud stocke indépendamment une partie des données. Afin d'assurer une haute disponibilité des données, le système

Avec le développement rapide d’Internet, les exigences de performances pour les applications à grande échelle sont de plus en plus élevées. Les systèmes de stockage de cache distribué sont une solution courante qui peut améliorer les performances, l'évolutivité et la fiabilité des applications. Dans cet article, nous explorerons comment implémenter un système de stockage de cache distribué hautement disponible dans le développement du langage Go. 1. Introduction générale Le système de stockage de cache distribué est une infrastructure clé pour les applications à grande échelle. Il accélère la lecture en stockant les données en mémoire et grâce à des technologies telles que la réplication et le partage de données,

Comment configurer une passerelle NAT hautement disponible sous Linux Résumé : La traduction d'adresses réseau (NAT) est une technologie réseau courante utilisée pour traduire l'adresse IP d'un réseau privé en adresse IP d'un réseau public. Sur les systèmes Linux, la configuration d'une passerelle NAT hautement disponible peut améliorer la disponibilité et la fiabilité du réseau. Cet article explique comment utiliser les outils Keepalived et iptables pour configurer une passerelle NAT hautement disponible sous Linux. Mots clés : NAT, haute disponibilité, Keepalived, i
