Inicio rápido: Creación de un grupo de servidores Citus en Azure Portal

Artículo
05/13/2021
7 minutos para leer

Azure Database for PostgreSQL es un servicio administrado que usa para ejecutar, administrar y escalar bases de datos de PostgreSQL de alta disponibilidad en la nube. Este inicio rápido muestra cómo crear un grupo de servidores de Hiperescala (Citus) de Azure Database for PostgreSQL mediante Azure Portal. Explorará los datos distribuidos: tablas de particionamiento entre nodos, ingesta de datos de ejemplo y ejecución de consultas que se ejecutan en varios nodos.

Creación de un grupo de servidores Hiperescala (Citus)

Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

Inicie sesión en Azure Portal.

Para crear un servidor de Azure Database for PostgreSQL, siga estos pasos:

Haga clic en Crear un recurso de la esquina superior izquierda de Azure Portal.
En la página Nuevo, seleccione Bases de datos y, en la página Bases de datos, seleccione Azure Database for PostgreSQL.
En la opción de implementación, haga clic en el botón Crear en el grupo de servidores de Hiperescala (Citus).
Rellene el formulario del nuevo servidor con la siguiente información:
- Grupo de recursos: haga clic en el vínculo Crear nuevo que está debajo de este cuadro de texto para este campo. Escriba un nombre como myresourcegroup.
- Nombre del grupo de servidores: escriba un nombre exclusivo para el nuevo grupo de servidores, que también se usará para un subdominio de servidor.
- Nombre de usuario de administrador: actualmente, se necesita el valor citus y no se puede cambiar.
- Contraseña: tiene que tener al menos ocho caracteres de las tres categorías siguientes: letras mayúsculas del alfabeto inglés, letras minúsculas del alfabeto inglés, números (0-9) y caracteres no alfanuméricos (!, $, # o %, entre otros)
- Ubicación: use la ubicación más cercana a los usuarios para que puedan acceder de la forma más rápida posible a los datos.
Importante

Se precisa la contraseña de administrador del servidor que especifique aquí para iniciar sesión en el servidor y sus bases de datos. Recuerde o grabe esta información para su uso posterior.
Haga clic en Configurar grupo de servidores. No modifique los valores de esa sección y haga clic en Guardar.
Haga clic en Siguiente: Redes > en la parte inferior de la pantalla.
En la pestaña Redes, haga clic en el botón de radio Punto de conexión público.
Haga clic en el vínculo + Agregar dirección IP del cliente actual.

Nota

El servidor Azure PostgreSQL se comunica a través de puerto 5432. Si intenta conectarse desde una red corporativa, es posible que el firewall de la red no permita el tráfico saliente a través del puerto 5432. En este caso, no se podrá conectar al clúster de Hiperscala (Citus), salvo que el departamento de TI abra el puerto 5432.
Haga clic en Revisar y crear y luego en Crear para aprovisionar el servidor. El aprovisionamiento tarda unos minutos.
La página irá a la supervisión de la implementación. Cuando el estado activo cambia de La implementación está en curso a Se completó la implementación, haga clic en el elemento de menú Salidas que se encuentra a la izquierda de la página.
La página de resultados incluirá un nombre de host de coordinación junto a un botón para copiar el valor en el Portapapeles. Anote esta información para usarla más adelante.

Conexión a la base de datos mediante psql

Al crear el servidor de Azure Database for PostgreSQL, también se crea la base de datos predeterminada denominada citus. Para conectarse al servidor de bases de datos, necesita una cadena de conexión y la contraseña de administrador.

Obtenga la cadena de conexión. En la página del grupo de servidores, haga clic en el elemento de menú Cadenas de conexión. (Se encuentra en Configuración). Busque la cadena marcada como psql. Tendrá el formato:
```
psql "host=hostname.postgres.database.azure.com port=5432 dbname=citus user=citus password={your_password} sslmode=require"
```
Copie la cadena. Deberá reemplazar "{su_contraseña}" por la contraseña administrativa que eligió anteriormente. El sistema no almacena la contraseña de texto no cifrado y, por lo tanto, no puede mostrarla en la cadena de conexión.
Abra una ventana del terminal en el equipo local.
En el símbolo de sistema, conéctese al servidor de Azure Database for PostgreSQL con la utilidad psql. Pase la cadena de conexión entre comillas, asegurándose de que contiene la contraseña:
```
psql "host=..."
```
Por ejemplo, el siguiente comando se conecta al nodo de coordinación del grupo de servidores mydemoserver:
```
psql "host=mydemoserver-c.postgres.database.azure.com port=5432 dbname=citus user=citus password={your_password} sslmode=require"
```

Creación y distribución de tablas

Una vez conectado al nodo coordinador de hiperescala mediante psql, puede completar algunas tareas básicas.

Dentro de los servidores de Hiperescala (Citus) hay tres tipos de tablas:

Tablas particionadas o distribuidas (repartidas para ayudar a escalar para el rendimiento y paralelización)
Tablas de referencia (se mantienen varias copias)
Tablas locales (se usan frecuentemente para las tablas de administración interna)

En este inicio rápido nos centraremos principalmente en las tablas distribuidas para familiarizarnos con ellas.

El modelo de datos con el que vamos a trabajar es simple: datos de usuario y eventos desde GitHub. Los eventos incluyen la creación de una bifurcación, confirmaciones git relacionadas con una organización y más.

Una vez que se haya conectado a través de psql vamos a crear nuestras tablas. En la consola de psql ejecute lo siguiente:

CREATE TABLE github_events
(
    event_id bigint,
    event_type text,
    event_public boolean,
    repo_id bigint,
    payload jsonb,
    repo jsonb,
    user_id bigint,
    org jsonb,
    created_at timestamp
);

CREATE TABLE github_users
(
    user_id bigint,
    url text,
    login text,
    avatar_url text,
    gravatar_id text,
    display_login text
);

El campo payload de github_events tiene un tipo de datos JSONB. JSONB es el tipo de datos JSON en formato binario en Postgres. Este tipo de datos facilita el almacenamiento de un esquema flexible en una sola columna.

Postgres puede crear un índice GIN en este tipo que indexará cada clave y valor dentro de él. Con un índice, consultar la carga con varias condiciones pasa a ser una tarea rápida y fácil. Sigamos adelante, ahora vamos a crear un par de índices antes de cargar los datos. En psql:

CREATE INDEX event_type_index ON github_events (event_type);
CREATE INDEX payload_index ON github_events USING GIN (payload jsonb_path_ops);

A continuación, con esas tablas Postgres en el nodo de coordinación, indicaremos a Hiperescala (Citus) que las particione entre los roles de trabajo. Para ello, ejecutaremos una consulta para cada tabla especificando la clave en la que se va a particionar. En el ejemplo actual, vamos a particionar la tabla de usuarios y de eventos en user_id:

SELECT create_distributed_table('github_events', 'user_id');
SELECT create_distributed_table('github_users', 'user_id');

Importante

La distribución de tablas es necesaria para aprovechar las características de rendimiento de Hiperescala. Si no distribuye tablas, los nodos de trabajo no pueden ayudar a ejecutar las consultas que impliquen a esas tablas.

Ya estamos preparados para cargar los datos. En psql todavía, aplique un shell para descargar los archivos:

\! curl -O https://examples.citusdata.com/users.csv
\! curl -O https://examples.citusdata.com/events.csv

A continuación, cargue los datos de los archivos en las tablas distribuidas:

SET CLIENT_ENCODING TO 'utf8';

\copy github_events from 'events.csv' WITH CSV
\copy github_users from 'users.csv' WITH CSV

Ejecutar consultas

Ahora llega la parte más divertida: vamos a ejecutar algunas consultas. Comencemos con un sencillo count (*) para ver cuántos datos hemos cargado:

SELECT count(*) from github_events;

Esto ha ido muy bien. Volveremos a ese tipo de agregación más tarde, pero ahora vamos a echar un vistazo a otras consultas. Dentro de la columna payload de JSONB existe una cantidad importante de datos, pero varían en función del tipo de evento. Los eventos PushEvent contienen un tamaño que incluye el número de diferentes confirmaciones para la inserción. Se puede usar para buscar el número total de confirmaciones por hora:

SELECT date_trunc('hour', created_at) AS hour,
       sum((payload->>'distinct_size')::int) AS num_commits
FROM github_events
WHERE event_type = 'PushEvent'
GROUP BY hour
ORDER BY hour;

Hasta ahora, las consultas que hemos realizado solo han utilizado github_events, pero podemos combinar esta información con github_users. Como hemos particionado tanto los usuarios como los eventos en el mismo identificador (user_id), las filas de ambas tablas con identificadores de usuario que coincidan se coubicarán en los mismos nodos de base de datos con lo que pueden combinarse fácilmente.

Si incorporamos user_id, Hiperescala (Citus) puede insertar la ejecución conjunta en particiones para su ejecución en paralelo en nodos de trabajo. Por ejemplo, vamos a buscar los usuarios que hayan creado el mayor número de repositorios:

SELECT gu.login, count(*)
  FROM github_events ge
  JOIN github_users gu
    ON ge.user_id = gu.user_id
 WHERE ge.event_type = 'CreateEvent'
   AND ge.payload @> '{"ref_type": "repository"}'
 GROUP BY gu.login
 ORDER BY count(*) DESC;

Limpieza de recursos

En los pasos anteriores, creó recursos de Azure en un grupo de servidores. Si no cree que vaya a necesitar estos recursos en el futuro, elimine el grupo de servidores. Presione el botón Eliminar en la página Información general del grupo de servidores. Cuando aparezca una página emergente en la que se le pida hacerlo, confirme el nombre del grupo de servidores y haga clic en el botón Eliminar final.

Pasos siguientes

En este inicio rápido, aprendió a aprovisionar un grupo de servidores de Hiperescala (Citus). Se conectó a él con psql, creó un esquema y distribuyó datos.

Siga un tutorial para crear aplicaciones escalables multiinquilino.
Determine el mejor tamaño inicial para el grupo de servidores.