Mysql5. Replicación maestro-maestro + SSL + retrasada

Desde la versión 5 MySQL viene con soporte para la replicación maestro-maestro, resolviendo los problemas que surgían de inmediato si un nodo A y un nodo B insertaban ambos una clave autonumérica en la misma tabla.

Las ventajas de la replicación maestro-maestro sobre el tradicional maestro-esclavo son:

- no se tienen que modificar las aplicaciones para hacer que los accesos de escrituras sólo accedan al maestro.
- es más fácil proporcionar alta disponibilidad porque si el maestro falla todavía se tiene el otro maestro.

En este ejemplo voy a mostrar cómo replicar varias bases de datos del servidor skinner.gowex.com con la dirección IP 192.168.0.2 al servidor cletus.gowex.com con la dirección IP 192.168.0.9 y viceversa. Cada sistema es el esclavo del otro maestro y el maestro del otro esclavo al mismo tiempo. Ambos sistemas están corriendo Ubuntu 8.0.4, sin embargo, la configuración debe aplicarse a casi todas las distribuciones con poca o ninguna modificación.

Para asegurarse de que la replicación pueda funcionar, tenemos que hacer que MySQL escuche en todas las interfaces, por lo tanto, debemos comentar la línea
'bind-address = 127.0.0.1' en /etc/mysql/my.cnf:

<- líneas que salen
-> líneas que entran

skinner/cletus:

vi /etc/mysql/my.cnf

<- bind-address = 127.0.0.1
-> # bind-address = 127.0.0.1

Después hay que reiniciar mysql en ambos servidores y comprobar que escucha en todas las interfaces:

/etc/init.d/mysql restart

netstat -tap | grep mysql

skinner:~# netstat -tap | grep mysql
tcp 0 0 *:mysql *:* LISTEN 19928/mysqld

Si root no tiene password la creamos:

mysqladmin -u root password yourrootsqlpassword

En skinner:

mysqladmin -h skinner.gowex.com -u root password yourrootsqlpassword

#Configuramos un usuario de replicacion 'slavecletus' que podrá ser usado por el servidor cletus para acceder a la base de datos MySQL en skinner:
mysql -u root -p
GRANT REPLICATION SLAVE ON *.* TO 'slavecletus'@'192.168.0.9' IDENTIFIED BY 'slavecletus_password';
FLUSH PRIVILEGES;
quit;

En cletus:

mysqladmin -h cletus.gowex.com -u root password yourrootsqlpassword

#Configuramos un usuario de replicacion 'slaveskinner' que podrá ser usado por el servidor skinner para acceder a la base de datos MySQL en cletus:
mysql -u root -p
GRANT REPLICATION SLAVE ON *.* TO 'slaveskinner'@'192.168.0.2' IDENTIFIED BY 'slaveskinner_password';
FLUSH PRIVILEGES;
quit;

Voy a suponer que las bases de datos telcommunity, webpanelsuzuki, wiloc, rss, GestorMarketing, plataforma y radiusSeasuntel ya existen, que hay tablas con registros en ellas y que todas son de tipo InnoDB salvo las dos primeras que son MyIsam.

Vamos a configurar la replicación de todas a cletus, y después configuraremos la replicación de todas de cletus a skinner.

Lo primero es crear las bases de datos vacías en cletus:

mysql -u root -p
CREATE DATABASE exampledb;
quit;

Ahora configuraremos la replicación maestro-maestro en /etc/mysql/my.cnf. Las opciones de configuración cruciales para la replicación maestro-maestro son auto_increment_increment y auto_increment_offset:

  • Auto_increment_increment controla el incremento entre los sucesivos valores AUTO_INCREMENT.
  • Auto_increment_offset determina el punto de partida para los valores de la columna AUTO_INCREMENT.

Supongamos que tenemos N nodos MySQL (N = 2 en este ejemplo), entonces auto_increment_increment tiene el valor N en todos los nodos, y cada nodo debe tener un valor diferente para auto_increment_offset (1, 2, …, N).

Hay que tener en cuenta que para copiar las BD InnoDB voy a parar el servicio mysql (no ha reiniciarlo), por lo que primero vamos a realizar la replicación de las BD MyIsam.

