Quickstart: een Hyperscale (Citus)-servergroep maken in Azure Portal

Azure Database for PostgreSQL is een beheerde service waarmee u PostgreSQL-databases met hoge beschikbaarheid in de cloud kunt uitvoeren, beheren en schalen. In deze snelstart ontdekt u hoe u een Azure Database for PostgreSQL - Hyperscale (Citus)-servergroep maakt in Azure Portal. U verkent gedistribueerde gegevens: sharding van tabellen over knooppunten, de opname van voorbeeldgegevens en het uitvoeren van query's die op meerdere knooppunten worden uitgevoerd.

Een Hyperscale (Citus)-servergroep maken

Als u nog geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

Aanmelden bij Azure Portal

Meld u aan bij de Azure-portal.

Volg deze stappen voor het maken van een Azure Database voor PostgreSQL-server:

1. Klik in de linkerbovenhoek van Azure Portal op Een resource maken.

2. Selecteer Databases op de pagina Nieuw en selecteer Azure Database voor PostgreSQL op de pagina Databases.

3. Klik voor de implementatieoptie op de knop Maken onder Servergroep voor Hyperscale (Citus) .

4. Vul het formulier voor de gegevens van de nieuwe server als volgt in:

   • Resourcegroep: klik op de koppeling Nieuwe maken onder het tekstvak voor dit veld. Voer een naam in, bijvoorbeeld mijnresourcegroep.
   • Naam van servergroep: voer een unieke naam in voor de nieuwe servergroep, die ook wordt gebruikt voor een subdomein van de server.
   • Gebruikersnaam van beheerder: momenteel is de waarde citus vereist en kan dit niet worden gewijzigd.
   • Wachtwoord: Uw wachtwoord moet minimaal 8 tekens lang zijn en tekens bevatten uit drie van de volgende categorieën: Nederlandse hoofdletters, Nederlandse kleine letters, cijfers (0-9) en niet-alfanumerieke tekens (!, $, #, %, enzovoort).
   • Locatie: gebruik de locatie die zich het dichtst bij uw gebruikers bevindt, zodat ze de snelst mogelijke toegang tot de gegevens hebben.

   Belangrijk

   Het wachtwoord van de serverbeheerder die u hier opgeeft, is vereist voor aanmelding bij de server en de bijbehorende databases. Onthoud of noteer deze informatie voor later gebruik.

5. Klik op Servergroep configureren. Laat de instellingen in die sectie ongewijzigd en klik op Opslaan.

6. Klik op Volgende: Netwerken > onderaan het scherm.

7. Selecteer op het tabblad Netwerken de optie Openbare toegang toestaan vanuit Azure-services en -resources in Azure voor deze servergroep. Selecteer vervolgens + Huidig IP-adres van client toevoegen.

   Notitie

   De Azure PostgreSQL-server communiceert via poort 5432. Als u verbinding probeert te maken vanuit een bedrijfsnetwerk, wordt uitgaand verkeer via poort 5432 mogelijk niet toegestaan door de firewall van uw netwerk. In dat geval kunt u alleen verbinding maken met uw Hyperscale (Citus)-cluster als uw IT-afdeling poort 5432 openstelt.

8. Klik op Beoordelen en maken en vervolgens op Maken om de server in te richten. De inrichting duurt een paar minuten.

9. De pagina wordt omgeleid om de implementatie te bewaken. Wanneer de Live-status wordt gewijzigd van Uw implementatie wordt uitgevoerd in Uw implementatie is voltooid, klikt u op de menuopdracht Uitvoer aan de linkerkant van de pagina.

10. De pagina Uitvoer bevat een coördinatorhostnaam met een knop ernaast om de waarde naar het klembord te kopiëren. Noteer deze informatie voor later gebruik.

Verbinding maken met de database met behulp van psql

Wanneer u de Azure Database for PostgreSQL-server maakt, wordt een standaarddatabase met de naam citus gemaakt. Als u verbinding wilt maken met uw databaseserver, hebt u een verbindingsreeks en het beheerderswachtwoord nodig.

1. Haal de verbindingsreeks op. Klik op de pagina Servergroep op de menuopdracht Verbindingsreeksen. (Deze bevindt zich onder Instellingen.) Zoek de tekenreeks met de markering psql. Deze heeft de volgende vorm:

   psql "host=hostname.postgres.database.azure.com port=5432 dbname=citus user=citus password={your_password} sslmode=require"
   

   Kopieer de tekenreeks. Vervang "{your_password}" door het beheerderswachtwoord dat u eerder hebt gekozen. Uw leesbare wachtwoord wordt niet opgeslagen in het systeem en kan dus niet worden weergegeven in de verbindingsreeks.

2. Open een terminalvenster op de lokale computer.

3. In de prompt maakt u verbinding met uw Azure Database for PostgreSQL-server via het psql-hulpprogramma. Geef uw verbindingsreeks tussen haakjes door, en zorg ervoor dat het uw wachtwoord bevat:

   psql "host=..."
   

   Met de volgende opdracht maakt u bijvoorbeeld verbinding met het coördinatorknooppunt van de servergroep mydemoserver:

   psql "host=mydemoserver-c.postgres.database.azure.com port=5432 dbname=citus user=citus password={your_password} sslmode=require"
   

Tabellen maken en distribueren

Zodra u met behulp van psql verbinding hebt gemaakt met het hyperscale-coördinatorknooppunt, kunt u een aantal basistaken voltooien.

Op Hyperscale (Citus)-servers zijn drie typen tabellen aanwezig:

• Gedistribueerde tabellen of tabellen waarop sharding is toegepast (uitgespreid voor schaalaanpassing voor prestaties en parallellisering)
• Referentietabellen (meerdere kopieën)
• Lokale tabellen (vaak gebruikt voor interne beheertabellen)

In deze quickstart richten we ons met name op gedistribueerde tabellen en proberen we onze bekendheid hiermee te vergroten.

Het gegevensmodel waarmee we gaan werken is eenvoudig: gebruikers- en gebeurtenisgegevens van GitHub. Gebeurtenissen zijn bijvoorbeeld het maken van een fork, git-opmerkingen met betrekking tot een organisatie, enzovoort.

Zodra u via psql verbinding hebt gemaakt, gaan we onze tabellen maken. Voer in de psql-console het volgende uit:

CREATE TABLE github_events
(
    event_id bigint,
    event_type text,
    event_public boolean,
    repo_id bigint,
    payload jsonb,
    repo jsonb,
    user_id bigint,
    org jsonb,
    created_at timestamp
);

CREATE TABLE github_users
(
    user_id bigint,
    url text,
    login text,
    avatar_url text,
    gravatar_id text,
    display_login text
);

Het veld payload van github_events heeft een JSONB-gegevenstype. JSONB is het JSON-gegevenstype in binaire vorm in Postgres. Door dit gegevenstype is het eenvoudig om een flexibel schema in één kolom op te slaan.

In Postgres kan een GIN-index voor dit type worden gemaakt, waarmee elke sleutel en waarde in dit type worden geïndexeerd. Met een index kunt u snel en gemakkelijk query's uitvoeren op de nettolading met verschillende voorwaarden. Maak nu een aantal indexen voordat we onze gegevens gaan laden. In psql:

CREATE INDEX event_type_index ON github_events (event_type);
CREATE INDEX payload_index ON github_events USING GIN (payload jsonb_path_ops);

Vervolgens maken we die Postgres-tabellen op het coördinatorknooppunt en geven we aan Hyperscale (Citus) door dat ze via sharding naar de werknemers moet worden gestuurd. Hiervoor voeren we een query uit voor elke tabel en geven we de sleutel op waarmee de sharding moet worden uitgevoerd. In het huidige voorbeeld passen we sharding toe op zowel de gebeurtenissen- als de gebruikerstabel op user_id:

SELECT create_distributed_table('github_events', 'user_id');
SELECT create_distributed_table('github_users', 'user_id');

We kunnen nu gegevens laden. Blijf in psql en gebruik een shell (???) om de bestanden te downloaden:

\! curl -O https://examples.citusdata.com/users.csv
\! curl -O https://examples.citusdata.com/events.csv

Hierna laadt u de gegevens uit de bestanden in de gedistribueerde tabellen:

SET CLIENT_ENCODING TO 'utf8';

\copy github_events from 'events.csv' WITH CSV
\copy github_users from 'users.csv' WITH CSV

Query's uitvoeren

Nu gaan we over naar het leuke gedeelte: we gaan een aantal query's uitvoeren. We beginnen met een eenvoudige count (*) om te zien hoeveel gegevens we hebben geladen:

SELECT count(*) from github_events;

Dat ging goed. We komen later terug bij dat soort aggregaties, maar voor nu kijken we eerst naar een aantal andere query's. In de JSONB payload-kolom staan vele gegevens, maar het varieert op basis van het gebeurtenistype. PushEvent-gebeurtenissen bevatten een grootte met daarin het aantal unieke doorvoeringen voor de push. Hiermee kunnen we het totale aantal doorvoeringen per uur vinden:

SELECT date_trunc('hour', created_at) AS hour,
       sum((payload->>'distinct_size')::int) AS num_commits
FROM github_events
WHERE event_type = 'PushEvent'
GROUP BY hour
ORDER BY hour;

Tot dusver gingen de query's alleen over de github_-gebeurtenissen, maar we kunnen deze informatie combineren met github_-gebruikers. Omdat we sharding hebben toegepast op gebruikers en gebeurtenissen met dezelfde id (user_id), bevinden de rijen van beide tabellen met overeenkomende gebruikers-id's zich op dezelfde locatie, namelijk op dezelfde databaseknooppunten, en kunnen ze eenvoudig worden gekoppeld.

Als we naar user_id gaan, kan Hyperscale (Citus) de samenvoegbewerking in shards pushen, zodat ze tegelijkertijd kunnen worden uitgevoerd op werkknooppunten. Laten we bijvoorbeeld de gebruikers zoeken die het grootste aantal opslagplaatsen hebben gemaakt:

SELECT gu.login, count(*)
  FROM github_events ge
  JOIN github_users gu
    ON ge.user_id = gu.user_id
 WHERE ge.event_type = 'CreateEvent'
   AND ge.payload @> '{"ref_type": "repository"}'
 GROUP BY gu.login
 ORDER BY count(*) DESC;

Resources opschonen

In de voorgaande stappen hebt u Azure-resources in een resourcegroep gemaakt. Als u deze resources in de toekomst niet nodig denkt te hebben, kunt u de servergroep verwijderen. Druk op de knop Verwijderen op de pagina Overzicht voor uw servergroep. Wanneer u daarom op een pop-uppagina wordt gevraagd, bevestigt u de naam van de servergroep en klikt u op de laatste knop Verwijderen.

Volgende stappen

In deze quickstart hebt u geleerd hoe u een Hyperscale (Citus)-servergroep inricht. U hebt psql gebruikt om hiermee verbinding te maken, u hebt een schema gemaakt en u hebt gegevens gedistribueerd.

• Volg hierna een zelfstudie voor het bouwen van schaalbare toepassingen met meerdere tenants
• Bepaal de beste begingrootte voor uw servergroep