Créer et distribuer des tables dans Azure Cosmos DB for PostgreSQL

S’APPLIQUE À : Azure Cosmos DB for PostgreSQL (avec l’extension de base de données Citus pour PostgreSQL)

Dans cet exemple, nous utilisons des tables distribuées Azure Cosmos DB for PostgreSQL pour stocker et interroger les événements enregistrés par les contributeurs GitHub open source.

Prérequis

Pour suivre ce démarrage rapide, vous devez d’abord :

1. Créer un cluster dans le portail Azure.
2. Vous connecter au cluster avec psql pour exécuter des commandes SQL.

Créer des tables

Une fois que vous vous êtes connecté via psql, vous allez créer vos tables. Copiez et collez les commandes suivantes dans la fenêtre de terminal psql, puis appuyez sur Entrée pour les exécuter :

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

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 INDEX event_type_index ON github_events (event_type);
CREATE INDEX payload_index ON github_events USING GIN (payload jsonb_path_ops);

Notez l’index GIN sur payload dans github_events. L’index autorise l’interrogation rapide dans la colonne JSONB. Comme Citus est une extension PostgreSQL, Azure Cosmos DB for PostgreSQL prend en charge des fonctionnalités PostgreSQL avancées comme le type de données JSONB pour stocker des données semi-structurées.

Distribuer des tables

create_distributed_table() est la fonction magique fournie par Azure Cosmos DB for PostgreSQL pour distribuer des tables et utiliser des ressources sur plusieurs machines. La fonction décompose les tables en partitions, qui peuvent être réparties entre les nœuds pour augmenter les performances de stockage et de calcul.

Notes

Dans des applications réelles, quand votre charge de travail loge dans 64 vCores, 256 Go de RAM et 2 To de stockage, vous pouvez utiliser un cluster à nœud unique. Dans ce cas, la distribution de tables est facultative. Vous pouvez distribuer des tables plus tard selon vos besoins à l’aide de create_distributed_table_concurrently.

Distribuons les tables :

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

Important

La distribution de tables ou l’utilisation du partitionnement basé sur un schéma est nécessaire pour tirer parti des fonctionnalités de performances d’Azure Cosmos DB for PostgreSQL. Si vous ne distribuez pas de tables ou de schémas, les nœuds Worker ne peuvent s’empêcher d’exécuter des requêtes impliquant leurs tables.

Charger des données dans des tables distribuées

Nous sommes prêts à remplir les tables avec des exemples de données. Pour ce guide de démarrage rapide, nous allons utiliser un jeu de données capturé précédemment à partir de l’API GitHub.

Nous allons utiliser l’extension pg_azure_storage pour charger les données directement à partir d’un conteneur public dans Stockage Blob Azure. Tout d’abord, nous devons créer l’extension dans notre base de données :

SELECT * FROM create_extension('azure_storage');

Exécutez les commandes suivantes pour que la base de données récupère les exemples de fichiers CSV et les charger dans les tables de base de données.

-- download users and store in table

COPY github_users FROM 'https://pgquickstart.blob.core.windows.net/github/users.csv.gz';

-- download events and store in table

COPY github_events FROM 'https://pgquickstart.blob.core.windows.net/github/events.csv.gz';

Notez que l’extension a reconnu que les URL fournies à la commande de copie proviennent de Stockage Blob Azure, que les fichiers que nous avons signalés ont été compressés en gzip et que cela a également été géré automatiquement pour nous.

Nous pouvons passer en revue les détails de nos tables distribuées, y compris leur taille, avec la vue citus_tables :

SELECT * FROM citus_tables;

  table_name   | citus_table_type | distribution_column | colocation_id | table_size | shard_count | table_owner | access_method 
---------------+------------------+---------------------+---------------+------------+-------------+-------------+---------------
 github_events | distributed      | user_id             |             1 | 388 MB     |          32 | citus       | heap
 github_users  | distributed      | user_id             |             1 | 39 MB      |          32 | citus       | heap
(2 rows)

Étapes suivantes

Nous avons maintenant des tables distribuées et les avons chargées avec des données. Ensuite, essayons d’exécuter des requêtes sur les tables distribuées.

Exécuter des requêtes distribuées>