En skinner:

vi /etc/mysql/my.cnf

[mysqld]
#
#* Basic Settings
#

#
#* IMPORTANT
#If you make changes to these settings and your system uses apparmor, you may
#also need to also adjust /etc/apparmor.d/usr.sbin.mysqld.
#

user = mysql
pid-file = /var/run/mysqld/mysqld.pid
socket = /var/run/mysqld/mysqld.sock
port = 3306
basedir = /usr
#datadir = /var/lib/mysql
datadir = /home/datos/mysql
tmpdir = /tmp
language = /usr/share/mysql/english
skip-external-locking
skip-name-resolve
#
#Instead of skip-networking the default is now to listen only on
#localhost which is more compatible and is not less secure.
#bind-address = 127.0.0.1
#
#* Fine Tuning
#
key_buffer = 16M
max_allowed_packet = 16M
thread_stack = 128K
thread_cache_size = 8
#This replaces the startup script and checks MyISAM tables if needed
#the first time they are touched
myisam-recover = BACKUP
#max_connections = 100
#table_cache = 64
#thread_concurrency = 10
#
#* Query Cache Configuration
#
query_cache_limit = 1M
query_cache_size = 16M
#
#* Logging and Replication
#
#Both location gets rotated by the cronjob.
#Be aware that this log type is a performance killer.
#log = /var/log/mysql/mysql.log
#
#Error logging goes to syslog. This is a Debian improvement :)
#
#Here you can see queries with especially long duration
#log_slow_queries = /var/log/mysql/mysql-slow.log
#long_query_time = 2
#log-queries-not-using-indexes
#
#The following can be used as easy to replay backup logs or for replication.
#note: if you are setting up a replication slave, see README.Debian about
#other settings you may need to change.
server-id = 1
replicate-same-server-id = 0
auto-increment-increment = 2
auto-increment-offset = 1

master-host = 192.168.0.9
master-user = slaveskinner
master-password = slaveskinnerpassword
master-connect-retry = 60
replicate-do-db = telcommunity
replicate-do-db = webpanelsuzuki
#replicate-do-db = wiloc
#replicate-do-db = GestorMarketing
#replicate-do-db = plataforma
#replicate-do-db = radiusSeasuntel
#replicate-do-db = rss

log_bin = /home/datos/mysql/mysql-bin.log
expire_logs_days = 10
max_binlog_size = 500M
binlog_do_db = telcommunity
binlog_do_db = webpanelsuzuki
#binlog_do_db = wiloc
#binlog_do_db = GestorMarketing
#binlog_do_db = plataforma
#binlog_do_db = radiusSeasuntel
#binlog_do_db = rss
#binlog_ignore_db = include_database_name

relay-log = /home/datos/mysql/slave-relay.log
relay-log-index = /home/datos/mysql/slave-relay-log.index

#Y en el apartado de InnoDB:
<- skip-innodb
-> #skip-innodb

Aunque configuremos el archivo para replicar todas las BD, comento las InnoDB para que una vez replicadas las MyIsam las descomentemos y hagamos su replicación.

Reiniciamos el servicio:

/etc/init.d/mysql restart

En cletus:

vi /etc/mysql/my.cnf

[mysqld]
#
#* Basic Settings
#

#
#* IMPORTANT
#If you make changes to these settings and your system uses apparmor, you may
#also need to also adjust /etc/apparmor.d/usr.sbin.mysqld.
#

user = mysql
pid-file = /var/run/mysqld/mysqld.pid
socket = /var/run/mysqld/mysqld.sock
port = 3306
basedir = /usr
datadir = /var/lib/mysql
tmpdir = /tmp
language = /usr/share/mysql/english
skip-external-locking
skip-name-resolve
#
#Instead of skip-networking the default is now to listen only on
#localhost which is more compatible and is not less secure.
#bind-address = 127.0.0.1
#
#* Fine Tuning
#
key_buffer = 16M
max_allowed_packet = 16M
thread_stack = 128K
thread_cache_size = 8
#max_connections = 100
#table_cache = 64
#thread_concurrency = 10
#
#* Query Cache Configuration
#
query_cache_limit = 1M
query_cache_size = 16M
#
#* Logging and Replication
#
#Both location gets rotated by the cronjob.
#Be aware that this log type is a performance killer.
#log = /var/log/mysql/mysql.log
#
#Error logging goes to syslog. This is a Debian improvement :)
#
#Here you can see queries with especially long duration
#log_slow_queries = /var/log/mysql/mysql-slow.log
#long_query_time = 2
#log-queries-not-using-indexes
#
#The following can be used as easy to replay backup logs or for replication.
#note: if you are setting up a replication slave, see README.Debian about
#other settings you may need to change.
server-id = 2
replicate-same-server-id = 0
auto-increment-increment = 2
auto-increment-offset = 2

