How To Set Up MySQL Master-Master Replication

 https://www.digitalocean.com/community/tutorials/how-to-set-up-mysql-master-master-replication

Posted Apr 26, 2013

49

311.1k views MySQL Scaling Backups

Intro

This second installment of "Scaling Web Applications" will list out the steps necessary for scaling a mysql deployment over two VPS.
The first article in this series laid out the steps needed to load-balance nginx over two VPS, and it is recommended that you read that article first.
MySQL replication is the process by which a single data set, stored in a MySQL database, will be live-copied to a second server. This configuration, called "master-slave" replication, is a typical setup. Our setup will be better than that, because master-master replication allows data to be copied from either server to the other one. This subtle but important difference allows us to perform mysql read or writes from either server. This configuration adds redundancy and increases efficiency when dealing with accessing the data.
The examples in this article will be based on two VPS, named Server C and Server D.
Server C: 3.3.3.3
Server D: 4.4.4.4

Step 1 - Install and Configure MySQL on Server C

The first thing we need to do is to install the mysql-server and mysql-client packages on our server. We can do that by typing the following:

sudo apt-get install mysql-server mysql-client

By default, the mysql process will only accept connections on localhost (127.0.0.1). To change this default behavior and change a few other settings necessary for replication to work properly, we need to edit /etc/mysql/my.cnf on Server C. There are four lines that we need to change, which are currently set to the following:

#server-id              = 1
#log_bin                = /var/log/mysql/mysql-bin.log
#binlog_do_db           = include_database_name
bind-address            = 127.0.0.1

The first of those lines is to uniquely identify our particular server, in our replication configuration. We need to uncomment that line, by removing the "#" before it. The second line indicates the file in which changes to any mysql database or table will be logged.
The third line indicates which databases we want to replicate between our servers. You can add as many databases to this line as you'd like. The article will use a single database named "example" for the purposes of simplicity. And the last line tells our server to accept connections from the internet (by not listening on 127.0.0.1).

server-id               = 1
log_bin                 = /var/log/mysql/mysql-bin.log
binlog_do_db            = example
# bind-address            = 127.0.0.1

Now we need to restart mysql:

sudo service mysql restart

We next need to change some command-line settings within our mysql instance. Back at our shell, we can get to our root mysql user by typing the following:

mysql -u root -p 

Please note that the password this command will prompt you for is that of the root mysql user, not the root user on our droplet. To confirm that you are logged in to the mysql shell, the prompt should look like the following.

mysql> 

Once we are logged in, we need to run a few commands.
We need to create a pseudo-user that will be used for replicating data between our two VPS. The examples in this article will assume that you name this user "replicator". Replace "password" with the password you wish to use for replication.

create user 'replicator'@'%' identified by 'password'; 

Next, we need to give this user permissions to replicate our mysql data:

grant replication slave on *.* to 'replicator'@'%'; 

Permissions for replication cannot, unfortunately, be given on a per-database basis. Our user will only replicate the database(s) that we instruct it to in our config file.
For the final step of the initial Server C configuration, we need to get some information about the current MySQL instance which we will later provide to Server D.
The following command will output a few pieces of important information, which we will need to make note of:

show master status; 

The output will looking similiar to the following, and will have two pieces of critical information:

+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000001 |      107 | example      |                  |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

We need to make a note of the file and position which will be used in the next step.

Step 2 - Install and Configure MySQL on Server D

We need to repeat the same steps that we followed on Server C. First we need to install it, which we can do with the following command:

sudo apt-get install mysql-server mysql-client

Once the two packages are properly installed, we need to configure it in much the same way as we configured Server C. We will start by editing the /etc/mysql/my.cnf file.

sudo nano /etc/mysql/my.cnf 

We need to change the same four lines in the configuration file as we changed earlier.
The defaults are listed below, followed by the changes we need to make.

#server-id              = 1
#log_bin                = /var/log/mysql/mysql-bin.log
#binlog_do_db           = include_database_name
bind-address            = 127.0.0.1

We need to change these four lines to match the lines below. Please note, that unlike Server C, the server-id for Server D cannot be set to 1.

server-id              = 2
log_bin                = /var/log/mysql/mysql-bin.log
binlog_do_db           = example
# bind-address            = 127.0.0.1

After you save and quit that file, you need to restart mysql:

sudo service mysql restart

It is time to go into the mysql shell and set some more configuration options.

mysql -u root -p 

First, just as on Server C, we are going to create the pseudo-user which will be responsible for the replication. Replace "password" with the password you wish to use.

create user 'replicator'@'%' identified by 'password'; 

Next, we need to create the database that we are going to replicate across our VPS.

create database example; 

And we need to give our newly created 'replication' user permissions to replicate it.

grant replication slave on *.* to 'replicator'@'%'; 

The next step involves taking the information that we took a note of earlier and applying it to our mysql instance. This will allow replication to begin. The following should be typed at the mysql shell:

slave stop; 
CHANGE MASTER TO MASTER_HOST = '3.3.3.3', MASTER_USER = 'replicator', MASTER_PASSWORD = 'password', MASTER_LOG_FILE = 'mysql-bin.000001', MASTER_LOG_POS = 107; 
slave start; 

You need to replace 'password' with the password that you have chosen for replication. Your values for MASTER_LOG_FILE and MASTER_LOG_POS may differ than those above. You should copy the values that "SHOW MASTER STATUS" returns on Server C.
The last thing we have to do before we complete the mysql master-master replication is to make note of the master log file and position to use to replicate in the other direction (from Server D to Server C).
We can do that by typing the following:

