Zelfstudie: Ontwerpen voor microservices met elastische clusters

In deze zelfstudie gebruikt u Azure Database for PostgreSQL als de opslagback-end voor meerdere microservices. In de handleiding ziet u een voorbeeldinstallatie en basiswerking van een dergelijk cluster. Leer hoe u het volgende doet:

Vereiste voorwaarden
Rollen maken voor uw microservices
PSQL-hulpprogramma gebruiken om rollen en gedistribueerde schema's te maken
Tabellen maken voor de voorbeeldservices
Services configureren
Services uitvoeren
De database verkennen

Vereiste voorwaarden

Maak een elastisch cluster op een van de volgende manieren:

Rollen maken voor uw microservices

U kunt gedistribueerde schema's dynamisch in een elastisch cluster plaatsen. Het systeem kan ze opnieuw verdelen als een hele eenheid over de beschikbare knooppunten, zodat u de efficiëntie van uw clusterresources kunt verbeteren zonder handmatige toewijzing.

Wanneer u schema-sharding toepast op een microserviceontwerppatroon, maakt u een databaseschema voor elke bijbehorende microservice. Gebruik ook een afzonderlijke ROL voor elke microservice wanneer u verbinding maakt met de database. Wanneer elke gebruiker verbinding maakt, wordt de rolnaam aan het begin van de search_path weergegeven. Als de rolnaam overeenkomt met de schemanaam, hoeft u geen aanvullende toepassingswijzigingen in te stellen om de juiste search_path in te stellen.

In dit voorbeeld gebruikt u drie microservices:

user
time
ping

Maak de databaserollen voor elke service:

CREATE USER user_service;
CREATE USER time_service;
CREATE USER ping_service;

PSQL-hulpprogramma gebruiken om gedistribueerde schema's te maken

Nadat u verbinding hebt gemaakt met het elastische cluster met behulp van psql, kunt u enkele basistaken uitvoeren.

U kunt een schema op twee manieren distribueren:

Handmatig door de functie citus_schema_distribute(schema_name) aan te roepen:

CREATE SCHEMA AUTHORIZATION user_service;
CREATE SCHEMA AUTHORIZATION time_service;
CREATE SCHEMA AUTHORIZATION ping_service;

SELECT citus_schema_distribute('user_service');
SELECT citus_schema_distribute('time_service');
SELECT citus_schema_distribute('ping_service');

Met deze methode kunt u ook bestaande reguliere schema's converteren naar gedistribueerde schema's.

Opmerking

U kunt alleen schema's distribueren die geen gedistribueerde en referentietabellen bevatten.

Door de citus.enable_schema_based_sharding configuratievariabele in te schakelen. U kunt de variabele voor de huidige sessie of permanent wijzigen vanuit de parameters van het coördinatorknooppunt. Wanneer u de parameter instelt op AAN, worden alle gemaakte schema's standaard gedistribueerd.

SET citus.enable_schema_based_sharding TO ON;

CREATE SCHEMA AUTHORIZATION user_service;
CREATE SCHEMA AUTHORIZATION time_service;
CREATE SCHEMA AUTHORIZATION ping_service;

Voer de volgende opdracht uit om de momenteel gedistribueerde schema's weer te geven:

SELECT * FROM citus_schemas;

 schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
 user_service |             5 | 0 bytes     | user_service
 time_service |             6 | 0 bytes     | time_service
 ping_service |             7 | 0 bytes     | ping_service
(3 rows)

Tabellen maken voor de voorbeeldservices

U kunt nu voor elke microservice verbinding maken met het elastische cluster. In het volgende voorbeeld heeft de elastische clusterdatabase de naam Citus. Vanuit de psql-sessie kunt u de opdracht \c gebruiken om naar een andere gebruiker te wisselen.

\c citus user_service

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

\c citus time_service

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

\c citus ping_service

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

Services configureren

In deze tutorial gebruiken we een eenvoudige set diensten. U kunt ze verkrijgen door deze openbare opslagplaats te klonen:

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

Voordat u de services echter uitvoert, bewerkt user/app.py, ping/app.pyen time/app.py bestanden die de verbindingsconfiguratie bieden voor uw elastische cluster:

# Database configuration
db_config = {
    'host': 'EXAMPLE.postgres.database.azure.com',
    'database': 'postgres',
    'password': 'SECRET',
    'user': 'ping_service',
    'port': 5432
}

Nadat u de wijzigingen hebt aangebracht, slaat u alle gewijzigde bestanden op en gaat u verder met de volgende stap van het uitvoeren van de services.

Services uitvoeren

Ga naar iedere app-map en voer ze uit in hun eigen Python-omgeving.

cd user
pipenv install
pipenv shell
python app.py

Herhaal de opdrachten voor tijd en ping-service, waarna u de API kunt gebruiken.

Maak enkele gebruikers:

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

Geef de gemaakte gebruikers weer:

curl http://localhost:5000/users

Huidige tijd ophalen:

Get current time:

Voer de ping uit op example.com:

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

De database verkennen

Nu u een aantal API-functies hebt aangeroepen, worden gegevens opgeslagen en kunt u controleren of citus_schemas dit overeenkomt met wat er wordt verwacht:

SELECT * FROM citus_schemas;

 schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
 user_service |             1 | 112 kB      | user_service
 time_service |             2 | 32 kB       | time_service
 ping_service |             3 | 32 kB       | ping_service
(3 rows)

Toen u de schema's maakte, hebt u niet aangegeven op welke computers de schema's moeten worden gemaakt. Het is automatisch gedaan. U kunt zien waar elk schema zich bevindt met de volgende query:

  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 |     7001 | time_service.query_details | 32 kB
 localhost |     7002 | user_service.users         | 112 kB
 localhost |     7002 | ping_service.ping_results  | 32 kB

Omwille van de beknoptheid van de voorbeelduitvoer op deze pagina vervangen we nodename als IP-adres door localhost. Stel dat het localhost:7001 knooppunt één is en localhost:7002 knooppunt twee is.

U kunt zien dat de tijdservice op het knooppunt localhost:7001 terechtkomt terwijl de gebruiker en ping-serviceruimte delen op het tweede knooppunt localhost:7002. De voorbeeld-apps zijn simplistisch en de gegevensgrootten hier zijn onbelangrijk, maar we gaan ervan uit dat u last hebt van het ongelijke gebruik van opslagruimte tussen de knooppunten. Het zou logischer zijn om de twee kleinere tijd- en pingservices op één knooppunt te hebben terwijl de grote gebruikersservice zich op een eigen knooppunt bevindt.

U kunt het cluster eenvoudig opnieuw verdelen op schijfgrootte:

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)

Wanneer u klaar bent, kunt u controleren hoe onze nieuwe indeling eruitziet:

  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 |     7001 | time_service.query_details | 32 kB
 localhost |     7001 | ping_service.ping_results  | 32 kB
 localhost |     7002 | user_service.users         | 112 kB
(3 rows)

Volgens de verwachtingen worden de schema's verplaatst en hebben we een evenwichtiger cluster. Deze bewerking is transparant voor de toepassingen. U hoeft ze niet eens opnieuw op te starten. Ze blijven query's leveren.

Volgende stap

Meer informatie over elastische clusters

Feedback

Is deze pagina nuttig?

Laatst bijgewerkt om 2026-07-08