master-host = 192.168.0.2
master-user = slavecletus
master-password = slavecletuspassword
master-connect-retry = 60
replicate-do-db = telcommunity
replicate-do-db = webpanelsuzuki
#replicate-do-db = wiloc
#replicate-do-db = GestorMarketing
#replicate-do-db = plataforma
#replicate-do-db = radiusSeasuntel
#replicate-do-db = rss

log_bin = /var/lib/mysql/mysql-bin.log
expire_logs_days = 10
max_binlog_size = 500M
binlog_do_db = telcommunity
binlog_do_db = webpanelsuzuki
#binlog_do_db = wiloc
#binlog_do_db = GestorMarketing
#binlog_do_db = plataforma
#binlog_do_db = radiusSeasuntel
#binlog_do_db = rss
#binlog_ignore_db = include_database_name

relay-log = /var/lib/mysql/slave-relay.log
relay-log-index = /var/lib/mysql/slave-relay-log.index

#Y en el apartado de InnoDB:
<- skip-innodb
-> #skip-innodb

Reiniciamos el servicio:

/etc/init.d/mysql restart

A continuación bloqueamos las bases de datos en skinner, vemos la situación del maestro skinner, creamos un volcado SQL de telcommunity y webpanelsuzuki (que vamos a importar en cletus a fin de que ambos servidores contengan las misma BD con los mismos datos), y desbloqueamos las bases de datos a fin de que pueda ser utilizada de nuevo:

mysql -u root -p
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;

El último comando debería mostrar algo como esto (anotar File y Position, los necesitaremos más adelante):

+——————+———-+————–+——————+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+——————+———-+————–+——————+
| mysql-bin.000009 | 98 | telcommunity,webpanelsuzuki | |
+——————+———-+————–+——————+
1 row in set (0.00 sec)

Ahora sin salir del shell de MySQL, porque si la deja, el bloqueo de las bases de datos será removido. Mientras el shell de MySQL está todavía abierto, abrimos una segunda ventana de línea de comandos donde creamos los volcados SQL y los transferimos a cletus (usando scp):

cd /tmp
mysqldump -u root -pyourrootsqlpassword —opt telcommunity > telcommunity.sql
mysqldump -u root -pyourrootsqlpassword —opt webpanelsuzuki > webpanelsuzuki.sql
scp telcommunity.sql webpanelsuzuki.sql 9.0.861.291|toor#9.0.861.291|toor:/tmp

Ya puede cerrar la segunda ventana de línea de comandos. En la primera ventana ahora podemos desbloquear la base de datos y dejar el shell de MySQL:

UNLOCK TABLES;
quit;

En cletus ahora podemos importar los volcados SQL:

mysqladmin —user=root —password=yourrootsqlpassword stop-slave
cd /tmp
mysql -u root -pyourrootsqlpassword telcommunity < telcommunity.sql
mysql -u root -pyourrootsqlpassword webpanelsuzuki < webpanelsuzuki.sql

Después, vemos el estado del maestro en cletus y lo anotamos:

mysql -u root -p
FLUSH TABLES WITH READ LOCK;
SHOW MASTER STATUS;

+——————+———-+————–+——————+
| File | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+——————+———-+————–+——————+
| mysql-bin.000009 | 783 | telcommunity,webpanelsuzuki | |
+——————+———-+————–+——————+
1 row in set (0.00 sec)

Desbloquee las tablas:

UNLOCK TABLES;

