4 High Availability y High Performance

4.1 Antecedentes

Estudios recientes (IDC) han encontrado que los "downtime" o "caídas" son las causas principales al hablar de los TCO en las empresas.

Caídas de algunas aplicaciones puede significar considerables pérdidas, por ejemplo:

Proveedores de telecomunicaciones y operadores de redes requieren brindar sus servicios sin parar, independientemente de la información que manejan, por el simple hecho de mantener un nivel competitivo.
Intituciones financieras aumentan cada día el número de usuarios y transacciones, es importante atenderlos y en el menor tiempo posible.
Web sites y compañías de portales en Internet crean comunidades que también contribuyen de manera exponencial en el crecimiento de los datos .
Todo lo relacionado con e-commerce representa tiendas o transacciones de gran demanda.

Para estas y muchas otras compañías un downtime puede ser crucial y algo que simplemente no pueden permitir, alta disponibilidad es la solución central y crítica para su éxito. Sin HA y HP se comprometen la satisfacción del cliente y las ganancias.

4.2 High Performance

Hablando de Performance existen algunas soluciones conocidas:

Buen manejo de índices y memoria
Denormalización

4.2.1 Manejo de índices y memoria

4.2.1.1 Indices

mysql> describe book;
+-------------+-----------+------+-----+---------+-------+
| Field       | Type      | Null | Key | Default | Extra |
+-------------+-----------+------+-----+---------+-------+
| call_letter | char(10)  |      | PRI |         |       |
| call_number | float     |      | PRI | 0       |       |
| call_cutter | char(50)  |      | PRI |         |       |
| title       | char(255) | YES  | MUL | NULL    |       |
| systemkey   | char(10)  | YES  |     | NULL    |       |
| series      | char(255) | YES  |     | NULL    |       |
| year        | int(11)   | YES  | MUL | NULL    |       |
| edition     | char(255) | YES  |     | NULL    |       |
| publisher   | char(255) | YES  | MUL | NULL    |       |
| isbn        | char(255) | YES  |     | NULL    |       |
| conference  | char(255) | YES  |     | NULL    |       |
| corpauthor  | char(255) | YES  |     | NULL    |       |
| alttitle    | char(255) | YES  |     | NULL    |       |
| place       | char(255) | YES  | MUL | NULL    |       |
+-------------+-----------+------+-----+---------+-------+
14 rows in set (0.00 sec)

mysql> show index from book;
         +-------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
         | Table | Non_unique | Key_name | Seq_in_index | Column_name | Collation | Cardinality | Sub_part | Packed | Null | Index_type | Comment |
         +-------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
         | book | 0 | PRIMARY | 1 | call_cutter | A | 216144 | NULL | NULL | | BTREE | |
         | book | 0 | PRIMARY | 2 | call_number | A | 216144 | NULL | NULL | | BTREE | |
         | book | 0 | PRIMARY | 3 | call_letter | A | 216144 | NULL | NULL | | BTREE | |
         | book | 1 | book_idx_1 | 1 | year | A | 17 | NULL | NULL | YES | BTREE | |
         | book | 1 | book_idx_2 | 1 | title | A | 216144 | NULL | NULL | YES | BTREE | |
         | book | 1 | book_idx_3 | 1 | publisher | A | 108072 | NULL | NULL | YES | BTREE | |
         | book | 1 | book_idx_4 | 1 | place | A | 13509 | NULL | NULL | YES | BTREE | |
         +-------+------------+------------+--------------+-------------+-----------+-------------+----------+--------+------+------------+---------+
         7 rows in set (3.16 sec)

mysql> explain select * from book where call_letter='QA' and call_number between 75.9999 and 76.0001;
         +----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
         | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
         +----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
         | 1 | SIMPLE | book | ALL | NULL | NULL | NULL | NULL | 216144 | Using where |
         +----+-------------+-------+------+---------------+------+---------+------+--------+-------------+
         1 row in set (0.00 sec)

