Unterteilen eines Shards in einer DB-Shard-Gruppe - Amazon Aurora
VoraussetzungenUnterteilen eines ShardsNachverfolgen von Shard-SplitsFinalisieren von Shard-SplitsAbbrechen eines Shard-Splits

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Unterteilen eines Shards in einer DB-Shard-Gruppe

Sie können einen Shard in einer DB-Shard-Gruppe manuell in zwei kleinere Shards unterteilen. Dies wird als ein vom Benutzer initiierter Shard-Split bezeichnet.

Aurora PostgreSQL Limitless Database kann Shards auch unterteilen, wenn sie über sehr große Datenmengen verfügen oder sehr stark genutzt werden. Dies wird als ein vom System initiierter Shard-Split bezeichnet.

Voraussetzungen

Für vom Benutzer initiierte Shard-Splits gelten die folgenden Voraussetzungen:

  • Sie müssen über eine DB-Shard-Gruppe verfügen.

  • Die DB-Shard-Gruppe darf nicht leer sein: Sie muss mindestens eine Sharded-Tabelle enthalten.

  • Ein Benutzer muss die Berechtigung rds_aurora_limitless_cluster_admin haben. Der rds_superuser hat dieses Recht; daher hat es auch der Masterbenutzer. Der rds_superuser kann anderen Benutzern das Privileg gewähren:

    /* Logged in as the master user or a user with rds_superuser privileges */
CREATE USER username;
GRANT rds_aurora_limitless_cluster_admin to username;

  • Sie müssen die Subcluster-ID (Knoten-ID) des Shards kennen, den Sie unterteilen möchten. Sie können die ID mithilfe der folgenden Abfrage identifizieren:

    SELECT * FROM rds_aurora.limitless_subclusters;

 subcluster_id | subcluster_type
---------------+-----------------
 1             | router
 2             | router
 3             | shard
 4             | shard
 5             | shard
 6             | shard

Wenn Sie möchten, dass das System Shard-Splits initiiert, legen Sie die folgenden DB-Cluster-Parameter in einer benutzerdefinierten DB-Cluster-Parametergruppe fest, die Ihrem DB-Cluster zugeordnet ist:

Parameter Wert

rds_aurora.limitless_enable_auto_scale

on

rds_aurora.limitless_auto_scale_options

Entweder split_shard oder add_router,split_shard

rds_aurora.limitless_finalize_split_shard_mode

Dieser Parameter bestimmt, wie vom System initiierte Shard-Splits finalisiert werden. Der Wert kann eine der folgenden Formen annehmen:

  • user_initiated: Sie entscheiden, wann der Shard-Split finalisiert werden soll. Dies ist der Standardwert.

  • immediate: Shard-Splits werden sofort finalisiert.

Weitere Informationen finden Sie unter Finalisieren von Shard-Splits.

Anmerkung

Dieser Parameter gilt nur für vom System initiierte Shard-Splits.

Weitere Informationen finden Sie unter DB-Cluster-Parametergruppen für Amazon-Aurora-DB-Cluster.

Unterteilen eines Shards

Verwenden Sie die Funktion rds_aurora.limitless_split_shard, um einen Shard in einer DB-Shard-Gruppe zu unterteilen. Diese Funktion startet einen Auftrag zum Unterteilen des Shards, der asynchron ausgeführt wird.

SELECT rds_aurora.limitless_split_shard('subcluster_id');

Warten Sie nach erfolgreicher Übermittlung des Auftrags auf die Rückgabe einer Auftrags-ID, zum Beispiel:

SELECT rds_aurora.limitless_split_shard('3');

    job_id
---------------
 1691300000000
(1 row)
Anmerkung

Gleichzeitige Shard-Splits werden nicht unterstützt. Führen Sie die Aufträge nacheinander aus und schließen Sie jeden Auftrag ab, bevor Sie einen weiteren Split veranlassen.

Nachverfolgen von Shard-Splits

Sie können die Auftrags-ID verwenden, um einen Shard-Split-Auftrag nachzuverfolgen. Führen Sie die folgende Abfrage aus, um einen bestimmten Auftrag zu beschreiben und weitere Informationen dazu zu erhalten:

SELECT * FROM rds_aurora.limitless_list_shard_scale_jobs(job_id);

Zum Beispiel:

SELECT * FROM rds_aurora.limitless_list_shard_scale_jobs(1691300000000);

    job_id     |    action   |      job_details      | status  |    submission_time     |                  message                  
---------------+-------------+-----------------------+---------+------------------------+-------------------------------------------
 1691300000000 | SPLIT_SHARD | Split Shard 3 by User | SUCCESS | 2023-08-06 05:33:20+00 | Scaling job succeeded.                 +
               |             |                       |         |                        | New shard instance with ID 7 was created.
