Dela via

Självstudie: Design för mikrotjänster med elastiska kluster

I den här självstudien använder du Azure Database for PostgreSQL som lagringsserverdel för flera mikrotjänster. Handledningen visar en provuppsättning och grundläggande drift för ett sådant kluster. Lär dig att:

  • Förutsättningar
  • Skapa roller för dina mikrotjänster
  • Använda psql-verktyget för att skapa roller och distribuerade scheman
  • Skapa tabeller för exempeltjänsterna
  • Konfigurera tjänster
  • Starta tjänster
  • Utforska databasen

Förutsättningar

Skapa ett elastiskt kluster på något av följande sätt:

Skapa roller för dina mikrotjänster

Du kan dynamiskt placera distribuerade scheman i ett elastiskt kluster. Systemet kan balansera om dem som en hel enhet mellan de tillgängliga noderna, så att du får bättre effektivitet i dina klusterresurser utan manuell allokering.

När du tillämpar schemasharding på ett designmönster för mikrotjänster skapar du ett databasschema för varje motsvarande mikrotjänst. Använd också en distinkt ROLL för varje mikrotjänst när du ansluter till databasen. När varje användare ansluter går deras rollnamn i början av search_path. Om rollnamnet matchar schemanamnet behöver du inga ytterligare programändringar för att ange rätt search_path.

I det här exemplet använder du tre mikrotjänster:

  • user
  • time
  • ping

Skapa databasrollerna för varje tjänst:

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

Använda psql-verktyget för att skapa distribuerade scheman

När du har anslutit till det elastiska klustret med hjälp av psql kan du utföra några grundläggande uppgifter.

Du kan distribuera ett schema på två sätt:

  • Manuellt genom att anropa citus_schema_distribute(schema_name) funktionen:
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');

Med den här metoden kan du också konvertera befintliga vanliga scheman till distribuerade scheman.

Anmärkning

Du kan bara distribuera scheman som inte innehåller distribuerade tabeller och referenstabeller.

  • Genom att aktivera konfigurationsvariabeln citus.enable_schema_based_sharding . Du kan ändra variabeln för den aktuella sessionen eller göra en permanent ändring via koordinatornodens parametrar. När du anger parametern till PÅ distribueras alla skapade scheman som standard.
SET citus.enable_schema_based_sharding TO ON;

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

Kör följande kommando för att visa en lista över de för närvarande distribuerade schemana:

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)

Skapa tabeller för exempeltjänsterna

Nu kan du ansluta till det elastiska klustret för varje mikrotjänst. I följande exempel heter den elastiska klusterdatabasen Citus. Från psql-sessionen kan du använda kommandot \c för att växla till en annan användare.

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

Konfigurera tjänster

I den här handledningen använder vi en enkel uppsättning tjänster. Du kan hämta dem genom att klona den här offentliga lagringsplatsen:

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

Innan du kör tjänsterna måste du dock redigera user/app.py, ping/app.pyoch filer som time/app.py tillhandahåller anslutningskonfigurationen för ditt elastiska kluster:

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

När du har gjort ändringarna sparar du alla ändrade filer och går vidare till nästa steg för att köra tjänsterna.

Starta tjänster

Ändra till varje appkatalog och kör dem i sin egen python-miljö.

cd user
pipenv install
pipenv shell
python app.py

Upprepa kommandona för tids- och pingtjänsten, varefter du kan använda API:et.

Skapa några användare:

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

Lista de skapade användarna:

curl http://localhost:5000/users

Hämta aktuell tid:

Get current time:

Kör pingen mot example.com:

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

Utforska databasen

Nu när du har anropat vissa API-funktioner lagras data och du kan kontrollera om citus_schemas de återspeglar vad som förväntas:

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)

När du skapade schemana angav du inte på vilka datorer som scheman ska skapas. Det gjordes automatiskt. Du kan se var varje schema finns med följande fråga:

  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

För korthet i exempelutdata på den här sidan, i stället för att använda nodename som en IP-adress ersätter vi den med localhost. Anta att är localhost:7001 nod ett och localhost:7002 är nod två.

Du kan se att tidstjänsten landade på noden localhost:7001 medan användaren och pingtjänsten delar utrymme på den andra noden localhost:7002. Exempelapparna är förenklade och datastorlekarna här är obetydliga, men vi antar att du påverkas av den ojämna lagringsutrymmesanvändningen mellan noderna. Det skulle vara mer meningsfullt att ha de två mindre tids- och pingtjänsterna på en nod medan den stora användartjänsten finns på en egen nod.

Du kan enkelt balansera om klustret efter diskstorlek:

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)

När du är klar kan du kontrollera hur vår nya layout ser ut:

  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)

Enligt förväntningarna flyttas schemana och vi har ett mer balanserat kluster. Den här åtgärden är transparent för programmen. Du behöver inte ens starta om dem, de fortsätter att hantera frågor.

Nästa steg

Läs mer om elastiska kluster

  • Last updated on