mysql> explain select * from book where call_letter='QA' and call_number between 75.9999 and 76.0001 and call_cutter='/abc';
         +----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
         | id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
         +----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
         | 1 | SIMPLE | book | range | PRIMARY | PRIMARY | 64 | NULL | 1 | Using where |
         +----+-------------+-------+-------+---------------+---------+---------+------+------+-------------+
         1 row in set (0.04 sec)

4.2.1.2 Memoria

global buffers + (session buffers* maxconnections) = RAM Mem

Donde se puede observar que el total de la memoria empleada por el manejador de base de datos está repartido entre una sección global y otra dedicada cada conexión de los usuarios.

session buffers

sort_buffer
myisam_soft_buffer
read_buffer
join_buffer
read_rnd_buffer

global buffers

key_buffer
innodb_buffer_pool
innodb_log_buffer
innodb_additional_mem_pool
net_buffer

# The following options will be passed to all MySQL clients

[client]

#password = your_password
port = 3306
socket = /tmp/mysql.sock

# Here follows entries for some specific programs

# The MySQL server
[mysqld]
         port = 3306
         socket = /tmp/mysql.sock
         skip-locking
         #set-variable = key_buffer=64M
         #set-variable = max_allowed_packet=300M
         #set-variable = table_cache=500
         #set-variable = sort_buffer=32M
         set-variable = net_buffer_length=64M
         #set-variable = myisam_sort_buffer_size=16M
         set-variable = max_connections=500
         #set-variable = interactive_timeout=604800
         set-variable = wait_timeout=604800
         #set-variable = thread_stack=64M
         set-variable = tmp_table_size=32M
         set-variable = back_log=100
         #set-variable = binlog_cache_size=64M
         set-variable = connect_timeout= 45
         set-variable = join_buffer_size=2M
         #set-variable = key_buffer_size=64M
         set-variable = long_query_time=604800
         set-variable = max_binlog_cache_size=1000M
         set-variable = max_binlog_size=1000M
         set-variable = net_read_timeout=300
         set-variable = net_write_timeout=300
         set-variable = net_retry_count=50
         #set-variable = preload_buffer_size=16M
         #set-variable = query_cache_size=128M
         #set-variable = sort_buffer_size=64M
         #set-variable = thread_cache_size=100
         set-variable = key_buffer=64M
         set-variable = max_allowed_packet=300M
         set-variable = table_cache=512
         set-variable = sort_buffer_size=2M
         set-variable = read_buffer_size=2M
         set-variable = read_rnd_buffer_size=8M
         set-variable = myisam_sort_buffer_size=64M
         set-variable = thread_cache=8
         set-variable = query_cache_size=32M
         # Try number of CPU's*2 for thread_concurrency
         set-variable = thread_concurrency=8

#log-bin
         server-id = 1

# Point the following paths to different dedicated disks
         tmpdir = /var/tmp/ 
         #log-update = /centia01/final/database/mysql/var/log-catarina

# Uncomment the following if you are using BDB tables
         set-variable = bdb_cache_size=4M
         set-variable = bdb_max_lock=10000

# Uncomment the following if you are using Innobase tables
         innodb_file_per_table
         innodb_data_file_path = ibdata1:1G:autoextend
         innodb_data_home_dir = /mysql/data/innodb
         innodb_log_group_home_dir = /mysql/data/innodb
         innodb_log_arch_dir = /mysql/data/innodb
         set-variable = innodb_mirrored_log_groups=1
         set-variable = innodb_log_files_in_group=5
         set-variable = innodb_log_file_size=400M
         set-variable = innodb_log_buffer_size=256M
         innodb_flush_log_at_trx_commit=1
         innodb_log_archive=0
         set-variable = innodb_buffer_pool_size=2000M
         set-variable = innodb_additional_mem_pool_size=256M
         set-variable = innodb_file_io_threads=4
         set-variable = innodb_lock_wait_timeout=50
         #set-variable = innodb_force_recovery=3

[mysqldump]
         quick
         set-variable = max_allowed_packet=300M

[mysql]
         prompt=(\u) [\d]>\_
         no-auto-rehash
         # Remove the next comment character if you are not familiar with SQL
         #safe-updates