(1 row)

Die Abfrage gibt einen Fehler zurück, wenn Sie einen nicht vorhandenen Auftrag als Eingabe übermitteln.

SELECT * from rds_aurora.limitless_list_shard_scale_jobs(1691300000001);

ERROR:  no job found with the job ID provided

Sie können den Status aller Shard-Split-Aufträge verfolgen, indem Sie dieselbe Abfrage ohne Auftrags-ID ausführen, zum Beispiel:

SELECT * FROM rds_aurora.limitless_list_shard_scale_jobs();

    job_id     |   action    |  job_details          |   status    |    submission_time     |                  message                 
---------------+-------------+-----------------------+-------------+------------------------+--------------------------------------------------------------
 1691200000000 | SPLIT_SHARD | Split Shard 3 by User | IN_PROGRESS | 2023-08-05 01:46:40+00 | 
 1691300000000 | SPLIT_SHARD | Split Shard 4 by User | SUCCESS     | 2023-08-06 05:33:20+00 | Scaling job succeeded. +
               |             |                       |             |                        | New shard instance with ID 7 was created.
 1691400000000 | SPLIT_SHARD | Split Shard 5 by User | FAILED      | 2023-08-07 09:20:00+00 | Error occurred for the add shard job 1691400000000.
               |             |                       |             |                        | Retry the command. If the issue persists, contact AWS Support.
 1691500000000 | SPLIT_SHARD | Split Shard 5 by User | CANCELED    | 2023-08-07 09:20:00+00 | Scaling job was cancelled.
(4 rows)

Der Auftragsstatus kann einer der folgenden Werte sein:

  • IN_PROGRESS: Der Shard-Split-Auftrag wurde eingereicht und ist in Bearbeitung. Sie können nur einen Auftrag nach dem anderen ausführen.

  • PENDING: Der Shard-Split-Auftrag wartet darauf, dass Sie ihn finalisieren. Weitere Informationen finden Sie unter Finalisieren von Shard-Splits.

  • CANCELLATION_IN_PROGRESS: Der Shard-Split-Auftrag wird vom Benutzer abgebrochen.

  • CANCELED: Der Shard-Split-Auftrag wurde vom Benutzer oder vom System erfolgreich abgebrochen.

  • SUCCESS: Der Shard-Split-Auftrag wurde erfolgreich abgeschlossen. Das Feld message enthält die Instance-ID des neuen Shards.

  • FAILED: Der Shard-Split-Auftrag ist fehlgeschlagen. Das Feld message enthält die Einzelheiten zu dem Fehler und alle Maßnahmen, die zu dem fehlgeschlagenen Auftrag ergriffen werden können.

Finalisieren von Shard-Splits

Das Finalisieren ist der letzte Schritt des Shard-Split-Prozesses. Er verursacht etwas Ausfallzeit. Wenn Sie einen Shard-Split-Auftrag starten, erfolgt die Finalisierung sofort, nachdem der Auftrag erfolgreich abgeschlossen wurde.

Manchmal unterteilt das System Shards auf Grundlage ihrer Workload, wenn Sie vom System initiierte Shard-Splits mithilfe des Parameters rds_aurora.limitless_enable_auto_scale aktiviert haben.

In diesem Fall können Sie wählen, ob die Finalisierung sofort oder zu einem von Ihnen gewünschten Zeitpunkt erfolgt. Sie verwenden den DB-Cluster-Parameter rds_aurora.limitless_finalize_split_shard_mode, um zu bestimmen, wann dies geschieht:

  • Wenn Sie den Wert auf immediate setzen, geschieht dies sofort.

  • Wenn Sie den Wert auf user_initiated setzen, müssen Sie den Shard-Split-Auftrag manuell abschließen.

    Ein RDS-Ereignis wird an Sie gesendet, und der Status des Shard-Split-Auftrags wechselt in PENDING.

Bei der Einstellung user_initiated verwenden Sie die Funktion rds_aurora.limitless_finalize_split_shard, um den Shard-Split-Auftrag zu finalisieren:

SELECT * FROM rds_aurora.limitless_finalize_split_shard(job_id);
Anmerkung

Diese Funktion gilt nur für Shard-Splits, die vom System initiiert werden, nicht von Ihnen.

Abbrechen eines Shard-Splits

Sie können einen vom Benutzer oder vom System initiierten Shard-Split mit dem Status IN_PROGRESS oder PENDING abbrechen. Sie benötigen die Auftrags-ID, um den Auftrag abzubrechen.

SELECT * from rds_aurora.limitless_cancel_shard_scale_jobs(job_id);

Es wird keine Ausgabe zurückgegeben, es sei denn, es liegt ein Fehler vor. Sie können den Abbruch mithilfe einer Abfrage zur Auftragsverfolgung überwachen.