Suddivisione di uno shard in un gruppo di shard di database - Amazon Aurora
PrerequisitiSuddivisione di uno shardTracciamento delle suddivisioni di shardFinalizzazione delle suddivisioni in shardAnnullamento di una suddivisione in shard

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Suddivisione di uno shard in un gruppo di shard di database

È possibile suddividere manualmente uno shard di un gruppo di shard di database in due shard più piccoli. Questa operazione è denominata suddivisione dello shard avviata dall’utente.

Aurora PostgreSQL Limitless Database può suddividere gli shard anche quando presentano grandi quantità di dati o un utilizzo molto elevato. Questa operazione è denominata suddivisione dello shard avviata dal sistema.

Prerequisiti

Le suddivisioni di shard avviate dall’utente presentano i seguenti prerequisiti:

  • È necessario disporre di un gruppo di shard di database.

  • Il gruppo di shard di database non può essere vuoto e deve contenere almeno una tabella sottoposta a shard.

  • Un utente deve avere il privilegio rds_aurora_limitless_cluster_admin. Il rds_superuser dispone di questo privilegio, quindi lo possiede anche l’utente master. Il rds_superuser può concedere il privilegio ad altri utenti:

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

  • È necessario conoscere l’ID del cluster secondario (nodo) dello shard che si desidera dividere. Per ottenere l’ID, utilizza la seguente query:

    SELECT * FROM rds_aurora.limitless_subclusters;

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

Per abilitare le suddivisioni di shard avviate dal sistema, imposta i seguenti parametri del cluster di database in un gruppo di parametri personalizzato associato al cluster di database:

Parametro Valore

rds_aurora.limitless_enable_auto_scale

on

rds_aurora.limitless_auto_scale_options

split_shard o add_router,split_shard

rds_aurora.limitless_finalize_split_shard_mode

Questo parametro determina come vengono finalizzate le suddivisioni di shard avviate dal sistema. Il valore può essere uno dei seguenti:

  • user_initiated: sei tu a decidere quando finalizzare la suddivisione dello shard. Si tratta del valore di default.

  • immediate: le suddivisioni degli shard vengono finalizzate immediatamente.

Per ulteriori informazioni, consulta Finalizzazione delle suddivisioni in shard.

Nota

Questo parametro si applica solo alle suddivisioni di shard avviate dal sistema.

Per ulteriori informazioni, consulta Gruppi di parametri del cluster di database per i cluster di database Amazon Aurora.

Suddivisione di uno shard

Per suddividere uno shard in un gruppo di shard di database, utilizza la funzione rds_aurora.limitless_split_shard. Questa funzione avvia un processo di suddivisione in shard che viene eseguito in modo asincrono.

SELECT rds_aurora.limitless_split_shard('subcluster_id');

Attendi la restituzione dell’ID di un processo correttamente inviato, ad esempio:

SELECT rds_aurora.limitless_split_shard('3');

    job_id
---------------
 1691300000000
(1 row)
Nota

Le operazioni di suddivisione degli shard simultanee non sono supportate. Esegui ogni operazione in sequenza e completala prima di avviarne una aggiuntiva.

Tracciamento delle suddivisioni di shard

L’ID del processo consente di tracciare un processo di suddivisione in shard. Per descrivere un determinato processo e ottenere maggiori dettagli su di esso, esegui la query sotto indicata:

SELECT * FROM rds_aurora.limitless_list_shard_scale_jobs(job_id);

Per esempio:

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)

La query restituisce un errore quando si passa un processo inesistente come input.

SELECT * from rds_aurora.limitless_list_shard_scale_jobs(1691300000001);

ERROR:  no job found with the job ID provided

Puoi tenere traccia dello stato di tutti i processi di suddivisione in shard utilizzando la stessa query senza un ID del processo, ad esempio:

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)

Il processo può avere uno dei seguenti stati:

  • IN_PROGRESS: il processo di suddivisione in shard è stato inviato ed è in corso. È possibile avere un solo processo in corso per volta.

  • PENDING: il processo di suddivisione in shard attende di essere finalizzato dall’utente. Per ulteriori informazioni, consulta Finalizzazione delle suddivisioni in shard.

  • CANCELLATION_IN_PROGRESS: il processo di suddivisione in shard viene annullato dall’utente.

  • CANCELED: il processo di suddivisione in shard è stato correttamente annullato dall’utente o dal sistema.

  • SUCCESS: il processo di suddivisione in shard è stato completato correttamente. Il campo message contiene l’ID dell’istanza del nuovo shard.

  • FAILED: il processo di suddivisione in shard non è riuscito. Il campo message contiene i dettagli dell’errore e tutte le azioni che possono essere intraprese in seguito all’esito negativo del processo.

Finalizzazione delle suddivisioni in shard

La finalizzazione è l’ultima fase del processo di suddivisione in shard e causa alcuni tempi di inattività. Se avvii un processo di suddivisione in shard, la finalizzazione avviene subito dopo il corretto completamento del processo.

Se hai abilitato la suddivisione in shard avviata dal sistema utilizzando il parametro rds_aurora.limitless_enable_auto_scale, è possibile che il sistema suddivida gli shard in base al carico di lavoro.

In questo caso, puoi scegliere se finalizzare il processo immediatamente o in un momento a tua scelta. Per stabilirlo, utilizza il parametro del cluster di database rds_aurora.limitless_finalize_split_shard_mode:

  • Se imposti il valore su immediate, avviene immediatamente.

  • Se imposti il valore su user_initiated, il processo di suddivisione in shard deve essere finalizzato manualmente.

    Ti viene inviato un evento RDS e lo stato del processo di suddivisione in shard viene impostato su PENDING.

Quando il parametro è impostato su user_initiated, per finalizzare il processo di suddivisione in shard utilizza la funzione rds_aurora.limitless_finalize_split_shard:

SELECT * FROM rds_aurora.limitless_finalize_split_shard(job_id);
Nota

Questa funzione si applica solo alle suddivisioni in shard avviate dal sistema, non dall’utente.

Annullamento di una suddivisione in shard

È possibile annullare una suddivisione in shard avviata dall’utente o dal sistema con stato IN_PROGRESS o PENDING. Per annullare il processo, è necessario il relativo ID.

SELECT * from rds_aurora.limitless_cancel_shard_scale_jobs(job_id);

Non viene restituito alcun output. a meno che non si verifichi un errore. Puoi tracciare l’annullamento utilizzando una query di tracciamento del lavoro.