SHOW MASTER STATUS; 

The output will look similiar to the following:

+------------------+----------+--------------+------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB |
+------------------+----------+--------------+------------------+
| mysql-bin.000004 |      107 | example      |                  |
+------------------+----------+--------------+------------------+
1 row in set (0.00 sec)

Take note of the file and position, as we will have to enter those on server C, to complete the two-way replication.
The next step will explain how to do that.

Step 3 - Completing Replication on Server C

Back on Server C, we need to finish configuring replication on the command line. Running this command will replicate all data from Server D.

 
slave stop; 
CHANGE MASTER TO MASTER_HOST = '4.4.4.4', MASTER_USER = 'replicator', MASTER_PASSWORD = 'password', MASTER_LOG_FILE = 'mysql-bin.000004', MASTER_LOG_POS = 107; 
slave start; 

Keep in mind that your values may differ from those above. Please also replace the value of MASTER_PASSWORD with the password you created when setting up the replication user.
The output will look similiar to the following:

Query OK, 0 rows affected (0.01 sec)

The last thing to do is to test that replication is working on both VPS. The last step will explain an easy way to test this configuration.

Step 4 - Testing Master-Master Replication

Now that have all the configuration set up, we are going to test it now. To do this, we are going to create a table in our example database on Server C and check on Server D to see if it shows up. Then, we are going to delete it from Server D and make sure it's no longer showing up on Server C.
We now need to create the database that will be replicated between the servers. We can do that by typing the following at the mysql shell:

create database example; 

Once that's done, let's create a dummy table on Server C:

create table example.dummy (`id` varchar(10)); 

We now are going to check Server D to see if our table exists.

 
show tables in example; 

We should see output similiar to the following:

+-------------------+
| Tables_in_example |
+-------------------+
| dummy             |
+-------------------+
1 row in set (0.00 sec)

The last test to do is to delete our dummy table from Server D. It should also be deleted from Server C.
We can do this by entering the following on Server D:

DROP TABLE dummy; 

To confirm this, running the "show tables" command on Server C will show no tables:

Empty set (0.00 sec)

And there you have it! Working mysql master-master replication. As always, any feedback is more than welcome

Programar en Bash, pequeño manual de referencia [Cheat Sheet]

Escrito por Manuel Ignacio López Quintero 8th junio 2010 in Tutoriales con 14

Aquí os dejo mi cheat sheet, o pequeño manual de referencia, personal sobre Bash. Faltan cosas pero creo que he cubierto lo más básico. Espero que os guste.

1. Cómo ejecutar scripts Bash

Para escribir en Bash puedes hacerlo directamente desde la consola/terminal de GNU/Linux, sin embargo, su mayor potencia radica en poder escribir ‘scripts’ y ejecutar piezas de código para automatizar tareas. Aquí muestro paso a paso un ejemplo.

1.1. Escribe un ‘script’ Bash

Abre tu editor de textos favoritos y escribe el siguiente código.

#!/bin/bash
echo "Hola mundo"

Guárdalo como holamundo.sh (la extensión no importa pero ésta es renococida por muchos editores de texto) .

1.2. Dale permisos

Para lanzar el ‘script’ Bash, dále permisos de ejecución. Para ello escribe en tu terminal/consola de comandos:
chmod u+x holamundo.sh
Recuerda ejecutar este comando y los siguientes en la misma carpeta/directorio donde se encuentra holamundo.sh

1.3. Ejecútalo

Lanza el ‘script’ ejecutando en tu terminal/consola:
./holamundo.sh
Si no ha habido ningún problema se ejecutará el ‘script’ de Bash mostrando la frase “Hola mundo”.

2. Características Bash

Aquí se mostrarán las características de dicho intérprete de comandos o shell de GNU. Recuerda que los comandos son las acciones a ejecutar desde la consola/terminal Linux. En la siguiente sección hay una recopilación de ellos.

2.1. Comentarios

Los comentarios en Bash se hacen línea a línea con el símbolo #.

#!/bin/bash

#
# Hola Mundo comentado
#

echo "Hola mundo"

2.2. Variables

Las variables no tienen tipo, es decir, una variable puede contener una cadena, un número, etc. sin necesidad de definirlo.
La sintaxis es:
nombre_variable=valor_variable
Es obligatorio no dejar espacios antes o despues del simbolo ‘=’ ya que sino Bash interpretaría la variable como un comando Linux.
Para acceder a una variable simplemente escribe como prefijo $ en el nombre de la variable.
echo $varname
Un ejemplo sencillo:

#!/bin/bash

# Asignación y salida de variables

mivariable="Me llamo Nacho"
echo $mivariable

2.2.1. Paso de variables

Cuando ejecutas desde tu terminal/consola tienes la posibilidad de pasarle más argumentos. Por ejemplo:
./miScript.sh hola 4
Para recoger estos valores escribe $ y a continuación el número de posición del argumento pasado. El primer argumento tiene valor $1, que sería ‘hola’, y el segundo argumento sería $2, en el ejemplo sería el número 4. La variable $0 es el propio nombre del archivo.

#!/bin/bash

#
# Paso de variables
#

echo "Tu primer argumento es" $1
echo "Tu segundo argumento es" $2

También hay que destacar que $? guarda el valor de salida del último comando ejecutado. $* almacena todos los argumentos y $# es el número de argumentos pasados.

2.3. Comparaciones y/o expresiones