[isamchk]
         set-variable = key_buffer=20M
         set-variable = sort_buffer=20M
         set-variable = read_buffer=2M
         set-variable = write_buffer=2M

[myisamchk]
         set-variable = key_buffer=20M
         set-variable = sort_buffer=20M
         set-variable = read_buffer=2M
         set-variable = write_buffer=2M

[mysqlhotcopy]
         interactive-timeout

Configuración my.cnf

4.2.2 Denormalización

Se puede definir como el proceso de poner la misma información en varios lugares.

Una normalización reduce problemas de integridad y optimiza las actualizaciones, quizás con el costo del tiempo de recuperación. Cuando se pretende evitar esta demora resultado de la combinación de muchas tablas entonces se puede utilizar la denormalización.

Antes de denormalizar es importante considerar:

El sistema puede tener un desempeño aceptable sin la denormalización ?
Aún con la denormalización el desempeño será siendo malo ?
El sistema será menos confiable debido a la denormalización ?

Candidatos a denormalización:

Numerosas consultas críticas o reportes incluyen datos que incluyen más de una tabla.
Grupos repetidos de elementos necesitan ser procesados en un grupo en lugar de individualmente.
Muchos cálculos necesitan realizarse a una o más columnas antes de procesar las consultas.
Las tablas necesitan ser accesadas de diferentes maneras por diferentes usuarios durante el mismo lapso de tiempo.
Llaves primarias mal diseñadas que requieren tiempo al usarlas en relaciones.
Algunas columnas son interrogadas un gran porcentaje del tiempo.

Importante: nunca se realiza una denormalización en un modelo lógico.

Prejoined Tables

Cuando 2 tablas se mezclan (join) frecuentemente, considerar tener una tabla premezclada (prejoined) la cual debera:

Contener columnas que no sean redundantes
Contener sólo aquellas columnas absolutamente necesarias para las necesidades de la aplicación
Ser creada periodicamente utilizando las tablas normalizadas (que forman el join)

Ventaja: consultas rápidas y eficientes

Desventaja: la tabla puede quedar inconsistente rapidamente, se recomienda para datos más estáticos que dinámicos.

Report Tables

Mantener reportes en línea puede ser muy costoso, es mejor considerar tener una tabla que incluya los datos de dicho reporte.

Dicha tabla deberá contener:

Una columna por cada columna del reporte
Tener sus tuplas ordenadas secuencialmente en el mismo orden que deben aparecer en el reporte (evitando ordenamientos)
Elementos atómicos (1NF)

Mirror Tables

En ocasiones algún departamento de la organización necesita consultar mientras otro hace modificaciones, se pueden usar dos tablas para balancear la carga y obtener buen tiempo de acceso y modificación.

Se debe tener un esquema de duplicación que permita actualizar el espejo de manera eficiente, esto puede hacerse:

A través de un proceso batch, que es bastante rápido
Directamente con herramientas de replicación y propagación del dbms

Split Tables

Si la cantidad de información es considerable se puede pensar en partir una tabla ya sea vertical u horizontalmente

Vertical: implica conservar en ambas la llave primaria para tener una integridad referencial

Se puede considerar el separar columnas:

create table item

(itemnum integer not null,itemsize char(1), itemcolor char(10),
itemdescr char(100))

se dividiría en:

create table item
(itemnum integer not null,itemsize char(1),
itemcolor char(10),itemdescr char(10))

create table item_desc
(itemnum integer not null, itemdescr char(90))

o bien

create table item_desc(itemnum integer not null,itemctr integer not null,
itemdescr char(100))

Horizontal: consiste en separar las tuplas por rangos, los cuales se basan en algun criterio particular.

En los manejadores existe esta denormalización de 2 formas:

Técnicas de "Partitioning"

En MySQL a partir de la versión 5.0.24 con las tablas tipo Merge y desde la 5.1 con la opción de partitioning

En Oracle

http://www.devarticles.com/c/a/Oracle/Partitioning-in-Oracle/1

Merge

