Microsserviços

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

APLICA-SE A: Azure Cosmos DB para PostgreSQL (alimentado pela extensão de banco de dados Citus para PostgreSQL)

Pré-requisitos

Se não tiver uma subscrição 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 para PostgreSQL:

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

1. Preencha as informações no separador Básicas.

   

   A maioria das opções são autoexplicativas, mas tenha em atenção:

   • O nome do cluster determina o nome DNS que seus aplicativos usam para se conectar, 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 para PostgreSQL sempre suporta a versão mais recente do Citus para a versão principal selecionada do Postgres.
   • O nome de utilizador do administrador deve ser o valor citus.
   • Você pode deixar o nome do banco de dados em seu valor padrão 'citus' ou definir seu único nome de banco de dados. Não é possível renomear o banco de dados após o provisionamento do cluster.

2. Selecione Next : Networking na parte inferior da tela.

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

   

4. Selecione Analisar + criar e, quando a validação passar, selecione Criar para criar o cluster.

5. O aprovisionamento demora alguns minutos. A página redireciona para a monitorização da implementação. Quando o estado é alterado de Implementação a decorrer para A implementação está concluída, selecione Aceder ao recurso.

Criar funções para seus microsserviços

Os esquemas distribuídos são realocáveis dentro de um cluster do Azure Cosmos DB para PostgreSQL. O sistema pode reequilibrá-los como uma unidade inteira entre os nós disponíveis, permitindo compartilhar recursos de forma eficiente sem alocação manual.

Por design, os microsserviços possuem sua camada de armazenamento, 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 assumimos que eles usam uma FUNÇÃO distinta para se conectar ao banco de dados. Quando um usuário se conecta, seu 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 nenhuma alteração no aplicativo para definir o search_path correto.

Utilizamos três serviços no nosso exemplo:

• Utilizador
• hora
• Ping

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

• userservice
• timeservice
• pingservice

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

Uma vez conectado ao Azure Cosmos DB para 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 para PostgreSQL:

Manualmente chamando citus_schema_distribute(schema_name) a função:

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 esquemas regulares existentes em esquemas distribuídos.

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

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 do 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 atualmente distribuídos 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 para PostgreSQL para cada microsserviço. Você pode usar o comando \c para trocar o usuário dentro de 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 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

Antes de executar os serviços, no entanto, edite user/app.pyping/app.py e time/app.py os arquivos que fornecem a configuração de conexão para seu cluster do Azure Cosmos DB para 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

Mude para cada diretório de aplicativos e execute-os em seu próprio python env.

cd user
pipenv install
pipenv shell
python app.py

Repita os comandos para o serviço de tempo e 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

Liste os usuários criados:

curl http://localhost:5000/users

Obter hora atual:

Get current time:

Execute o ping contra example.com:

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

Explore a base de dados

Agora que você chamou algumas funções da 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 para PostgreSQL em quais máquinas criar os esquemas. 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 brevidade da saída de exemplo nesta página, em vez de usar nodename como exibido no Azure Cosmos DB para PostgreSQL, nós a substituímos por localhost. Suponha que localhost:9701 é trabalhador um e localhost:9702 é trabalhador dois. Os nomes de nó no serviço gerenciado são mais longos e contêm elementos aleatórios.

Você pode ver que o serviço de tempo aterrissou no nó enquanto o usuário e o serviço de localhost:9701 ping compartilham espaço no segundo trabalhador localhost:9702. Os aplicativos de exemplo são simplistas, e os tamanhos de dados aqui são ignorantes, mas vamos supor que você esteja incomodado com a utilização desigual do espaço de armazenamento entre os nós. Faria mais sentido ter os dois serviços de tempo e ping menores residindo em uma máquina enquanto o serviço de grande usuário reside sozinho.

Você pode facilmente reequilibrar o cluster por tamanho de 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 como fica o nosso 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. Esta operação tem sido transparente para as aplicações. Você nem precisa reiniciá-los, eles continuam atendendo consultas.

Próximos passos

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

• Saiba mais sobre os tipos de nó de cluster