Mikrotjänster

I den här självstudien använder du Azure Cosmos DB for PostgreSQL som lagringsserverdel för flera mikrotjänster, vilket visar en exempelkonfiguration och grundläggande drift av ett sådant kluster. Lär dig att:

Förutsättningar

Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

Skapa ett kluster

Logga in på Azure Portal och följ dessa steg för att skapa ett Azure Cosmos DB for PostgreSQL-kluster:

På formuläret Skapa ett Azure Cosmos DB för PostgreSQL-kluster:

1. Fyll i informationen på fliken Basics (Grunder).

   

   De flesta alternativ är självförklarande, men tänk på följande:

   • Klusternamnet bestämmer det DNS-namn som dina program använder för att ansluta, i formuläret <node-qualifier>-<clustername>.<uniqueID>.postgres.cosmos.azure.com.
   • Du kan välja en större PostgreSQL-version, till exempel 15. Azure Cosmos DB for PostgreSQL stöder alltid den senaste Citus-versionen för den valda större Postgres-versionen.
   • Administratörsanvändarnamnet måste ha värdet citus.
   • Du kan lämna databasnamnet som standardvärde "citus" eller definiera ditt enda databasnamn. Du kan inte byta namn på databasen efter klusteretablering.

2. Välj Nästa: Nätverk längst ned på skärmen.

3. På skärmen Nätverk väljer du Tillåt offentlig åtkomst från Azure-tjänster och resurser i Azure till det här klustret.

   

4. Välj Granska + skapa, och när valideringen är godkänd väljer du Skapa för att skapa klustret.

5. Provisioneringen tar några minuter. Sidan omdirigeras till övervakning av distribution. När statusen ändras från Distribution pågår till Distributionen är klar väljer du Gå till resurs.

Skapa roller för dina mikrotjänster

Distribuerade scheman kan flyttas i ett Azure Cosmos DB för PostgreSQL-kluster. Systemet kan balansera om dem som en hel enhet mellan tillgängliga noder, vilket gör det möjligt att effektivt dela resurser utan manuell allokering.

Mikrotjänster äger genom design sitt eget lagringslager; vi gör inga antaganden om vilken typ av tabeller och data de skapar och lagrar. Vi tillhandahåller ett schema för varje tjänst och förutsätter att de använder en distinkt ROLL för att ansluta till databasen. När en användare ansluter placeras deras rollnamn i början av search_path, så om rollen matchar schemanamnet behöver du inga programändringar för att ange rätt search_path.

Vi använder tre tjänster i vårt exempel:

• användare
• tid
• Ping

Följ stegen som beskriver hur du skapar användarroller och skapar följande roller för varje tjänst:

• userservice
• timeservice
• pingservice

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

När du har anslutit till Azure Cosmos DB for PostgreSQL med psql kan du utföra några grundläggande uppgifter.

Det finns två sätt på vilka ett schema kan distribueras i Azure Cosmos DB för PostgreSQL:

Manuellt genom att anropa citus_schema_distribute(schema_name) funktionen:

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

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

En annan metod är att aktivera citus.enable_schema_based_sharding konfigurationsvariabel:

SET citus.enable_schema_based_sharding TO ON;

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

Variabeln kan ändras för den aktuella sessionen eller permanent i koordinatornodparametrar. Med parametern inställd på PÅ distribueras alla skapade scheman som standard.

Du kan visa en lista över de för närvarande distribuerade schemana genom att köra:

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)

Skapa tabeller för exempeltjänsterna

Nu måste du ansluta till Azure Cosmos DB for PostgreSQL för varje mikrotjänst. Du kan använda kommandot \c för att växla användaren i en befintlig psql-instans.

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

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 ska du dock redigera user/app.pyoch ping/app.pytime/app.py filer som tillhandahåller anslutningskonfigurationenför ditt Azure Cosmos DB for PostgreSQL-kluster:

# Database configuration
db_config = {
    'host': 'c-EXAMPLE.EXAMPLE.postgres.cosmos.azure.com',
    'database': 'citus',
    'password': 'SECRET',
    'user': 'pingservice',
    '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 har data lagrats och du kan kontrollera om citus_schemas återspeglar vad som förväntas:

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)

När du skapade schemana berättade du inte för Azure Cosmos DB för PostgreSQL på vilka datorer som scheman ska skapas på. 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 |     9701 | timeservice.query_details | 32 kB
 localhost |     9702 | userservice.users         | 112 kB
 localhost |     9702 | pingservice.ping_results  | 32 kB

För korthet i exempelutdata på den här sidan ersätter vi det med localhost i stället för att använda nodename som visas i Azure Cosmos DB for PostgreSQL. Anta att localhost:9701 är arbetare ett och localhost:9702 är arbetare två. Nodnamn på den hanterade tjänsten är längre och innehåller slumpmässiga element.

Du kan se att tidstjänsten landade på noden localhost:9701 medan användaren och pingtjänsten delar utrymme på den andra arbetaren localhost:9702. Exempelapparna är förenklade och datastorlekarna här är försumliga, men vi antar att du är irriterad över den ojämna användningen av lagringsutrymme mellan noderna. Det skulle vara mer meningsfullt att ha de två mindre tids- och pingtjänsterna på en dator medan den stora användartjänsten finns ensam.

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 |     9701 | timeservice.query_details | 32 kB
 localhost |     9701 | pingservice.ping_results  | 32 kB
 localhost |     9702 | userservice.users         | 112 kB
(3 rows)

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

Nästa steg

I den här självstudien lärde du dig att skapa distribuerade scheman, körde mikrotjänster med dem som lagring. Du har också lärt dig hur du utforskar och hanterar schemabaserade fragmenterade Azure Cosmos DB for PostgreSQL.

• Läs mer om klusternodtyper