Los condicionales y bucles se rigen mediante la evaluación de una expresión. Por eso lo primero es saber cómo programar en Bash las evaluaciones de una expresión.
La evaluación de una expresión da como resultado verdadero o falso. Si la comparación o evaluación de la expresión es verdadera se ejecutará el bucle o la condicional, si es falsa la evaluación no se ejecutará.
En Bash, la sintaxis es la siguiente:

test expresión

ó

[ expresión ]

Un ejemplo de expresión sería [ 3 -eq 5 ] que comprueba si el valor 3 es igual a 5. Como es incorrecto, el valor que devuelve es falso. Los símbolos [ y ] tienen que estar obligatoriamente separados por un espacio.

2.3.1. Comparaciones numéricas

numero1 -eq numero2: Devuelve verdadero si 'numero1' es igual a 'numero2'.
numero1 -ge numero2: Devuelve verdadero si 'numero1' es igual o mayor a 'numero2'.
numero1 -gt numero2: Devuelve verdadero si 'numero1' es mayor a 'numero2'.
numero1 -le numero2: Devuelve verdadero si 'numero1' es igual o menor a 'numero2'.
numero1 -lt numero2: Devuelve verdadero si 'numero1' es menor a 'numero2'.
numero1 -ne numero2: Devuelve verdadero si 'numero1' no es igual a 'numero2'.

2.3.2. Comparaciones de cadenas

cadena1 = cadena2: Devuelve verdadero si 'cadena1' es idéntica a 'cadena2'.
cadena1 != cadena2: Devuelve verdadero si 'cadena1' no es idéntica a 'cadena2'.
cadena1: Devuelve verdadero si 'cadena1' es nulo (no significa que su longitud sea cero).
-n cadena1: Devuelve verdadero si la longitud de caracteres de 'cadena1' es mayor que cero.
-z cadena1: Devuelve verdadero si la longitud de caracteres de 'cadena1' es cero.

2.3.3. Comparaciones de ficheros

-d nombrefichero: Devuelve verdadero si el fichero es un directorio.
-f nombrefichero: Devuelve verdadero si el fichero es un archivo.
-r nombrefichero: Devuelve verdadero si el fichero puede ser leído.
-w nombrefichero: Devuelve verdadero si el fichero puede ser escrito.
-x nombrefichero: Devuelve verdadero si el fichero es ejecutable.

2.3.4. Comparaciones de expresiones

!expresión: Devuelve verdadero si la expresión no se cumple.
expresión1 -a expresión2: Devuelve verdadero si la expresión1 y la expresión2 se cumplen (también vale &&).
expresión1 -o expresión2: Devuelve verdadero si la expresión1 o la expresión2 se cumplen (también vale ||).

2.4. Condicionales

En programación, una sentencia condicional es una instrucción que se pueden ejecutar o no en función del valor de una expresión. En Bash, las condicionales más populares son los siguientes:

2.4.1. If – Then

if [ expresión ]
then
comandos
fi

2.4.2. If – Then – Else

if [ expresión ]
then
comandos
else
comandos
fi

2.4.3. If – Then – Else if – Else

if [ expresión1 ]
then
comandos
elif [ expresión2 ]
then
comandos
else
comandos
fi

2.4.4. Case

case cadena in
cadena1)
comandos
;;
cadena2)
comandos
;;
*)
comandos
;;
esac

Se comprueba cadena. Si concuerda con cadena1 se ejecutará los comandos correspondientes hasta llegar a ;;. Lo mismo ocurre con cadena2. Si cadena no coincide con cadena1 o cadena2 entonces se ejecutará *. Se puede añadir tantas cadenas de verificación como uno desee.

2.5. Bucles

Un bucle repite los comandos que uno ha escrito tantas veces hasta que la expresión se verifique.

2.5.1. For

Existen muchas maneras de realizar un bucle for en Bash. Yo sólo uso ésta:

for (( inicializador; condición; incremento ))
do
 comandos
done

Su sintaxis es casi idéntica a C. Aquí un ejemplo:

#!/bin/bash
for (( c=1; c<=5; c++ ))
do
 echo "Bienvenido $c veces..."
done

2.5.2. While

while [ expresión ]
do
comandos
done

2.5.3. Until

until [ expresión ]
do
comandos
done

3. Comandos Linux

Lista de comandos más importantes según la Wikipedia.

3.1. Ayuda

man: muestra manual del comando que le indiquemos.
--help: da una ayuda de los comandos.

3.2. Archivos y directorios

ls: lista los archivos y directorios.
sort: ordena alfabéticamente una lista de archivos.
cd: cambio de directorio.
pwd: muestra la ruta al directorio actual.
tree: muestra la estructura de directorios y archivos en forma gráfica.
mkdir: crea un directorio.
rmdir: borro directorios.
rm -r: borra directorios no vacíos.
cp: copia archivos.
rm: borra archivos.
mv: mueve o renombra archivos y directorios.
cat: ve el contenido de uno o varios archivos.
more: ve el contenido de los archivos.
less: ve el contenido de los archivos.
split: dividir archivos.
find: busca archivos.
locate: localiza archivos según una lista generada.
updatedb: actualiza la lista de los archivos existentes.
whereis: muestra la ubicación de un archivo.
file: muestra el tipo de archivo.
whatis: muestra descripción del archivo.
wc: cuenta líneas palabras o caracteres en un archivo.
grep: busca un texto en archivos.
head: muestra el inicio de un archivo.
tail: muestra el final de un archivo.
tailf: muestra el final de un archivo y lo que se añada en el instante (logs).
tr: reemplaza caracteres en un fichero de texto.
sed: cambia una cadena de caracteres por otra.
join: cruza la información de dos archivos y muestra las partes que se repiten.
paste: toma la primera línea de cada archivo y las combina para formar una línea de salida.
uniq: elimina líneas repetidas adyacentes del archivo entrada cuando copia al archivo salida.
cut: sirve para seleccionar columnas de una tabla o campos de cada línea de archivo.
ln: crea enlaces a archivos o carpetas.
diff: muestra las diferencias entre dos archivos.
fuser: muestra que usuario tiene en uso o bloqueado un archivo o recurso.
tar: empaqueto archivos.
gzip: comprime archivos gz.
gunzip: descomprime archivos gz.
compress: comprime archivos Z.
uncompress: descomprime archivos Z.
chmod: cambio permisos a archivos y directorios.
chown: cambio de propietario.
chgrp: cambio de grupo.
vi: abre el editor de texto vi.
pico: edita un fichero de texto.