CREATE TABLE t1 ( -> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20)) ENGINE=MyISAM;
CREATE TABLE t2 ( -> a INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-> message CHAR(20)) ENGINE=MyISAM;

INSERT INTO t1 (message) VALUES ('Testing'),('table'),('t1');
INSERT INTO t2 (message) VALUES ('Testing'),('table'),('t2');
CREATE TABLE total (
-> a INT NOT NULL AUTO_INCREMENT,
-> message CHAR(20), INDEX(a))
-> ENGINE=MERGE UNION=(t1,t2) INSERT_METHOD=LAST;

CREATE TABLE SAMPLE_ORDERS
(ORDER_NUMBER NUMBER,
ORDER_DATE DATE,
CUST_NUM NUMBER,
TOTAL_PRICE NUMBER,
TOTAL_TAX NUMBER,
TOTAL_SHIPPING NUMBER,
SHIP_TO_ZIP_CODE,
SHIP_TO_STATE)
PARTITION BY LIST (SHIP_TO_STATE)
(PARTITION SHIP_TO_ARIZONA VALUES (‘AZ’) TABLESPACE TS01,
PARTITION SHIP_TO_CALIFORNIA VALUES (‘CA’) TABLESPACE TS02,
PARTITION SHIP_TO_ILLINOIS VALUES (‘IL’) TABLESPACE TS03,
PARTITION SHIP_TO_MASACHUSETTES VALUES (‘MA’) TABLESPACE TS04,
PARTITION SHIP_TO_MICHIGAN VALUES (‘MI’) TABLESPACE TS05)
ENABLE ROW MOVEMENT;

Partitioning

CREATE TABLE ti (id INT, amount DECIMAL(7,2), tr_date DATE)
ENGINE=INNODB
PARTITION BY HASH( MONTH(tr_date) )
PARTITIONS 6;

Este concepto de split/partitioning, se relaciona directamente con "Clustering", "Bases de datos paralelas" y "Bases de datos distribuidas"

Combined Tables

Dada una relacion 1-1, combinar las 2 tablas en una sola

Se complica si hay otras relaciones involucradas, otra relación 1-m implicaría demasiada redundancia y un aumento considerable del tiempo para actualizaciones.

Redundant Data

Cuando alguna columna de una tabla (A) es solicitada frecuentemente en una consulta de alguna otra tabla (B) entonces vale la pena agregar dicha columna de (A) en (B).

Dichas columnas serán redundantes y deberán cumplir con:

Sólo ser pocas las columnas involucradas
No deben necesitan actualizaciones frecuentes
Deben usarse por un gran número de usuarios y por pocos pero importantes

Repeating Groups

Muchas veces la repetición de tuplas puede transformase en varias columnas de la misma tupla

create table cust_balance

( custnum integer not null,

balanceperiod integer not null,

balance float)

create table cust_balance

( custnum integer not null,

period1_balance float,

period2_balance float,

period3_balance float,

period4_balance float,

period5_balance float,

period6_balance float)

Criterio:

Datos son raramente o nunca agregados, promediados o comparados dentro de una tupla
Los datos aparecen en un comportamiento estático y bajo un patrón
Se puede calcular el número de ocurrencias
Los datos se accesan colectivamente (grupos)

Derivable Data

Similar al de reportes para minimizar muchas fórmulas, se usa cuando:

La fuente de los datos involucrados son relativamente estáticos.
El costo de aplicar el cálculo es demasiado alto.
Es factible realizar el recálculo si es que los datos son modificados.

Hierarchies

create table dept

( parentdeptnum integer not null,

deptname char(25),

supervisornum integer,

reportstodeptnum integer)

create table dept

( deptnum integer not null,

childdeptnum integer not null,

level integer,

detail char(1),

deptname char(25),

supervisornum integer)

Dos columnas adicionales se incorporaron:

level, contiene un valor numérico indicando el nivel dentro de la jerarquía del childdeptnum; si el hijo reside 2 niveles abajo en la jerarquía del padre entonces el level será 2.

detail, contiene una "Y" si el childdeptnum esta hasta abajo de la jerarquía, "N" de otra manera.

Implementación física especial

