Equilibrio de Carga – Paralelismo

Pgpool es un pool de conexiones y hace mucho más que eso.

¿Qué es pgpool -II (de pg -pool wiki ) :

pgpool -II es un middleware que funciona entre servidores PostgreSQL y un cliente de base de datos PostgreSQL. Está autorizado bajo la licencia BSD . Ofrece las siguientes características:

Agrupación de conexiones – Connection Pooling
pgpool -II ahorra conexiones a los servidores PostgreSQL , y las reutiliza cada vez que llega una nueva conexión con las mismas propiedades ( es decir, nombre de usuario, bases de datos, la versión del protocolo ) reduce la sobrecarga de la conexión , y mejora el rendimiento global del sistema.
Replicación – Replication
pgpool -II puede gestionar múltiples servidores PostgreSQL . Usando la función de replicación permite crear una copia de seguridad en tiempo real en 2 o más discos físicos , por lo que el servicio pueda continuar sin detener servidores en caso de un fallo de disco.
Equilibrio de carga – Load Balancing
Si  una base de datos es replicada, ejecutar una consulta SELECT en cualquier servidor devolverá el mismo resultado. pgpool – II obtiene ventaja de la función de replicación para reducir la carga en cada servidor PostgreSQL mediante la distribución de consultas SELECT entre varios servidores , mejorando el rendimiento global del sistema. A lo sumo, el rendimiento mejora en proporción al número de servidores PostgreSQL . Equilibrio de carga funciona mejor en una situación en la que hay una gran cantidad de usuarios que ejecutan muchas consultas al mismo tiempo.
Limitar Exceder Conexiones – Limiting Exceeding Connections
Hay un límite en el número máximo de conexiones simultáneas con PostgreSQL, y las conexiones son rechazadas después de esta cantidad de conexiones. Configurando el número máximo de conexiones a un nivel alto, aumenta el consumo de recursos y puede afectar al rendimiento del sistema . pgpool -II también tiene un límite en el número máximo de conexiones , pero las conexiones adicionales se pondrá en cola de espera en lugar de devolver un error de inmediato.
Consulta en paralelo – Parallel Query
Usando la función de consulta en paralelo, los datos se pueden dividir entre los múltiples servidores, por lo que una consulta se puede ejecutar en todos los servidores a la vez para reducir el tiempo total de ejecución. La consulta en paralelo funciona mejor en la búsqueda de datos a gran escala.

La característica que queremos explorar en este post es ballanceo y equilibrio de carga. Nos gusta esta característica, ya que sin cambiar la aplicación puedes elevar su réplica un paso y hacer que sea aún más útil.

Configurando 3 máquinas virtuales que llamaremos pgpool1 , pgnode1 , pgnode2 .
Configuraremos una instalación básica de Debian Linux y compilar pgpool -II ( 3.3.2) y PostgreSQL 9.3.2 .
Como primer paso de instalación configuraremos una réplica básica entre pgnode1 y pgnode2 con pgpool1 para ballancing de carga . No entraremos mucho en detalles sobre cómo configurar pgPool , los archivos de configuración pueden encontrarlos en el foro de ayuda y deben ser una buena guía, me encontré con que la documentación de pgpool es muy informativa.
Estaremos más en el diseño y lo que podrías hacer con esto.
Como todos sabemos, el streaming de replicación es casi instantánea en separar ” leer ” de ” escritura ” y es beneficioso en una gran variedad de aplicaciones, pero especialmente para los más lecturas que escrituras , así que vamos a ver cómo funciona esto :

root@pgpool1:~# psql -p 9999 -U postgres
postgres=# create database datacenter;
CREATE DATABASE
postgres=# \connect datacenter;
You are now connected to database “datacenter” as user “postgres”.
datacenter=# create table test (id int);
CREATE TABLE
datacenter=# insert into test values (1);
INSERT 0 1
datacenter=# select * from test;
id
—-
1
(1 row)

Con la característica full logging habilitada en las bases de datos, veremos el archivo de logs de pgnode1 y pgnode2 :

pgnode1:
LOG:  duration: 342.044 ms  statement: create database datacenter;
LOG:  duration: 4.646 ms  statement: create table test (id int);
LOG:  duration: 1.733 ms  statement: insert into test values (1);

pgnode2:
LOG:  duration: 1.018 ms  statement: select * from test;

Funcionó como debería.

Pero, ¿qué pasaría con 2 réplicas ? Sabemos que las operaciones de lectura deben ampliarse y que deben ser distribuidos entre los esclavos, he creado otro cluster de bases de datos en pgnode2 (puerto 5433 ) y lo hice réplica al pgnode1 , Así que ahora tengo un maestro que se ejecuta en pgnode1 y dos esclavos que se ejecutan en pgnode2 ( 5432 y 5433 ) .
He cambiado la configuración pgpool para agregar a la nueva db:

backend_hostname0 = ‘192.168.0.202’
backend_port0 = 5432
backend_weight0 = 0
backend_data_directory0 = ‘/opt/pgdata’

backend_hostname1 = ‘192.168.0.203’
backend_port1 = 5432
backend_weight1 = 1
backend_data_directory1 = ‘/opt/pgdata’

backend_hostname2 = ‘192.168.0.203’
backend_port2 = 5433
backend_weight2 = 1
backend_data_directory2 = ‘/opt/pgdata2’

y desde pgpool1 he corrido :
while true; do psql -p 9999  -c ‘selecT * from test;’  -U postgres ;done

Voilà , tengo mis selects distribuidos entre mis dos servidores esclavos.
pgpool tiene un montón de características interesantes , con las pruebas con balanceo de carga  todo corre suave, pgpool también tiene una interfaz gráfica de usuario basada en web vale la pena mirar y algunas views del sistema que se pueden utilizar para controlar la actividad , también es compatible con la conmutación por error automática, vigilancia y muchos muchos otras características interesantes.

todas las configuraciones se pueden encontrar en el foro de ayuda (incluyendo las configuraciones postgres que se utilizaron ) .

Gracias por leer