3.3. Usuarios

adduser: agregó nuevo usuario.
useradd: agregó nuevo usuario.
userdel: borra un usuario.
passwd: permite cambiar la contraseña.
su: cambio de usuario.
whoami: muestra el nombre de usuario.
logname: muestra el nombre de usuario.
id: muestra datos de identificación del usuario.
finger: da información de usuario.
chfn: cambia la información del finger.
who: muestra los usuarios del sistema.
w: muestra un detalle de los usuarios.
last: información de los últimos usuarios que han usado el sistema.
mail: programa de correo.
pine: lector de correo en modo texto.
write: manda un mensaje a la pantalla de un usuario.
mesg: activo o desactivo recibir mensajes.
wall: mensaje a todos los usuarios.
talk: establecer una charla con otro usuario.
banner: saca letrero en la pantalla.
set: da información sobre el entorno del usuario.
addgroup: agregó nuevo grupo.
groupadd: agregó nuevo grupo.
chown: cambia el propietario de un fichero.

3.4. Procesos

top: muestra los procesos que se están ejecutando y permite matarlos.
ps: muestra la lista de procesos del usuario.
ps aux: muestra la lista de procesos de la máquina.
kill: mata proceso por ID.
killall: mata proceso por nombre.
time: mide el tiempo que tarda un proceso en ejecutarse.
fg: trae a primer plano un proceso parado o en segundo plano.
bg: pone un proceso en segundo plano.
&: colocado al final de la línea de comando ejecuta en segundo plano.
nice: ajusta la prioridad de un proceso de -20 a 19.

3.5. Discos

mount: monta un disco.
umount: desmonta un disco.
df: muestra el espacio libre de los discos.
du: muestra el espacio usado por el disco o un directorio.
mkfs: formateo un disco.
fsck: estado del disco.
fdisk: gestión de particiones.

3.6. Red

netstat: muestra estado de la red.
ifconfig: muestra la configuración del dispositivo de red.
iwconfig: muestra la configuración del dispositivo de red inalámbrico.
nmap: escanea la red y muestra los puertos que se encuentran disponibles.
ping: indica si hay respuesta por parte del servidor.
nslookup: me da la IP de nuestro servidor DNS.
telnet: me conecto a un equipo remotamente.
netconf: configuro la red.
ntop: muestra los procesos de la red.
route -n: muestra la tabla de rutas.

3.7. Sistema

rlogin: se conecta a otra máquina de forma remota (remote login).
rsh: se conecta a otra máquina de forma remota (remote shell).
ftp: se conecta a otra máquina por el protocolo ftp.
reboot: reinicia la máquina.
halt: apaga el sistema.
shutdown: apaga el sistema.
init0: apaga la máquina.
init6: reinicia la máquina.
uptime: muestra el tiempo transcurrido de encendida la máquina.
exit: cierro sesión actual.
logout: salgo del sistema.
nohup: proporciona inmunidad frente a rupturas de comunicación..
dmesg: muestra mensajes del arranque del ordenador.
history: muestra todos los comandos digitados por el usuario.
uname: da información del sistema operativo.
tee: copia la entrada estándar a la salida estándar y a un archivo.
host: muestra la dirección IP del servidor en una red local.
hostname: muestra el nombre del servidor.
umask: muestra y permite cambiar la máscara de usuario.
chroot: cambia la raíz para que root ejecute algo en forma particular.
chsh: cambia el login shell.
free: estado de la memoria.
date: muestra fecha y hora actual.
cal: muestra calendario.
clear: borro la pantalla.
at: ejecuta un comando más tarde.
env: ver variables de entorno.
export: permite el uso de variables por programas en todos los caminos del usuario.
modprobe: cargo modulo.
startx: arranca el servidor X.
xev: muestra los eventos de las teclas y el ratón.
lspci: muestra los periféricos conectados al puente pci.
lsmod: muestra los modulos cargados en el sistema.
echo: escribe un mensaje en la salida estándar.
alias: crear un alias. Un comando largo abreviado en pocas letras.
unalias: borrar un alias.
bc: calculadora.
mc: ejecuta Midnight Commander.
xkill: mata una ventana gráfica.
rpm: instala los paquetes rpm RedHat.
dpkg: instala los paquetes deb Debian.
kernelcfg: manejo los modulos cargados en el kernel.
insmod: inserta modulos en el kernel.
rmmod: elimina modulos del kernel.
updatedb: actualiza la base de datos interna de archivos.
sh: cambia al bash shell.
setxkbmap: por si no funcionan las teclas con AltGr en modo X.

4. Ejemplos

Introducir dos números diferentes e indicar cuál es el mayor