Partir una tabla de manera que su tamaño se aproxime al de la página que maneja el dbms.

4.3 High Availability

Respecto a disponibilidad existen también diferentes soluciones

Replication
Clustering

3.3.3.1 Replication

[HOWTO] MySQL Replication

About: It took me days to figure out how to replicate database in MySQL, and the official docs are somewhat sparse. Hopefully this will help -- it's geared towards any general MySQL installation.

Edit: This guide only works with MyISAM table types (the default for MySQL).

The Master Server

MySQL replicates the data between the two databases by using binary logs stored on the master server. The first step is to setup the server so it creates them.

Create a directory to store the binary logs

This creates the directories and sets the permissions so only the mysql daemon can read/write to the logs.

Code:

$ mkdir /var/log/mysql/binary
$ chown mysql: /var/log/mysql/binary
$ chmod 770 /var/log/mysql/binary

Edit the MySQL Configuration

This turns on the binary logging, tells it where to store the logs, and creates a server id.

Code:

$ vim /etc/mysql/my.cnf

Add under the [mysqld] section.
It doesn't matter what the value for server-id is, as long as it is different from the slave's (which you will set later).
Also make sure that "bind ip_address" and "skip-networking" are commented out, so that the slave user can log in remotely.

Code:

log-bin=/var/log/mysql/binary/mysql_binary_log
binlog-do-db=database_name
server-id=1

Once you're done, restart the mysql server for the changes to take effect, and for the logging to start.

Code:

/etc/init.d/mysql restart

If you were already using binary logging before this, you don't need to make any changes, except for adding a server-id. The slave can keep up with your current binary logs, so there's no reason to delete them or flush the logs.

Setup a slave account

This both creates a new account in mysql.user, and grants replication privileges only .

Code:

$ msyql
mysql> GRANT REPLICATION SLAVE ON *.* TO 'slave_user_name'@'%' IDENTIFIED BY 'slave_password';

Adding "@'%'" means that "slave_user_name" can connect from any host. Change yours to whatever host name options you want to use.

AFAIK, you don't need to run FLUSH PRIVILEGES; in mysql for it to recognize the new account.

Get a database dump

There are two ways to get the data from the master to the slave -- this howto only covers one: exporting the actual data to a file, and then restoring it on the slave. The other option is LOAD DATA FROM MASTER; which does pretty much the same thing.

Note that you will need to have two shells open at this point -- one mysql shell and one terminal shell. The mysql shell must stay open while you do the database dump to get a clean export.

Switch to the database you want to replicate. FLUSH TABLES only locks the database you're currently using.

Code:

mysql> USE database_name;
mysql> FLUSH TABLES WITH READ LOCK;

Once again, do NOT close your mysql session until you do a mysqldump in another shell (screen comes in handy). If you do, the tables will be unlocked.

Code:

mysql> SHOW MASTER STATUS;

Once you get the MASTER STATUS results, WRITE THEM DOWN because you'll need them in a minute. Should look something like this:

Code:

Get the db dump:

Code:

$ mysqldump --opt database_name > database_name.sql

and unlock the tables

Code:

mysql> UNLOCK TABLES;

You're done now with the master server.

The Slave Server

Import the mysqldump from the master server:

Code:

mysql database_name < database_name.sql

Edit the slave's MySQL configuration to setup replication:

Code:

$ vim /etc/mysql/my.cnf

Add under the [mysqld] section.
It doesn't matter what the value for server-id is, as long as it is different from the master's.

Code:

server-id=2
# master server settings
master-host=masterhost.com
master-port=3306
master-user=slave_user_name
master-password=slave_password
master-connect-retry=60 # num of seconds, default is 60
replicate-do-db=database_name

Restart MySQL -- don't worry, it won't start slaving yet.

Code:

/etc/init.d/mysql restart

Tell the slave specifically where to start logging:

This is where you use the data from SHOW MASTER STATUS; from the master mysql database.

Code:

