Partilhar via

Criar e distribuir tabelas no Azure Cosmos DB para PostgreSQL

  • Aplica-se a: ✅ PostgreSQL

Importante

O Azure Cosmos DB para PostgreSQL não tem mais suporte para novos projetos. Não use este serviço para novos projetos. Em vez disso, use um destes dois serviços:

  • Use o Azure Cosmos DB para NoSQL para obter uma solução de banco de dados distribuído projetada para cenários de alta escala com um SLA (contrato de nível de serviço) de disponibilidade de 99.999%, dimensionamento automático instantâneo e failover automático em várias regiões.

  • Use a funcionalidade de Clusters Elásticos do Azure para PostgreSQL para PostgreSQL fragmentado, utilizando a extensão Citus de código aberto.

Neste exemplo, usaremos o Azure Cosmos DB para tabelas distribuídas PostgreSQL para armazenar e consultar eventos registrados de colaboradores de código aberto do GitHub.

Pré-requisitos

Para seguir este guia de início rápido, primeiro você precisará:

  1. Crie um cluster no portal do Azure.
  2. Conecte-se ao cluster com psql para executar comandos SQL.

Criar tabelas

Depois de se conectar via psql, vamos criar nossa tabela. Copie e cole os seguintes comandos na janela do terminal psql e pressione enter para executar:

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);

Observe o índice GIN em payload em github_events. O índice permite consultas rápidas na coluna JSONB. Como o Citus é uma extensão do PostgreSQL, o Azure Cosmos DB para PostgreSQL oferece suporte a recursos avançados do PostgreSQL, como o tipo de dados JSONB para armazenar dados semiestruturados.

Distribuir tabelas

create_distributed_table() é a função mágica que o Azure Cosmos DB para PostgreSQL fornece para distribuir tabelas e usar recursos em várias máquinas. A função decompõe tabelas em fragmentos, que podem ser espalhados pelos nós para aumentar o desempenho de armazenamento e computação.

Nota

Em aplicativos reais, quando sua carga de trabalho se encaixa em 64 vCores, 256 GB de RAM e 2 TB de armazenamento, você pode usar um cluster de nó único. Neste caso, a distribuição de tabelas é opcional. Mais tarde, você pode distribuir tabelas conforme necessário usando create_distributed_table_concurrently.

Vamos distribuir as tabelas:

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

Importante

Distribuir tabelas ou usar fragmentação baseada em esquema é necessário para aproveitar os recursos de desempenho do Azure Cosmos DB para PostgreSQL. Se você não distribuir tabelas ou esquemas, os nós de trabalho não poderão ajudar a executar consultas envolvendo seus dados.

Carregar dados em tabelas distribuídas

Estamos prontos para preencher as tabelas com dados de exemplo. Para este início rápido, usaremos um conjunto de dados capturado anteriormente da API do GitHub.

Vamos usar a extensão pg_azure_storage para carregar os dados diretamente de um contêiner público no Armazenamento de Blobs do Azure. Primeiro precisamos criar a extensão em nosso banco de dados:

SELECT * FROM create_extension('azure_storage');

Execute os comandos a seguir para que o banco de dados busque os arquivos CSV de exemplo e os carregue nas tabelas do banco de dados.

-- 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';

Observe como a extensão detetou automaticamente que as URLs fornecidas ao comando "copy" são do Armazenamento de Blobs do Azure, os ficheiros que indicámos foram comprimidos em gzip, e isso também foi processado automaticamente para nós.

Podemos analisar os detalhes das nossas tabelas distribuídas, incluindo os seus tamanhos, com a citus_tables visualização.

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)

Próximos passos

Agora distribuímos tabelas e as carregamos com dados. Em seguida, vamos tentar executar consultas nas tabelas distribuídas.

Executar consultas distribuídas >

  • Last updated on