#!/bin/bash
echo "Introducir dos números:"
read A
read B
if [ $A -gt $B ]
then
 echo $A "es el mayor"
else
 echo $B "es el mayor"
fi

Pasar dos números como parámetros e indicar el menor

#!/bin/bash
echo $#
if [ $# -ne 2 ]
then
 echo "Falta algún parámetro"
elif [ $1 -eq $2 ]
 then
  echo "Son iguales"
 elif [ $1 -lt $2 ]
  then
   echo $1 "es menor"
  else
   echo $2 "es menor"
fi

Ver los procesos que está ejecutando un usuario concreto

#!/bin/bash
RES=s
while [ $RES = s ]
do
 echo "Introducir nombre de usuario:"
 read USU
 ps aux|grep $USU
 echo "¿Desea continuar?"
 read RES
done

Mostrar los usuarios que pasamos como parámetros y saber si están conectados

#!/bin/bash
for i in $*
do
 if who|grep -s $i>/dev/null
 then
  echo $i si está conectado
 else
  echo $i no está conectado
 fi
done

Bibliografía

• Informática - Ángeles Sampalo de la Torre
• Linux-SXS
• Wikipedia (comandos)

Setting up MySQL replication without the downtime

Esta nota la copie de aqu:

https://plusbryan.com/mysql-replication-without-downtime

I clearly don’t need to expound on the benefits of master-slave replication for your MySQL database. It’s simply a good idea; one nicety I looked forward to was the ability to run backups from the slave without impacting the performance of our production database. But the benefits abound.
Most tutorials on master-slave replication use a read lock to accomplish a consistent copy during initial setup. Barbaric! With our users sending thousands of cards and gifts at all hours of the night, I wanted to find a way to accomplish the migration without any downtime.
@pQd via ServerFault suggests enabling bin-logging and taking a non-locking dump with the binlog position included. In effect, you’re creating a copy of the db marked with a timestamp, which allows the slave to catch up once you’ve migrated the data over. This seems like the best way to set up a MySQL slave with no downtime, so I figured I’d document the step-by-step here, in case it proves helpful for others.
First, you’ll need to configure the master’s /etc/mysql/my.cnf by adding these lines in the [mysqld] section:

server-id=1
binlog-format   = mixed
log-bin=mysql-bin
datadir=/var/lib/mysql
innodb_flush_log_at_trx_commit=1
sync_binlog=1

Restart the master mysql server and create a replication user that your slave server will use to connect to the master:

CREATE USER replicant@<<slave-server-ip>>;
GRANT REPLICATION SLAVE ON *.* TO replicant@<<slave-server-ip>> IDENTIFIED BY '<<choose-a-good-password>>';

Note: Mysql allows for passwords up to 32 characters for replication users.
Next, create the backup file with the binlog position. It will affect the performance of your database server, but won’t lock your tables:

mysqldump --skip-lock-tables --single-transaction --flush-logs --hex-blob --master-data=2 -A  > ~/dump.sql

Now, examine the head of the file and jot down the values for MASTER_LOG_FILE and MASTER_LOG_POS. You will need them later:

head dump.sql -n80 | grep "MASTER_LOG_POS"

Because this file for me was huge, I gzip'ed it before transferring it to the slave, but that’s optional:

gzip ~/dump.sql

Now we need to transfer the dump file to our slave server (if you didn’t gzip first, remove the .gz bit):

scp ~/dump.sql.gz mysql-user@<<slave-server-ip>>:~/

While that’s running, you should log into your slave server, and edit your /etc/mysql/my.cnf file to add the following lines:

server-id               = 101
binlog-format       = mixed
log_bin                 = mysql-bin
relay-log               = mysql-relay-bin
log-slave-updates = 1
read-only               = 1

Restart the mysql slave, and then import your dump file:

gunzip ~/dump.sql.gz
mysql -u root -p < ~/dump.sql

Log into your mysql console on your slave server and run the following commands to set up and start replication:

CHANGE MASTER TO MASTER_HOST='<<master-server-ip>>',MASTER_USER='replicant',MASTER_PASSWORD='<<slave-server-password>>', MASTER_LOG_FILE='<<value from above>>', MASTER_LOG_POS=<<value from above>>;
START SLAVE;

To check the progress of your slave:

SHOW SLAVE STATUS \G

If all is well, Last_Error will be blank, and Slave_IO_State will report “Waiting for master to send event”. Look for Seconds_Behind_Master which indicates how far behind it is. It took me a few hours to accomplish all of the above, but the slave caught up in a matter of minutes. YMMV.
And now you have a newly minted mysql slave server without experiencing any downtime!
A parting tip: Sometimes errors occur in replication. For example, if you accidentally change a row of data on your slave. If this happens, fix the data, then run:

 STOP SLAVE;SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1;START SLAVE;

Update: In following my own post when setting up another slave, I ran into an issue with authentication. The slave status showed an error of 1045 (credential error) even though I was able to directly connect using the replicant credentials. It turns out that MySQL allows passwords up to 32 characters in length for master-slave replication.

Palabras mágicas para ordenar el caos de Gmail

¿Todo el mundo chateando por WhatsApp y vos tapado por el mail? Tranquilo, somos legión, y aquí viene la ayuda

SEGUIR

Ariel Torres

LA NACION

Sábado 05 de marzo de 2016

177

62

Hasta 2004 las cosas estaban más o menos bajo control. Los dueños del correo electrónico, como Microsoft (Hotmail) y Yahoo!, ofrecían bandejas de entrada de 5 megabytes (MB). Sí, mega. En un mundo de mensajes de texto, no estaba mal. Parece poco, pero equivalía a unos 4200 mails de una carilla. Palabra vieja, pero significativa. Esas bandejas de entrada, que hoy nos parecen de juguete, podían almacenar más de 8 resmas de papel. Virtualmente, claro. Aún así, conseguíamos administrarlas con cierta dignidad.

Pero las imágenes, los PDF, los documentos de Excel y Word y los desmesurados y en general insulsos PPT ya habían plantado su bandera en el espacio virtual y los 5 MB pronto empezaron a tirarnos de sisa. Entonces Google lanzó Gmail. Tal vez fue para celebrar su salida a la bolsa de valores. No lo sé. Pero patearon el tablero; fue una de las primeras señales de que iban por todo. En lugar de 5 MB la primera versión de Gmail ofrecía 1 gigabyte (GB). Es decir, 200 veces más que Hotmail o Yahoo! Mail. Habíamos pasado de 8 a 1600 resmas. O sea una pila de papel de 80 metros de altura. Veinte metros más que el obelisco.

Foto:SHUTTERSTOCK

Oh, sí, allí fuimos, como polillas atraídas por la luz, sin pensar en que cuando no hace falta borrar nada el amontonamiento puede volverse ingobernable. Que fue exactamente lo que ocurrió. Entusiasmado, en un mundo que veía desplomarse el costo del almacenamiento -prefigurando toda la cosa Nube que se venía-, Google redobló la apuesta y llevó la casilla de Gmail a 2 GB. Hoy ese valor está en 15 GB y la pila de papel ya es una montaña de 1200 metros de altura. Microsoft, mediante Outlook.com, ofrece hoy almacenamiento ilimitado. ¡Hasta el infinito y más allá!

Hace justo 3 años (por algún motivo en esta época del año me da por limpiar el mail) escribí acerca de cómo filtrar los correos, para moverlos, borrarlos, etiquetarlos, reenviarlos o archivarlos automáticamente. Se trata de una vieja herramienta de los clientes de e-mail que los veteranos conocen como reglas de correo. Es la única, tenue barrera que nos separa del alud electrónico.
Pero las reglas (o filtros, en la jerga de Gmail) no son suficientes cuando la acumulación aluvial suma, como es mi caso, unos 10.000 mensajes. O eso dice la pantalla. No los conté, confieso. Me da la impresión de que son más. Como 10 millones, digamos.

La cuestión es que liberar espacio, encontrar un mail en particular, incluso dar con un adjunto que sabemos que nos enviaron en algún momento de, digamos, 2014, todo eso se convierte en una empresa que está en la misma categoría que escalar el Everest. O, para el caso, una pila de 1200 metros de papel.
Entran en escena los operadores de búsqueda avanzada de Gmail. Son, grosso modo, palabras o frases que permiten refinar una búsqueda según un número bastante amplio de criterios. Por ejemplo, ¿cuántos mensajes tengo sin leer entre el 1° de enero de 2008 y el 1° de enero de 2012 que no fueron marcados como importantes? Si no los leí hasta ahora y no me parecieron destacables, ya, fue, es hora de borrarlos. ¿Suena bien? Sí, y se pone mejor. A propósito, Oulook.com proporciona herramientas similares, que trato más abajo.

Bordado a mano

Esta columna nació cuando un amigo logró agotar el espacio de almacenamiento de su Gmail (sí, en serio) y descubrió que no había forma de ordenar los mensajes por tamaño. Sólo podía listar los que ocuparan cierta cantidad de bytes. Habituados como estamos a las herramientas de Windows, Mac y Linux, esto suponía un obstáculo. Pero resulta que la búsqueda de correos que robaban espacio y merecían borrarse podía hacerse incluso mejor en Gmail que en una carpeta de Windows. Allá vamos.
La pantalla de Gmail está dominada por la lista de mensajes. Justo arriba hay una serie de botones (Seleccionar, Actualizar, Más, etcétera) y, por encima de esos botones, una gran caja vacía con una lupa. Es donde usualmente ingresamos criterios para encontrar mails. Y es allí donde los operadores de búsqueda avanzada hacen su magia.
Algunos de estos operadores son bastante obvios. Por ejemplo, from: sirve para listar los mensajes de cierto remitente. Dato: no hace falta poner toda la dirección de correo, incluida la arroba y el dominio. Con una parte funciona, salvo, claro, que tengamos varios amigos cuyas direcciones son casi iguales. Por ejemplo (observen que no hay que dejar ningún espacio después de los dos puntos.):
from:juanpablo
La cosa se pone mucho más interesante desde el momento en que los operadores se pueden combinar. Por ejemplo, busquemos todos los mensajes de juanpablo en cuyo asunto se menciona la palabra presupuesto. Se haría así:
from:juanpablo subject:presupuesto
Por supuesto, las comillas pueden usarse para los asuntos con más de una palabra.
from:juanpablo subject:"solicitar cuota"
También from: acepta comillas. Así:
from:"Juan Pablo" subject:"solicitar cuota"
Fantástico. Ahora bien, como juanpablo es el administrador de la empresa, un número demasiado grande de sus correos mencionan la palabra presupuesto en el asunto, así que terminamos de nuevo con una lista gigante. Hay que refinar un poco más. Agreguemos un rango de tiempo:
from:juanpablo subject:presupuesto after:2015/1/1 before:2016/1/1
Es decir, todo lo que nos envió durante 2015. Perfecto, ahora la lista se acotó lo suficiente como para limpiar lo que no sirve o encontrar lo que buscábamos.
¿Dijimos limpiar? Vamos por los principales responsables de que el espacio empiece a agotarse: los adjuntos. En el caso de Google, los 15 GB de Gmail son los mismos que los de Drive, por lo que si tenés 5 GB de mensajes, sólo te quedan 10 GB para Drive. Y todo suma. O resta, más bien.
Busquemos, pues, todos los mensajes con adjuntos de 5 MB que recibimos durante 2009, 2010 y 2011. En ese caso, deberíamos escribir:
size:5000000 has:attachment after:2009/1/1 before:2012/1/1
El ejemplo de arriba da cuenta del servicio que presta has:attachment, pero si no nos importa discriminar los mensajes que tienen adjuntos, también funcionaría si ponemos:
size:5000000 after:2009/1/1 before:2012/1/1
El operador has: (tiene) puede emplearse también para decirle a Gmail que muestre sólo los mensajes con una estrella amarilla (o de cualquier otro color, para el caso). Por ejemplo,
has:blue-star
Si te estás preguntando por qué sólo tenés estrellas amarillas, la respuesta es que hay que activar las demás desde la pestaña General de la configuración de Gmail. Una vez hecho esto, para cambiar el color de la estrella (o escoger otro símbolo; hay varios) sólo hay que darle clic a la estrellita blanca que se ve junto a cada mail hasta que aparezca el color o el símbolo que buscamos.
El operador size: tiene dos socios muy útiles, larger: (mayor que) y smaller: (menor que). En rigor, size: funciona igual que larger:. Supongamos que queremos encontrar todos los mensajes que tengan estrella amarilla y sean de más de 1 MB. En ese caso, habría que escribir:
larger:1000000 has:yellow-star
Del mismo modo que en las búsquedas de Google (es, en el fondo, el mismo motor), el signo menos (-) sirve para excluir de los resultados aquellos mails que contengan ciertas palabras, sin importar dónde. Por ejemplo, para buscar todos los mensajes que recibimos en 2012 y que ocupan más de 1 MB y en los que no aparecen las palabras Juan y Pedro, la línea sería:
after:2012/1/1 before:2013/1/1 size:1000000 -juan -pedro
Y para asegurarnos de que no se incluyan los mensajes que guardamos como borradores, añadimos el operador in:, en este caso con inbox:
after:2012/1/1 before:2013/1/1 size:1000000 -juan -pedro in:inbox
Por cierto, también podríamos buscar algo en los Borradores, que es algo así como ese cajón donde guardamos de todo. Para eso se usa el operador in:draft. Por ejemplo:
in:draft subject:boceto
O sea, todos los mensajes en Borradores cuyo asunto diga boceto. Si no ponemos el operador subject:, listará todos los mensajes guardados como borradores en los que aparezca la palabra boceto, en cualquiera de los campos, incluidos from:, to: (para), cc: (con copia) y bcc: (con copia oculta).
Lo genial es que el signo menos también funciona con operadores. Así, se pueden excluir de la lista los mensajes con estrellas, que supuestamente son más importantes para nosotros. De este modo:
size:1000000 -juan -pedro in:inbox -has:yellow-star after:2012/1/1 before:2013/1/1
O bien, si usás estrellas de varios tipos:
size:1000000 -juan -pedro in:inbox -is:starred after:2012/1/1 before:2013/1/1
Y aún podríamos refinar más, de esta forma, para descartar dos remitentes:
size:1000000 -from:juan -from:pedro in:inbox -is:starred after:2012/1/1 before:2013/1/1
Otra aplicación del signo menos es decirle que liste todos los mensajes recibidos en cierto período, que ocupan más de 1 MB y que no son importantes, así:
after:2012/1/1 before:2013/1/1 size:1000000 -is:important
Podría seguir con los ejemplos, pero creo que estos son suficientes. Gmail recuerda las búsquedas que hicimos (obvio) y muy pronto ni siquiera hará falta tipear todo. El operador smaller: citado antes es interesante porque una parte importante del espacio de la bandeja de entrada se va en pequeñeces, se esfuma por goteo. No es mala idea probar con una línea como:
smaller:50000 -is:starred -is:important is:unread
Es decir, listar todos los mensajes de menos de 50 KB que no tengan estrella ni sean importantes y que no hayan sido leídos. Vulgo: todo eso que nos llega y no le prestamos atención. Se asombrarán de la cantidad de espacio que pueden liberar.
Otra cosa. El operador in:sent (en:enviados) es fun-da-men-tal. Pasados varios años, la cantidad de mensajes que pueden acumularse allí, muchas veces con adjuntos, es monumental.
Aquí, todas las opciones de operadores de búsqueda avanzada de Gmail. Funcionan sólo con la versión Web, por supuesto, no con clientes de Escritorio como Thunderbird, pero esto no es en verdad un problema. La mayor parte de nosotros accede a sus casillas mediante un navegador, y en general usamos el cliente de Escritorio para mantener un backup de los mensajes, no como interfaz principal.
Por cierto, es posible usar la caja de búsqueda que se despliega apretando la flecha, a la derecha de la lupa, pero los operadores que menciono aquí permiten una precisión mucho mayor. Los recomiendo enfáticamente.

Outlook.com

El servicio de correo de Microsoft ofrece hoy prácticamente las mismas funciones que el de Google, sólo que el espacio de almacenamiento es, como dije, ilimitado. También ofrece operadores de búsqueda avanzados con los que, usando otras palabras y frases, se consigue el mismo resultado.
Por ejemplo, se puede poner from:"bobby moore" about:"status report" para buscar los mensajes que vienen de Bobby Moore y en cuyo asunto figuran la frase exacta status report. En lugar de larger: y smaller: se usan los símbolos mayor (>) que y menor que (<), combinados con la palabra reservada messagesize:, de este modo:
messagesize:>5MB (mensajes de más de 5 mega)
messagesize:<50KB (mensajes de menos de 50 kilobytes)

HTTP Strict Transport Security for Apache, NGINX and Lighttpd

HTTP Strict Transport Security for Apache, NGINX and Lighttpd

• Home
• Tutorials
• HTTP Strict Transport Security for Apache, NGINX and Lighttpd

29-12-2014 | Remy van Elst

Table of Contents

1. What is HTTP Strict Transport Security?
2. Set up HSTS in Apache2
3. Lighttpd
4. NGINX
5. X-Frame-Options header
1. X-Frame-Options for Apache2
6. Lighttpd
1. NGINX

---

HTTP Strict Transport Security (often abbreviated as HSTS) is a security feature that lets a web site tell browsers that it should only be communicated with using HTTPS, instead of using HTTP. This tutorial will show you how to set up HSTS in Apache2, NGINX and Lighttpd. It is tested with all mentioned webservers, NGINX 1.1.19, Lighttpd 1.4.28 and Apache 2.2.22 on Ubuntu 12.04, Debian 6 & 7 and CentOS 6.It should work on other distro's however, these are just reference values.

What is HTTP Strict Transport Security?

Quoting the Mozilla Developer Network:

If a web site accepts a connection through HTTP and redirects to HTTPS, the user in this case may initially talk to the non-encrypted version of the site before being redirected, if, for example, the user types http://www.foo.com/ or even just foo.com.

This opens up the potential for a man-in-the-middle attack, where the redirect could be exploited to direct a user to a malicious site instead of the secure version of the original page.

The HTTP Strict Transport Security feature lets a web site inform the browser that it should never load the site using HTTP, and should automatically convert all attempts to access the site using HTTP to HTTPS requests instead.

An example scenario:

You log into a free WiFi access point at an airport and start surfing the web, visiting your online banking service to check your balance and pay a couple of bills. Unfortunately, the access point you're using is actually a hacker's laptop, and they're intercepting your original HTTP request and redirecting you to a clone of your bank's site instead of the real thing. Now your private data is exposed to the hacker.

Strict Transport Security resolves this problem; as long as you've accessed your bank's web site once using HTTPS, and the bank's web site uses Strict Transport Security, your browser will know to automatically use only HTTPS, which prevents hackers from performing this sort of man-in-the-middle attack.

Do note that HSTS does not work if you've never visited the website before. A website needs to tell you it is HTTPS only.

Set up HSTS in Apache2

Edit your apache configuration file (/etc/apache2/sites-enabled/website.conf and /etc/apache2/httpd.conf for example) and add the following to your VirtualHost:

# Optionally load the headers module:
LoadModule headers_module modules/mod_headers.so

<VirtualHost 67.89.123.45:443>
    Header always set Strict-Transport-Security "max-age=63072000; includeSubdomains; preload"
</VirtualHost>

Now your website will set the header every time someone visits, with an expiration date of two years (in seconds). It sets it at every visit. So tomorrow, it will say two years again.
You do have to set it on the HTTPS vhost only. It cannot be in the http vhost.
To redirect your visitors to the HTTPS version of your website, use the following configuration:

<VirtualHost *:80>
  [...]
  ServerName example.com
  Redirect permanent / https://example.com/
</VirtualHost>

If you only redirect, you dont even need a document root.
You can also use modrewrite, however the above method is simpler and safer. However, modrewrite below redirects the user to the page they were visiting over https, the above config just redirects to /:

<VirtualHost *:80>
  [...]
  <IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{HTTPS} off
    RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}
  </IfModule>