Ejecutamos el siguiente comando para hacer a cletus escalvo de skinner (es importante que reemplace los valores en el siguiente comando con los valores que anoto del comando SHOW MASTER STATUS; que fué ejecutado en skinner):

CHANGE MASTER TO MASTER_HOST='192.168.0.2', MASTER_USER='slavecletus', MASTER_PASSWORD='slavecletuspassword', MASTER_LOG_FILE='mysql-bin.000009', MASTER_LOG_POS=98;

Finalmente iniciamos el esclavo y verificamos su estado:

START SLAVE;
SHOW SLAVE STATUS;

Es importante que ambos Slave_IO_Running y Slave_SQL_Running tengan el valor Yes en la salida (de otro modo algo salió mal, y deberiamos comprobar su configuración de nuevo y echar un vistazo a /var/log/syslog para averiguar acerca de cualquier error):

+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Slave_IO_State | Master_Host | Master_User | Master_Port | Connect_Retry | Master_Log_File | Read_Master_Log_Pos | Relay_Log_File | Relay_Log_Pos | Relay_Master_Log_File | Slave_IO_Running | Slave_SQL_Running | Replicate_Do_DB | Replicate_Ignore_DB | Replicate_Do_Table | Replicate_Ignore_Table | Replicate_Wild_Do_Table | Replicate_Wild_Ignore_Table | Last_Errno | Last_Error | Skip_Counter | Exec_Master_Log_Pos | Relay_Log_Space | Until_Condition | Until_Log_File | Until_Log_Pos | Master_SSL_Allowed | Master_SSL_CA_File | Master_SSL_CA_Path | Master_SSL_Cert | Master_SSL_Cipher | Master_SSL_Key | Seconds_Behind_Master |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Waiting for master to send event | 192.168.0.2 | slavecletus | 3306 | 60 | mysql-bin.000009 | 98 | slave-relay.000002 | 235 | mysql-bin.000009 | Yes | Yes | telcommunity,webpanelsuzuki | | | | | | 0 | | 0 | 98 | 235 | None | | 0 | No | | | | | | 0 |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
1 row in set (0.00 sec)

La replicación desde skinner a cletus ya está configurada, ahora debemos configurar la replicación desde cletus a skinner.

Para hacer esto, paramos el esclavo en skinner y hacemos a este un esclavo de cletus

mysql -u root -p
STOP SLAVE;

Asegurese de utilizar los valores del comando SHOW MASTER STATUS; que ejecutamos en cletus en el siguiente comando:

CHANGE MASTER TO MASTER_HOST='192.168.0.9', MASTER_USER='slaveskinner', MASTER_PASSWORD='slaveskinnerpassword', MASTER_LOG_FILE='mysql-bin.000009', MASTER_LOG_POS=783;

Iniciamos el esclavo en skinner y verificamos su estado:

START SLAVE;
SHOW SLAVE STATUS;

Es importante que ambos Slave_IO_Running y Slave_SQL_Running tengan el valor Yes en la salida (de otro modo algo salió mal, y deberiamos comprobar su configuración de nuevo y echar un vistazo a /var/log/syslog para averiguar acerca de cualquier error):

+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Slave_IO_State | Master_Host | Master_User | Master_Port | Connect_Retry | Master_Log_File | Read_Master_Log_Pos | Relay_Log_File | Relay_Log_Pos | Relay_Master_Log_File | Slave_IO_Running | Slave_SQL_Running | Replicate_Do_DB | Replicate_Ignore_DB | Replicate_Do_Table | Replicate_Ignore_Table | Replicate_Wild_Do_Table | Replicate_Wild_Ignore_Table | Last_Errno | Last_Error | Skip_Counter | Exec_Master_Log_Pos | Relay_Log_Space | Until_Condition | Until_Log_File | Until_Log_Pos | Master_SSL_Allowed | Master_SSL_CA_File | Master_SSL_CA_Path | Master_SSL_Cert | Master_SSL_Cipher | Master_SSL_Key | Seconds_Behind_Master |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Waiting for master to send event | 192.168.0.101 | slave1_user | 3306 | 60 | mysql-bin.000009 | 783 | slave-relay.000002 | 235 | mysql-bin.000009 | Yes | Yes | exampledb | | | | | | 0 | | 0 | 783 | 235 | None | | 0 | No | | | | | | 0 |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
1 row in set (0.00 sec)