mysql> CHANGE MASTER TO MASTER_HOST='master_host_name', MASTER_PORT=3306, MASTER_USER='slave_user_name', MASTER_PASSWORD='slave_password', MASTER_LOG_FILE='mysql_binary_log.025', MASTER_LOG_POS=796947;

Note that you don't put quotes around the value for MASTER_LOG_POS or mysql will give you an error.

Now start slaving!

Code:

mysql> START SLAVE;

And that's it!

4.3.2 Clustering

4.3.2.1 Definición

Qué es Clustering ?

En general, cuando las personas hablan de clusters, se refieren a tecnologías que permiten a múltiples computadoras trabajar conjuntamente para resolver problemas comunes.
Dichos problemas puede ser casi cualquier cosa, desde cálculos complejos que implican uso intensivo del CPU, hasta manejar una enorme cantidad de procesos que no tienen nada en común.
Actualmente por ejemplo los clusters Beowulf (múltiples máquinas conectadas a través de una LAN de gran velocidad) creados con Linux pueden ser bastante comunes y populares.

Un cluster puede hacerse de distintas maneras y con distintos propósitos.

Formando un máquina enorme
Buscando balanceo de procesos y memoria
De bases de datos
Combinaciones de las anteriores

The following are various cluster types found in use today. If you use or intend to use one of these cluster types, you may want to consider SSI clustering as an alternative or addition.

High performance (HP) clusters, typified by Beowulf clusters , are constructed to run parallel programs (weather simulations, data mining, etc.).
Load-leveling clusters, typified by Mosix , are constructed to allow a user on one node to spread his workload transparently across all nodes in the cluster. This can be very useful for compute intensive, long running jobs that aren't massively parallel.
Web-service clusters, typified by the Linux Virtual Server (LVS) project and Piranha , do a different kind of load leveling. Incoming web service requests are load-leveled by a front end system across a set of standard servers.
Storage clusters, typified by Sistina's GFS and the OpenGFS project , consist of nodes which supply parallel, coherent, and highly available access to filesystem data.
Database clusters, typified by Oracle 9I RAC (formerly Oracle Parallel Server), consist of nodes which supply parallel, coherent, and HA access to a database.
High Availability clusters, typified by Lifekeeper , FailSafe and Heartbeat , are also often known as failover clusters. Resources, most importantly applications and nodes, are monitored. When a failure is detected, scripts are used to fail over IP addresses, disks, and filesystems, as well as restarting applications.

4.3.2.2 Cluster de Bases de Datos

Caso MySQL

Lanzado en el 2004, es el primer cluster de bases de datos open source
Al igual que con el dbms, el cluster es simple, confiable, administrable.
Provee solución para HA y HP

Un NDB Cluster database consiste de una colección de nodos de 3 tipos:

1. Uno o más management servers (MGM nodes)
2. Uno o más database/storage nodes (DB nodes)
3. Uno o más applications (API nodes)

Un nodo es un programa ejecutándose en alguna computadora

Los nodos pueden correr en diferentes computadoras (o en la misma) y se comunican a través de módulos de software llamados "transporters".

Funcionamiento

Los datos son síncronamente replicados entre los storage nodes, esto reduce al mínimo problemas de caídas por fail-over.
Los nodos están diseñados usando una arquitectura "share-nothing".
No hay puntos de falla (points of failure). Cualquien nodo puede ser eliminado sin existir pérdida de datos y sin detener las aplicaciones que usan la base.
El empleo de SQL es transparente lo cual simplifica el trabajo de developers y DBAs.
Las aplicaciones se conectan al servidor sin reparar en detalles específicos de como se encuentra almacenada la información o como son las conexiones de red.
Lo anterior permite que una aplicacion sea "portable" entre ambientes donde existe o no replication y donde existe o no clustering.

Node y System Recovery

Cuando un nodo presenta una falla, al recuperarse restaura toda la información auxiliándose de otros nodos.
Al igual que en la versión sin cluster, éste maneja bitácoras y errores que permiten mantener íntegra y consistente la inf
El cluster utiliza "pessimistic concurrency control based on locking".

Ejemplos de configuraciones:

Failed Nodes	Computers Recovery Procedure
{D2}	System Restart