</VirtualHost>

And don't forget to restart Apache.

Lighttpd

The lighttpd variant is just as simple. Add it to your Lighttpd configuration file (/etc/lighttpd/lighttpd.conf for example):

server.modules += ( "mod_setenv" )
$HTTP["scheme"] == "https" {
    setenv.add-response-header  = ( "Strict-Transport-Security" => "max-age=63072000; includeSubdomains; preload")
}

And restart Lighttpd. Here the time is also two years.

NGINX

NGINX is even shorter with its config. Add this in the server block for your HTTPS configuration:

add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload";

Don't forget to restart NGINX.

X-Frame-Options header

The last tip I'll give you is the X-Frame-Options header, which you can add to your HTTPS website to make sure it is not embedded in a frame or iframe. This avoids clickjacking, and might be helpfull for HTTPS websites. Quoting the Mozilla Developer Network again:

The X-Frame-Options HTTP response header can be used to indicate whether or not a browser should be allowed to render a page in a `<frame>` or `<iframe>`. Sites can use this to avoid clickjacking attacks, by ensuring that their content is not embedded into other sites.

You can change DENY to SAMEORIGIN or ALLOW-FROM uri, see the Mozilla link above for more information on that. (Or the RFC.)

X-Frame-Options for Apache2

As above, add this to the apache config file:

Header always set X-Frame-Options DENY

Lighttpd

This goes in the lighttpd config. Make sure you don't double the above set config, if you have that, just add the rule it to it.

server.modules += ( "mod_setenv" )
$HTTP["scheme"] == "https" {
    setenv.add-response-header  = ( "X-Frame-Options" => "DENY")
}

NGINX

Yet again, in a server block:

add_header X-Frame-Options "DENY";