利用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健康检查程序是否会触发我们编写的脚本

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen

So nutzen Sie eine verteilte Datenbankarchitektur zum Aufbau eines hochverfügbaren MySQL-Clusters. Mit der Entwicklung des Internets wird die Nachfrage nach Hochverfügbarkeit und Skalierbarkeit von Datenbanken immer größer. Die verteilte Datenbankarchitektur ist zu einer der effektivsten Möglichkeiten zur Lösung dieser Anforderungen geworden. In diesem Artikel wird erläutert, wie mithilfe einer verteilten Datenbankarchitektur ein hochverfügbarer MySQL-Cluster erstellt wird, und es werden relevante Codebeispiele bereitgestellt. Erstellen eines MySQL-Master-Slave-Replikationsclusters Die MySQL-Master-Slave-Replikation ist die grundlegende Hochverfügbarkeitslösung von MySQL. Durch Master-Slave-Replikation können Daten sein

Golang ist eine effiziente, prägnante und sichere Programmiersprache, die Entwickler bei der Implementierung hochverfügbarer verteilter Systeme unterstützen kann. In diesem Artikel werden wir untersuchen, wie Golang hochverfügbare verteilte Systeme implementiert, und einige spezifische Codebeispiele bereitstellen. Herausforderungen verteilter Systeme Ein verteiltes System ist ein System, in dem mehrere Teilnehmer zusammenarbeiten. Teilnehmer eines verteilten Systems können verschiedene Knoten sein, die in verschiedenen Aspekten wie geografischer Lage, Netzwerk und Organisationsstruktur verteilt sind. Bei der Implementierung eines verteilten Systems müssen viele Herausforderungen bewältigt werden, wie zum Beispiel:

Linux und Docker: Wie implementiert man einen hochverfügbaren Container-Cluster? Zusammenfassung: Mit der Entwicklung der Containertechnologie stellen immer mehr Unternehmen nach und nach Anwendungen in Containern bereit. In einer Produktionsumgebung ist das Erreichen einer hohen Verfügbarkeit für einen Containercluster von entscheidender Bedeutung. In diesem Artikel wird die Verwendung von Linux und Docker zum Aufbau eines hochverfügbaren Containerclusters vorgestellt und die spezifische Implementierungsmethode anhand von Codebeispielen demonstriert. Erstellen Sie einen DockerSwarm-Cluster. DockerSwarm ist eine native Container-Cluster-Verwaltung, die von Docker bereitgestellt wird

Mit der rasanten Entwicklung der Cloud-Computing- und Containerisierungstechnologie sind Container-Orchestrierungssysteme zu einem wichtigen Bestandteil der modernen Anwendungsbereitstellung und -verwaltung geworden. Das Container-Orchestrierungssystem kann mehrere Container automatisch planen, bereitstellen und verwalten und sorgt so für hohe Verfügbarkeit und Skalierbarkeit. Unter vielen Programmiersprachen hat die Go-Sprache aufgrund ihrer leistungsstarken Parallelitätsfunktionen und hohen Leistung große Aufmerksamkeit erregt und wird von vielen bekannten Container-Orchestrierungssystemen wie Docker und Kubernetes verwendet. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache ein hochverfügbares Container-Orchestrierungssystem entwickeln

So konfigurieren Sie die Überwachung einer hochverfügbaren Container-Orchestrierungsplattform unter Linux. Mit der Entwicklung der Container-Technologie werden Container-Orchestrierungsplattformen von immer mehr Unternehmen als wichtiges Tool für die Verwaltung und Bereitstellung von Containeranwendungen eingesetzt. Um die hohe Verfügbarkeit der Container-Orchestrierungsplattform sicherzustellen, ist die Überwachung ein sehr wichtiger Teil. Sie kann uns helfen, den Betriebsstatus der Plattform in Echtzeit zu verstehen, Probleme schnell zu lokalisieren und eine Fehlerbehebung durchzuführen. In diesem Artikel wird erläutert, wie Sie die Überwachung der Hochverfügbarkeits-Container-Orchestrierungsplattform unter Linux konfigurieren und relevante Codebeispiele bereitstellen. 1. Wählen Sie geeignete Überwachungstools

Mit der rasanten Entwicklung des Internets müssen immer mehr Daten gespeichert und verarbeitet werden. Um die Sicherheit und Zuverlässigkeit von Daten zu gewährleisten, werden verteilte Speichersysteme immer wichtiger. In diesem Artikel wird die Verwendung der Go-Sprache zur Entwicklung eines hochverfügbaren verteilten Speichersystems vorgestellt und einige der Schlüsselkonzepte und -technologien in der Praxis untersucht. Bevor wir beginnen, verstehen wir zunächst die Grundprinzipien verteilter Speichersysteme. Ein verteiltes Speichersystem besteht aus mehreren Speicherknoten, und jeder Knoten speichert unabhängig einen Teil der Daten. Um eine hohe Verfügbarkeit der Daten zu gewährleisten, wird das System

So implementieren Sie ein hochverfügbares verteiltes System in der Go-Sprachentwicklung Zusammenfassung: Mit der rasanten Entwicklung des Internets steigt die Nachfrage nach verteilten Systemen. Die Implementierung eines hochverfügbaren verteilten Systems in der Go-Sprachentwicklung ist zu einem wichtigen Thema geworden. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache ein hochverfügbares verteiltes System entwickeln. 1. Einführung Ein verteiltes System besteht aus mehreren unabhängigen Knoten, und die Knoten kommunizieren und koordinieren über das Netzwerk. Hohe Verfügbarkeit ist eine der Kernanforderungen verteilter Systeme. Sie kann sicherstellen, dass das System auch bei verschiedenen Anomalien und Ausfällen weiterhin funktioniert.

So erreichen Sie Hochverfügbarkeit und Lastausgleich in Java. Im heutigen Internetzeitalter sind Hochverfügbarkeit und Lastausgleich eines der Schlüsselelemente beim Aufbau eines stabilen und zuverlässigen Systems. Als weit verbreitete Programmiersprache verfügt Java über eine Fülle von Bibliotheken und Tools, die uns dabei helfen können, hohe Verfügbarkeit und Lastausgleich zu erreichen. In diesem Artikel wird die Implementierung von Hochverfügbarkeit und Lastausgleich in Java vorgestellt und spezifische Codebeispiele bereitgestellt. 1. Hohe Verfügbarkeit Hohe Verfügbarkeit bedeutet, dass das System unter allen Umständen über einen langen Zeitraum einen stabilen Betrieb aufrechterhalten kann. In Java ist das möglich