Failed Nodes	Computers Recovery Procedure
{D2}, {D3}	Node Recovery
{D2, D3}	System Restart
{C1}, {C2}	Node Recovery (after computer is replaced/restarted)
{C3}, {C4}, {C3, C4}	Restart Applications and Management Server

Failed Nodes	Computers Recovery Procedure
{D2}, {D3}, {D2, D4}, {D2, D5}, {D3, D4}, {D3,D5}	Node Recovery
{D2, D3}, {D4, D5}+ all three node failures	System Restart
{C1}, {C2}	Node Recovery (after computer is replaced/restarted)
{C3}, {C4}, {C3, C4}	Restart Applications and Management Server

Failed Nodes	Computers Recovery Procedure
{D2}, {D3}, ..., {D9}	Node Recovery
{D2,D3}, {D4,D5}, {D6,D7}, {D8,D9}	System Restart
{D2,D4}, {D2,D5}, {D2,D6}, {D2,D7}, {D2,D8}, {D2,D9}	Node Recovery
{D3,D4}, {D3,D5}, {D3,D6}, {D3,D7}, {D3,D8}, {D3,D9}	Node Recovery
{D4,D6}, {D4,D7}, {D4,D8}, {D4,D9}	Node Recovery
{D5,D6}, {D5,D7}, {D4,D8}, {D4,D9}	Node Recovery
{D6,D8}, {D6,D9}	Node Recovery
{D7,D8}, {D7,D9}	Node Recovery
{C1}, {C2}	Node Recovery if Arbitrator survived
{C1}, {C2}	System Restart if Arbitrator did not survive
{C3}, {C4}, {C3, C4}	Restart Applications and Management Server

Implementación

Partimos de una configuración básica cona las siguientes máquinas

Función	Host	Port
Manager	server00	9000
Transport	server00	9099
Monitor (Manager client)	server00	-
Storage y API	server01	9001
Storage y API	server02	9002
API	server03	9003
Balancer	server00	9999

Manager

Storage1

Storage2

API

Balancer

server00

server01

server02

server03

server00

Bajar el binario de la plataforma,
en este caso lo más recomendable es la versión
4.1.9 Max de Solaris 8 Sparc 32 bits.

mysql-max-4.1.9-sun-solaris2.8-sparc.tar.gz

/carlos>gunzip mysql-max-4.1.9-sun-solaris2.8-sparc.tar.gz
/carlos>tar -xvf mysql-max-4.1.9-sun-solaris2.8-sparc.tar

....

/carlos>mv mysql-max-4.1.9-sun-solaris2.8-sparc mysql_manager

/carlos>cd mysql_manager

editar el archivo nuevo config.ini

/mysql_manager>vi config.ini

[NDBD DEFAULT]
NoOfReplicas=2
[MYSQLD DEFAULT]
[NDB_MGMD DEFAULT]
[TCP DEFAULT]
PortNumber=9099
# Managment Server
[NDB_MGMD]
HostName=server00.domain.com
# the IP of THIS SERVER
PortNumber=9000
# Storage Engines
[NDBD]
HostName=server01.domain.com
# the IP of the FIRST SERVER
DataDir= /archivos/vol880-12/carlos/mysql_1/cluster
[NDBD]
HostName=server02.domain.com
# the IP of the SECOND SERVER
DataDir=/archivos/vol880-12/carlos/mysql_2/cluster
# 2 MySQL Clients
# I personally leave this blank to allow rapid changes of the mysql clients;
# you can enter the hostnames of the above two servers here. I suggest you dont.
[MYSQLD]
[MYSQLD]
[MYSQLD]

iniciamos el manager

/mysql_manager>bin/ndb_mgmd -f config.ini

listo el manager ya esta corriendo

/mysql_manager>bin/ndb_mgm --connect-string=server00.domain.com:9000

ndb_mgm> show
Connected to Management Server at: localhost:9000
Cluster Configuration
---------------------
[ndbd(NDB)] 2 node(s)
id=2 (not connected, accepting connect from server01
id=3 (not connected, accepting connect from server02