Snabbstart: skapa Hyperskala (Citus) en servergrupp i Azure Portal

  • Artikel
  • 6 minuter för att läsa

Azure Database för PostgreSQL är en hanterad tjänst som du använder för att köra, hantera och skala högtillgängliga PostgreSQL-databaser i molnet. Den här snabbstarten visar hur du skapar en Azure Database for PostgreSQL – Hyperskala (Citus) servergrupp med hjälp av Azure Portal. Du kommer att utforska distribuerade data: horisontell partitionering av tabeller mellan noder, inmatning av exempeldata och körning av frågor som körs på flera noder.

Skapa en Hyperscale-servergrupp (Citus)

Om du inte har en Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Logga in på Azure Portal

Logga in på Azure-portalen.

Följ de här stegen för att skapa en Azure Database för PostgreSQL-server:

  1. Klicka på Skapa en resurs i det övre vänstra hörnet av Azure Portal.

  2. Välj databaser från sidan Nytt och välj Azure Database för PostgreSQL från sidan databaser.

  3. För distributionsalternativet klickar du på knappen Skapa under Hyperskala (Citus) servergrupp.

  4. Fyll i formuläret om den nya servern och uppge följande information:

    • Resursgrupp: Klicka på länken Skapa ny under textrutan för det här fältet. Ange ett namn, till exempel myresourcegroup.
    • Namn på servergrupp: Ange ett unikt namn för den nya servergruppen, som även ska användas för en serverunderdomän.
    • Administratörsanvändarnamn: måste för närvarande vara värdet citus och kan inte ändras.
    • Lösenord: måste vara minst åtta tecken långt och innehålla tecken från tre av följande kategorier – engelska versala bokstäver, engelska gemener, siffror (0–9) och icke-alfanumeriska tecken (!, $, #, %, osv.)
    • Plats: Använd den plats som är närmast dina användare för att ge dem den snabbaste åtkomsten till data.

    Viktigt

    Det serveradministratörslösenord som du anger här krävs för att logga in på servern och dess databaser. Kom ihåg eller skriv ned den här informationen så att du kan använda den senare.

  5. Klicka på Konfigurera servergruppen. Lämna inställningarna i det avsnittet oförändrade och klicka på Spara.

  6. Klicka på Nästa: > nätverk längst ned på skärmen.

  7. På fliken Nätverk väljer du Tillåt offentlig åtkomst från Azure-tjänster och -resurser i Azure till den här servergruppen. Välj sedan + Lägg till aktuell klient-IP-adress. Offentlig slutpunkt har valts

    Anteckning

    Azure PostgreSQL-servern kommunicerar via port 5432. Om du försöker ansluta inifrån ett företagsnätverk, kan utgående trafik via port 5432 bli nekad av nätverkets brandvägg. I så fall kan du inte ansluta till Hyperskala (Citus) kluster om inte IT-avdelningen öppnar port 5432.

  8. Klicka på Granska + skapa och sedan på Skapa för att etablera servern. Etableringen tar några minuter.

  9. Sidan omdirigeras för att övervaka distributionen. När livestatusen ändras från Distributionen är på gång till Distributionen är klar klickar du på menyalternativet Utdata till vänster på sidan.

  10. Utdatasidan innehåller ett värdnamn för koordinatorn med en knapp bredvid sig för att kopiera värdet till Urklipp. Registrera den här informationen för senare användning.

Anslut till databasen med psql

När du skapar Azure Database for PostgreSQL server skapas en standarddatabas med namnet citus. Om du vill ansluta till databasservern behöver du en anslutningssträng och administratörslösenordet.

  1. Hämta anslutningssträngen. På servergruppsidan klickar du på menyalternativet Anslutningssträngar. (Den är under Inställningar.) Hitta strängen som är markerad som psql. Den kommer att ha följande format:

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

    Kopiera strängen. Du måste ersätta "{ditt _ lösenord}" med det administrativa lösenord som du valde tidigare. Systemet lagrar inte lösenordet i klartext och kan därför inte visa det åt dig i anslutningssträngen.

  2. Öppna ett terminalfönster på den lokala datorn.

  3. I kommandotolken ansluter du till Azure Database for PostgreSQL-servern med psql-verktyget. Skicka anslutningssträngen inom citattecken och kontrollera att den innehåller ditt lösenord:

    psql "host=..."

    Följande kommando ansluter till exempel till koordinatornoden för servergruppen mydemoserver:

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

Skapa och distribuera tabeller

När du har anslutit till koordinatornoden för hyperskala med psql kan du utföra några grundläggande uppgifter.

På Hyperskala (Citus) servrar finns det tre typer av tabeller:

  • Distribuerade eller shardade tabeller (utspridda för att hjälpa till med skalning för prestanda och parallellisering)
  • Referenstabeller (flera kopior underhålls)
  • Lokala tabeller (används ofta för interna administratörstabeller)

I den här snabbstarten fokuserar vi främst på distribuerade tabeller och bekanta oss med dem.

Den datamodell som vi ska arbeta med är enkel: användar- och händelsedata från GitHub. Händelser omfattar förkgenerering, git-genomföranden relaterade till en organisation med mera.

När du har anslutit via psql ska vi skapa våra tabeller. I psql-konsolen kör du:

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

Fältet payload i har en github_events JSONB-datatyp. JSONB är JSON-datatypen i binärform i Postgres. Datatypen gör det enkelt att lagra ett flexibelt schema i en enda kolumn.

Postgres kan skapa ett GIN index för den här typen, som indexerar varje nyckel och värde i den. Med ett index blir det snabbt och enkelt att köra frågor mot nyttolasten med olika villkor. Nu ska vi skapa några index innan vi läser in våra data. I psql:

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

Härnäst tar vi de Postgres-tabellerna på koordinatornoden och Hyperskala (Citus) att fragmentera dem bland arbetarna. För att göra det kör vi en fråga för varje tabell som anger nyckeln för horisontell partitionering. I det aktuella exemplet kommer vi att sharda både händelserna och användartabellen på user_id :

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

Viktigt

Du måste distribuera tabeller för att kunna dra nytta av funktioner för storskalig prestanda. Om du inte distribuerar tabeller kan arbetsnoder inte hjälpa att köra frågor som involverar dessa tabeller.

Vi är redo att läsa in data. I psql ska du fortfarande skala ut för att ladda ned filerna:

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

Läs sedan in data från filerna till de distribuerade tabellerna:

SET CLIENT_ENCODING TO 'utf8';

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

Köra frågor

Nu är det dags för den roliga delen, att faktiskt köra några frågor. Vi börjar med ett enkelt sätt att count (*) se hur mycket data vi har läst in:

SELECT count(*) from github_events;

Det fungerade bra. Vi kommer tillbaka till den typen av aggregering om en stund, men nu ska vi titta på några andra frågor. Det finns bra data payload i JSONB-kolumnen, men det varierar beroende på händelsetyp. PushEvent händelser innehåller en storlek som innehåller antalet distinkta genomföranden för push-pushen. Vi kan använda den för att hitta det totala antalet genomföranden per timme:

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;

Hittills har frågorna endast involverat _ github-händelser, men vi kan kombinera den här informationen med _ github-användare. Eftersom vi fragmenterade både användare och händelser på samma identifierare ( ), kommer raderna i båda tabellerna med matchande användar-ID:n att finnas på samma databasnoder och user_id kan enkelt sammanfogas.

Om vi ansluter på user_id kan Hyperskala (Citus) push-koppla-körningen ned till shards för körning parallellt på arbetsnoder. Vi kan till exempel hitta de användare som har skapat det största antalet lagringsplatsen:

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;

Rensa resurser

I föregående steg skapade du Azure-resurser i en servergrupp. Om du inte förväntar dig att behöva dessa resurser i framtiden tar du bort servergruppen. Tryck på knappen Ta bort på sidan Översikt för servergruppen. När du uppmanas till det på en popup-sida bekräftar du namnet på servergruppen och klickar på den sista knappen Ta bort.

Nästa steg

I den här snabbstarten har du lärt dig hur du etablerar Hyperskala (Citus) en servergrupp. Du anslöt till den med psql, skapade ett schema och distribuerade data.