Si nada salió mal, la replicación MySQL maestro-maestro ahora debe estar funcionando. Si no es así, por favor consulte el /var/log/syslog por errores MySQL en skinner y cletus.

Pasamos ahora a la replicación de las BD InnoDB:

Paramos el servicio mysql en ambos servidores:

/etc/init.d/mysql stop

Pasamos la estructura de las BD de skinner a cletus:

cd /home/datos/mysql
tar -czvf /tmp/wiloc.gz wiloc/*
tar -czvf /tmp/rss.gz rss/*
tar -czvf /tmp/plataforma.gz plataforma/*
tar -czvf /tmp/GestorMarketing.gz GestorMarketing/*
tar -czvf /tmp/radiusSeasuntel.gz radiusSeasuntel/*
cd /tmp
scp -i /home/user/.ssh/id-rsa wiloc.gz rss.gz plataforma.gz GestorMarketing.gz radiusSeasuntel.gz 9.0.861.291|resu#9.0.861.291|resu:/tmp

Descomentamos las BD correspondientes en el archvo my.cnf de ambos servidores:

vi /etc/mysql/my.cnf

<- #replicate-do-db = wiloc
<- #replicate-do-db = GestorMarketing
<- #replicate-do-db = plataforma
<- #replicate-do-db = radiusSeasuntel
<- #replicate-do-db = rss
-> replicate-do-db = wiloc
-> replicate-do-db = GestorMarketing
-> replicate-do-db = plataforma
-> replicate-do-db = radiusSeasuntel
-> replicate-do-db = rss

<- #binlog_do_db = wiloc
<- #binlog_do_db = GestorMarketing
<- #binlog_do_db = plataforma
<- #binlog_do_db = radiusSeasuntel
<- #binlog_do_db = rss
-> binlog_do_db = wiloc
-> binlog_do_db = GestorMarketing
-> binlog_do_db = plataforma
-> binlog_do_db = radiusSeasuntel
-> binlog_do_db = rss

Iniciamos el servicio mysql y miramos el estado del maestro:

/etc/init.c/mysql start

En cletus:

Copiamos las BD pasadas de skinner en mysql:

cd /tmp
tar -xzvf wiloc.gz /var/lib/mysql/wiloc/
tar -xzvf rss.gz /var/lib/mysql/rss/
tar -xzvf plataforma.gz /var/lib/mysql/plataforma/
tar -xzvf GestorMarketing.gz /var/lib/mysql/GestorMarketing/
tar -xzvf radiusSeasuntel.gz /var/lib/mysql/radiusSeasuntel/

Iniciamos el servicio mysql:

/etc/init.d/mysql start

Hasta aquí nos ha servido para copiar la estructura de las BD de skinner a cletus, ahora traspasaremos los datos.

En skinner:

cd /tmp
mysqldump —single-transaction -u root -pyourrootsqlpassword wiloc > wiloc.sql
mysqldump —single-transaction -u root -pyourrootsqlpassword rss > rss.sql
mysqldump —single-transaction -u root -pyourrootsqlpassword plataforma > plataforma.sql
mysqldump —single-transaction -u root -pyourrootsqlpassword GestorMarketing > GestorMarketing.sql
mysqldump —single-transaction -u root -pyourrootsqlpassword radiusSeasuntel > radiusSeasuntel.sql
scp -i /home/user/.ssh/id-rsa wiloc.sql rss.sql plataforma.sql GestorMarketing.sql radiusSeasuntel.sql 9.0.861.291|resu#9.0.861.291|resu:/tmp

En cletus:

Paramos el esclavo de mysql:

mysqladmin —user=root —password=yourrootsqlpassword stop-slave

Insertamos los datos en las tablas:

mysql -u root -pyourrootsqlpassword wiloc < wiloc.sql
mysql -u root -pyourrootsqlpassword rss < rss.sq
mysql -u root -pyourrootsqlpassword plataforma < plataforma.sql
mysql -u root -pyourrootsqlpassword GestorMarketing < GestorMarketing.sql
mysql -u root -pyourrootsqlpassword radiusSeasuntel < radiusSeasuntel.sql

Vemos el estado del maestro:

mysql -u root -p
show master status;

Ejecutamos este comando con los datos obtenidos del estado del maestro en skinner:

CHANGE MASTER TO MASTER_HOST='192.168.0.2', MASTER_USER='slavecletus', MASTER_PASSWORD='slavecletuspassword', MASTER_LOG_FILE='mysql-bin.000XXX', MASTER_LOG_POS=XXX;

Arrancamos el slave y miramos su estado:

start slave;
show slave status;

Es importante que ambos Slave_IO_Running y Slave_SQL_Running tengan el valor Yes en la salida (de otro modo algo salió mal, y deberiamos comprobar su configuración de nuevo y echar un vistazo a /var/log/syslog para averiguar acerca de cualquier error):

La replicación desde skinner a cletus ya está configurada, ahora debemos configurar la replicación desde cletus a skinner.

Para hacer esto, paramos el esclavo en skinner y hacemos a este un esclavo de cletus

mysql -u root -p
STOP SLAVE;

Asegurese de utilizar los valores del comando SHOW MASTER STATUS; que ejecutamos en cletus en el siguiente comando:

CHANGE MASTER TO MASTER_HOST='192.168.0.9', MASTER_USER='slaveskinner', MASTER_PASSWORD='slaveskinnerpassword', MASTER_LOG_FILE='mysql-bin.000009', MASTER_LOG_POS=783;

Iniciamos el esclavo en skinner y verificamos su estado:

START SLAVE;
SHOW SLAVE STATUS;

Es importante que ambos Slave_IO_Running y Slave_SQL_Running tengan el valor Yes en la salida (de otro modo algo salió mal, y deberiamos comprobar su configuración de nuevo y echar un vistazo a /var/log/syslog para averiguar acerca de cualquier error):

+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Slave_IO_State | Master_Host | Master_User | Master_Port | Connect_Retry | Master_Log_File | Read_Master_Log_Pos | Relay_Log_File | Relay_Log_Pos | Relay_Master_Log_File | Slave_IO_Running | Slave_SQL_Running | Replicate_Do_DB | Replicate_Ignore_DB | Replicate_Do_Table | Replicate_Ignore_Table | Replicate_Wild_Do_Table | Replicate_Wild_Ignore_Table | Last_Errno | Last_Error | Skip_Counter | Exec_Master_Log_Pos | Relay_Log_Space | Until_Condition | Until_Log_File | Until_Log_Pos | Master_SSL_Allowed | Master_SSL_CA_File | Master_SSL_CA_Path | Master_SSL_Cert | Master_SSL_Cipher | Master_SSL_Key | Seconds_Behind_Master |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
| Waiting for master to send event | 192.168.0.101 | slave1_user | 3306 | 60 | mysql-bin.000009 | 783 | slave-relay.000002 | 235 | mysql-bin.000009 | Yes | Yes | exampledb | | | | | | 0 | | 0 | 783 | 235 | None | | 0 | No | | | | | | 0 |
+------—+---+---+---+---+----+-----+----+---+-----+----+---—+---+-----+----+----—+-----+-----+--+--+--+---—+---+---+--—+---+----+----+----+---+---—+--—+-----+
1 row in set (0.00 sec)

Si nada salió mal, la replicación MySQL maestro-maestro ahora debe estar funcionando. Si no es así, por favor consulte el /var/log/syslog por errores MySQL en skinner y cletus.

Asegurese de utilizar los valores del comando SHOW MASTER STATUS; que ejecutamos en cletus en el siguiente comando:

CHANGE MASTER TO MASTER_HOST='192.168.0.9', MASTER_USER='slaveskinner', MASTER_PASSWORD='slaveskinnerpassword', MASTER_LOG_FILE='mysql-bin.000XXX', MASTER_LOG_POS=XXX;

Iniciamos el esclavo en skinner y verificamos su estado:

START SLAVE;
SHOW SLAVE STATUS;

Es importante que ambos Slave_IO_Running y Slave_SQL_Running tengan el valor Yes en la salida (de otro modo algo salió mal, y deberiamos comprobar su configuración de nuevo y echar un vistazo a /var/log/syslog para averiguar acerca de cualquier error):

Si nada salió mal, la replicación MySQL maestro-maestro ahora debe estar funcionando. Si no es así, por favor consulte el /var/log/syslog por errores MySQL en skinner y cletus.


Completar con replicación Mysql + SSL

No te olvides que esto es complementario a todo lo anterior, debes seguir teniendo en cuenta todo lo mencionado, como por ejemplo, que para poder ver el estado del master (show master status), es necesario que en el archivo de configuración my.cnf esté activado el campo:

log_bin                 = /home/datos/mysql/mysql-bin.log

En resumen:

En skinner:

Create CA certificate:

openssl genrsa 2048 > skinner-ca-key.pem
openssl req -new -x509 -nodes -days 1000 -key skinner-ca-key.pem > skinner-ca-cert.pem

Create server certificate:

openssl req -newkey rsa:2048 -days 1000 -nodes -keyout skinner-server-key.pem > skinner-server-req.pem
openssl x509 -req -in skinner-server-req.pem -days 1000 -CA skinner-ca-cert.pem -CAkey skinner-ca-key.pem -set_serial 01 > skinner-server-cert.pem

Create client certificate:

openssl req -newkey rsa:2048 -days 1000 -nodes -keyout skinner-client-key.pem > skinner-client-req.pem
openssl x509 -req -in skinner-client-req.pem -days 1000 -CA skinner-ca-cert.pem -CAkey skinner-ca-key.pem -set_serial 01 > skinner-client-cert.pem

Copiamos los certificados necesarios en cletus:

scp -i /home/ldiaz/.ssh/id_rsa skinner-ca-cert.pem skinner-client-cert.pem skinner-client-key.pem ldiaz@192.168.0.9:~

Configurar ssl:

vi /etc/mysql/my.cnf

[...]
# * Security Features
#
# Read the manual, too, if you want chroot!
# chroot = /var/lib/mysql/
#
# For generating SSL certificates I recommend the OpenSSL GUI "tinyca".
ssl
ssl-ca=/etc/mysql/skinner-ca-cert.pem
ssl-cert=/etc/mysql/skinner-server-cert.pem
ssl-key=/etc/mysql/skinner-server-key.pem
[...]

Dar permisos de replicación al usuario:

GRANT REPLICATION SLAVE ON *.* TO 'slavecletus'@'192.168.0.9' IDENTIFIED BY 'slave_password' REQUIRE SSL;

NOTA

En el ejemplo de la fuente mencionan que si ya teníamos un usuario de replicación, podemos dejar que se conecte tanto con una password normal, como con ssl, las 2 a la vez, o solo por ssl. He probado a quitarle el acceso mediante password normal, solo accediendo mediante ssl y no me ha salido, lanzaba un error de que el usuario usaba password. He utilizado la opción de usar ambas conjuntamente y entonces ha salido bien.

Sincronizar servidores:

- observa que los certificados son los correspondientes al otro servidor (cletus), los copiaremos depueś.

stop slave;

CHANGE MASTER TO MASTER_HOST='192.168.0.9', MASTER_USER='slaveskinner', MASTER_PASSWORD='slave_password', MASTER_LOG_FILE='mysql-bin.0000XX', MASTER_LOG_POS=XX, MASTER_SSL=1, MASTER_SSL_CA = '/etc/mysql/cletus-ca-cert.pem', MASTER_SSL_CERT = '/etc/mysql/celtus-client-cert.pem', MASTER_SSL_KEY = '/etc/mysql/celtus-client-key.pem';

start slave;

En cletus:

Create CA certificate:

openssl genrsa 2048 > cletus-ca-key.pem
openssl req -new -x509 -nodes -days 1000 -key cletus-ca-key.pem > cletus-ca-cert.pem

Create server certificate:

openssl req -newkey rsa:2048 -days 1000 -nodes -keyout cletus-server-key.pem > cletus-server-req.pem
openssl x509 -req -in cletus-server-req.pem -days 1000 -CA cletus-ca-cert.pem -CAkey cletus-ca-key.pem -set_serial 01 > cletus-server-cert.pem

Create client certificate:

openssl req -newkey rsa:2048 -days 1000 -nodes -keyout cletus-client-key.pem > cletus-client-req.pem
openssl x509 -req -in cletus-client-req.pem -days 1000 -CA v-ca-cert.pem -CAkey cletus-ca-key.pem -set_serial 01 > cletus-client-cert.pem

Copiamos los certificados necesarios en skinner:

scp -i /home/ldiaz/.ssh/id_rsa cletus-ca-cert.pem cletus-client-cert.pem cletus-client-key.pem ldiaz@192.168.0.2:~

Configurar ssl:

vi /etc/mysql/my.cnf

[...]
# * Security Features
#
# Read the manual, too, if you want chroot!
# chroot = /var/lib/mysql/
#
# For generating SSL certificates I recommend the OpenSSL GUI "tinyca".
ssl
ssl-ca=/etc/mysql/cletus-ca-cert.pem
ssl-cert=/etc/mysql/cletus-server-cert.pem
ssl-key=/etc/mysql/cletus-server-key.pem
[...]

Dar permisos de replicación al usuario:

GRANT REPLICATION SLAVE ON *.* TO 'slaveskinner'@'192.168.0.2' IDENTIFIED BY 'slave_password' REQUIRE SSL;

Sincronizar servidores:

- observa que los certificados son los que copiamos del otro servidor (skinner).

CHANGE MASTER TO MASTER_HOST='192.168.0.2', MASTER_USER='slavecletus', MASTER_PASSWORD='slave_password', MASTER_LOG_FILE='mysql-bin.0000XX', MASTER_LOG_POS=XX, MASTER_SSL=1, MASTER_SSL_CA = '/etc/mysql/skinner-ca-cert.pem', MASTER_SSL_CERT = '/etc/mysql/skinner-client-cert.pem', MASTER_SSL_KEY = '/etc/mysql/skinner-client-key.pem';

Completar con replicación Mysql retrasada

Recuerda que esto es complementario a todo lo anterior, debes seguir teniendo en cuenta todo lo mencionado, como por ejemplo, que para poder ver el estado del master (show master status), es necesario que en el archivo de configuración my.cnf esté activado el campo:

log_bin                 = /home/datos/mysql/mysql-bin.log

Para evitar que en las BBDDs replicadas se propague cualquier problema que pueda surgir en las BBDDs del master, se ha creado un script en el slave para retrasar dicha replicación:

En cletus:

crontab -e
05 06 * * * /home/ulysse/scripts/mysql/replication.sh

replication.sh

#!/bin/bash

/home/ulysse/scripts/mysql/replication.conf

replication.conf

#!/bin/bash

# Script que levanta el slave de mysql para que sincronice con su master y una vez sincronizados lo vuelve a parar.
# Esto se hace para que la replicación no sea instantanea, evitando así la propagación de cualquier posible error
# en las BBDDs originales.

# $status: valor semáforo para salir del while (0:continuar 1:salir)
# $user: usuario mysql
# $pass: contraseña mysql de usuario $user
# $result: indica si se han sincronizado

status="0"
user="XXXX"
pass="XXXXXXXX"

# Se levanta el slave

mysqladmin -u $user -p$pass start-slave 1>/dev/null

# Al levantar el slave se inicia automáticamente la replicación, se detecta cuando estan sincronizados
# y se detiene de nuevo el slave.

while [ "$status" = "0" ]
        do

                # Se mira el tiempo de retardo del slave, si está a 0 ha terminado de replicar
                # y está a la espera de nuevos registros, por lo que se para.

        sleep 10 # Tiempo estimado en segundos de la duracion de la replica.

                mysql -u $user -p$pass -e "show slave status \G" > /tmp/mysql-replication.log
                result=$(grep "Seconds_Behind_Master: 0" "/tmp/mysql-replication.log")
                if [ "$result" != "" ]; then
                        status="1"
                        mysqladmin -u $user -p$pass stop-slave 1>/dev/null
                fi
        done

Para parar el slave en cletus:

mysqladmin -u root -p stop-slave

« Linux

Si no se indica lo contrario, el contenido de esta página se ofrece bajo Creative Commons Attribution-ShareAlike 3.0 License