Microsserviços

Neste tutorial, você usará o Azure Cosmos DB for PostgreSQL como back-end de armazenamento para vários microsserviços, demonstrando uma configuração de exemplo e uma operação básica desse cluster. Saiba como:

• Criar um cluster
• Criar funções para seus microsserviços
• Usar o utilitário psql para criar funções e esquemas distribuídos
• Criar tabelas para os serviços de exemplo
• Configurar os serviços
• Executar serviços
• Explore o banco de dados

APLICA-SE AO: Azure Cosmos DB for PostgreSQL (da plataforma da extensão de dados Citus para PostgreSQL)

Pré-requisitos

Se você não tiver uma assinatura do Azure, crie uma conta gratuita antes de começar.

Criar um cluster

Entre no portal do Azure e siga estas etapas para criar um cluster do Azure Cosmos DB for PostgreSQL:

Link direto

Acesse Criar cluster do Azure Cosmos DB for PostgreSQL no portal do Azure.

Pesquisa no portal

1. No portal do Azure, pesquise cosmosdb e selecione Azure Cosmos DB nos resultados.

   

2. Na tela Azure Cosmos DB, selecione Criar.

   

3. Na tela Selecionar opção de API, escolha Criar no bloco do PostgreSQL.

   

No formulário Criar cluster do Azure Cosmos DB for PostgreSQL:

1. Preencha as informações na guia Básico.

   

   A maioria das opções é auto-explicativa, mas tenha em mente que:

   • O nome do cluster determina o nome DNS que os aplicativos usarão para estabelecer conexão, no formato <node-qualifier>-<clustername>.<uniqueID>.postgres.cosmos.azure.com.
   • Você pode escolher uma versão principal do PostgreSQL, como a 15. O Azure Cosmos DB for PostgreSQL sempre dá suporte para a versão mais recente do Citus para a versão principal do Postgres selecionada.
   • O nome de usuário do administrador precisa ser o valor citus.
   • Você pode deixar o nome do banco de dados com o valor padrão "citus" ou definir seu próprio nome de banco de dados. O banco de dados não pode ser renomeado após o provisionamento do cluster.

2. Selecione Avançar: Rede na parte inferior da tela.

3. Na tela Rede, selecione Permitir acesso público de serviços e recursos no Azure a este cluster.

   

4. Selecione Revisar + criar e, quando a validação for aprovada, selecione Criar para criar o cluster.

5. O provisionamento demora alguns minutos. A página redirecionará você para monitorar a implantação. Quando o status mudar de A implantação está em andamento para A implantação foi concluída, clique em Acessar recurso.

Criar funções para seus microsserviços

Os esquemas distribuídos são relocáveis em um cluster do Azure Cosmos DB for PostgreSQL. O sistema pode rebalanceá-los como uma unidade inteira entre os nós disponíveis, permitindo compartilhar recursos com eficiência sem alocação manual.

Os microsserviços possuem uma camada de armazenamento intencionalmente. Não fazemos suposições sobre o tipo de tabelas e dados que eles criam e armazenam. Fornecemos um esquema para cada serviço e presumimos que eles usam uma FUNÇÃO diferente para se conectar ao banco de dados. Quando um usuário se conecta, o respectivo nome de função é colocado no início do search_path. Portanto, se a função corresponder ao nome do esquema, você não precisará de alterações de aplicativo para definir o search_path correto.

Usamos três serviços em nosso exemplo:

• usuário
• time
• ping

Siga as etapas que descrevem como criar funções de usuário e crie as seguintes funções para cada serviço:

• userservice
• timeservice
• pingservice

Usar o utilitário psql para criar esquemas distribuídos

Depois de conectado ao Azure Cosmos DB for PostgreSQL usando psql, você pode concluir algumas tarefas básicas.

Há duas maneiras pelas quais um esquema pode ser distribuído no Azure Cosmos DB for PostgreSQL:

Chamando a função citus_schema_distribute(schema_name) manualmente:

CREATE SCHEMA AUTHORIZATION userservice;
CREATE SCHEMA AUTHORIZATION timeservice;
CREATE SCHEMA AUTHORIZATION pingservice;

SELECT citus_schema_distribute('userservice');
SELECT citus_schema_distribute('timeservice');
SELECT citus_schema_distribute('pingservice');

Esse método também permite converter os esquemas regulares existentes em esquemas distribuídos.

Observação

Você só pode distribuir esquemas que não contêm tabelas distribuídas e de referência.

A abordagem alternativa é habilitar a variável de configuração citus.enable_schema_based_sharding:

SET citus.enable_schema_based_sharding TO ON;

CREATE SCHEMA AUTHORIZATION userservice;
CREATE SCHEMA AUTHORIZATION timeservice;
CREATE SCHEMA AUTHORIZATION pingservice;

A variável pode ser alterada para a sessão atual ou permanentemente nos parâmetros de nó coordenador. Com o parâmetro definido como ON, todos os esquemas criados são distribuídos por padrão.

Você pode listar os esquemas distribuídos no momento executando:

select * from citus_schemas;

 schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
 userservice |             5 | 0 bytes     | userservice
 timeservice |             6 | 0 bytes     | timeservice
 pingservice |             7 | 0 bytes     | pingservice
(3 rows)

Criar tabelas para os serviços de exemplo

Agora você precisa se conectar ao Azure Cosmos DB for PostgreSQL para cada microsserviço. Você pode usar o comando \c para trocar o usuário em uma instância psql existente.

\c citus userservice

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) NOT NULL
);

\c citus timeservice

CREATE TABLE query_details (
    id SERIAL PRIMARY KEY,
    ip_address INET NOT NULL,
    query_time TIMESTAMP NOT NULL
);

\c citus pingservice

CREATE TABLE ping_results (
    id SERIAL PRIMARY KEY,
    host VARCHAR(255) NOT NULL,
    result TEXT NOT NULL
);

Configurar os serviços

Neste tutorial, usamos um conjunto simples de serviços. Você pode obtê-los clonando este repositório público:

git clone https://github.com/citusdata/citus-example-microservices.git

$ tree
.
├── LICENSE
├── README.md
├── ping
│   ├── app.py
│   ├── ping.sql
│   └── requirements.txt
├── time
│   ├── app.py
│   ├── requirements.txt
│   └── time.sql
└── user
    ├── app.py
    ├── requirements.txt
    └── user.sql

No entanto, antes de executar os serviços, edite arquivos user/app.py, ping/app.py e time/app.py fornecendo a configuração de conexão para o cluster do Azure Cosmos DB for PostgreSQL:

# Database configuration
db_config = {
    'host': 'c-EXAMPLE.EXAMPLE.postgres.cosmos.azure.com',
    'database': 'citus',
    'password': 'SECRET',
    'user': 'pingservice',
    'port': 5432
}

Depois de fazer as alterações, salve todos os arquivos modificados e passe para a próxima etapa de execução dos serviços.

Executar serviços

Altere em cada diretório de aplicativo e execute-os em seu próprio ambiente Python.

cd user
pipenv install
pipenv shell
python app.py

Repita os comandos para o serviço de tempo e de ping, após o qual você pode usar a API.

Crie alguns usuários:

curl -X POST -H "Content-Type: application/json" -d '[
  {"name": "John Doe", "email": "john@example.com"},
  {"name": "Jane Smith", "email": "jane@example.com"},
  {"name": "Mike Johnson", "email": "mike@example.com"},
  {"name": "Emily Davis", "email": "emily@example.com"},
  {"name": "David Wilson", "email": "david@example.com"},
  {"name": "Sarah Thompson", "email": "sarah@example.com"},
  {"name": "Alex Miller", "email": "alex@example.com"},
  {"name": "Olivia Anderson", "email": "olivia@example.com"},
  {"name": "Daniel Martin", "email": "daniel@example.com"},
  {"name": "Sophia White", "email": "sophia@example.com"}
]' http://localhost:5000/users

Listar os usuários criados:

curl http://localhost:5000/users

Obtenha a hora atual:

Get current time:

Execute o ping em example.com:

curl -X POST -H "Content-Type: application/json" -d '{"host": "example.com"}' http://localhost:5002/ping

Explore o banco de dados

Agora que você chamou algumas funções de API, os dados foram armazenados e você pode verificar se citus_schemas reflete o que é esperado:

select * from citus_schemas;

 schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
 userservice |             1 | 112 kB      | userservice
 timeservice |             2 | 32 kB       | timeservice
 pingservice |             3 | 32 kB       | pingservice
(3 rows)

Quando você criou os esquemas, não disse ao Azure Cosmos DB for PostgreSQL em quais computadores os esquemas devem ser criados. Isso foi feito automaticamente. Você pode ver onde cada esquema reside com a seguinte consulta:

  select nodename,nodeport, table_name, pg_size_pretty(sum(shard_size))
    from citus_shards
group by nodename,nodeport, table_name;

nodename  | nodeport |         table_name         | pg_size_pretty
-----------+----------+---------------------------+----------------
 localhost |     9701 | timeservice.query_details | 32 kB
 localhost |     9702 | userservice.users         | 112 kB
 localhost |     9702 | pingservice.ping_results  | 32 kB

Para fins de brevidade da saída de exemplo nesta página, em vez de usar nodename, conforme exibido no Azure Cosmos DB for PostgreSQL, substituímos por localhost. Suponha que localhost:9701 é o trabalho um e localhost:9702 é o trabalho dois. Os nomes de nós no serviço gerenciado são mais longos e contêm elementos aleatórios.

Você pode ver que o serviço de tempo chegou ao nó localhost:9701, enquanto o usuário e o espaço de compartilhamento de serviço de ping no segundo trabalho localhost:9702. Os aplicativos de exemplo são simplistas e os tamanhos de dados aqui são ignoráveis, mas vamos supor que você esteja irritado com a utilização de espaço de armazenamento desigual entre os nós. Faria mais sentido fazer com que os dois serviços menores de ping e tempo residam em um computador, enquanto o serviço grande de usuário reside sozinho.

Você pode reequilibrar facilmente o cluster pelo tamanho do disco:

select citus_rebalance_start();

NOTICE:  Scheduled 1 moves as job 1
DETAIL:  Rebalance scheduled as background job
HINT:  To monitor progress, run: SELECT * FROM citus_rebalance_status();
 citus_rebalance_start
-----------------------
                     1
(1 row)

Quando terminar, você pode verificar a aparência do novo layout:

  select nodename,nodeport, table_name, pg_size_pretty(sum(shard_size))
    from citus_shards
group by nodename,nodeport, table_name;

 nodename  | nodeport |         table_name        | pg_size_pretty
-----------+----------+---------------------------+----------------
 localhost |     9701 | timeservice.query_details | 32 kB
 localhost |     9701 | pingservice.ping_results  | 32 kB
 localhost |     9702 | userservice.users         | 112 kB
(3 rows)

De acordo com as expectativas, os esquemas foram movidos e temos um cluster mais equilibrado. Essa operação foi transparente para os aplicativos. Você nem precisa reiniciá-los, eles continuam atendendo as consultas.

Próximas etapas

Neste tutorial, você aprendeu a criar esquemas distribuídos, executou microsserviços usando-os como armazenamento. Você também aprendeu a explorar e gerenciar o Azure Cosmos DB for PostgreSQL fragmentado baseado em esquema.

• Saiba mais sobre os tipos de nós de cluster