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à.
# Amministrazione dell’istanza database Amazon RDS per Db2
Di seguito sono riportate le attività di gestione comuni che si eseguono con un’istanza database Amazon RDS per Db2. Alcune attività sono uguali per tutte le istanze database Amazon RDS. Altre invece sono specifiche di RDS per Db2.
Le attività riportate di seguito sono comuni a tutti i database RDS. Esistono anche attività specifiche di RDS per Db2, come la connessione a un database RDS per Db2 con un client SQL standard.
| Area attività | Documentazione di riferimento |
| --- | --- |
| **Classi delle istanze, storage e PIOPS** Se si sta creando un'istanza di produzione, occorre conoscere il funzionamento di classi di istanza, tipi di storage e IOPS con provisioning in Amazon RDS. | [Classi di istanze DB ](Concepts.DBInstanceClass.md) [Tipi di storage Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Implementazioni Multi-AZ** Un'istanza database in produzione deve utilizzare implementazioni Multi-AZ. Le implementazioni Multi-AZ forniscono alle istanze database maggior disponibilità, longevità dei dati e tolleranza ai guasti. | [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Se Account AWS disponi di un cloud privato virtuale (VPC) predefinito, l'istanza DB viene creata automaticamente all'interno del VPC predefinito. Se l'account non dispone di un VPC predefinito e desideri che l'istanza database sia in un VPC, è necessario creare il VPC e i gruppi di sottoreti prima di creare l'istanza database. | [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Gruppi di sicurezza** Per impostazione predefinita, le istanze database utilizzano un firewall che impedisce l'accesso. Per accedere all'istanza database, assicurati di aver creato un gruppo di sicurezza con gli indirizzi IP e la configurazione di rete corretti. | [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md) |
| **Gruppi di parametri** Poiché l’istanza database RDS per Db2 richiede l’aggiunta dei parametri `rds.ibm_site_id` e `rds.ibm_customer_id`, crea un gruppo di parametri prima di creare l’istanza database. Se la tua istanza database richiede altri parametri di database specifici, aggiungili a questo gruppo di parametri prima di creare l’istanza database. | [Aggiunta IBM IDs a un gruppo di parametri per RDS per istanze DB Db2](db2-licensing.md#db2-licensing-options-byol-adding-ids) [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Gruppi di opzioni** Se l'istanza database richiede opzioni database specifiche, crea un gruppo di opzioni prima di creare l'istanza database. | [Opzioni per le istanze database Amazon RDS per Db2](Db2.Options.md) |
| **Connessione all'istanza database** Dopo aver creato un gruppo di sicurezza e averlo associato a un’istanza database, puoi connetterti all’istanza database mediante un’applicazione client SQL standard, come IBM Db2 CLP. | [Connessione all’istanza database Db2](USER_ConnectToDb2DBInstance.md) |
| **Backup e ripristino** Puoi configurare l’istanza database affinché effettui backup automatici dell’archiviazione oppure acquisire snapshot manuali dell’archiviazione ed eseguire il ripristino di istanze dai backup o dagli snapshot. | [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md) |
| **Monitoraggio** È possibile monitorare un’istanza database RDS per Db2 con IBM Db2 Data Management Console. Puoi anche monitorare un'istanza DB RDS for Db2 utilizzando i parametri, gli eventi e il monitoraggio avanzato di CloudWatch Amazon RDS. | [Connessione a un’istanza database Amazon RDS per Db2 con IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md) [Visualizzazione dei parametri nella console Amazon RDS](USER_Monitoring.md) [Visualizzazione di eventi Amazon RDS](USER_ListEvents.md) [Monitoraggio dei parametri del sistema operativo con il monitoraggio avanzato](USER_Monitoring.OS.md) |
| **File di log** È possibile accedere ai file di log per le istanze database RDS per Db2. | [Monitoraggio dei file di log di Amazon RDS](USER_LogAccess.md) |
**Topics**
+ [Esecuzione di attività di sistema comuni per le istanze database Amazon RDS per Db2](db2-performing-common-system-tasks-db-instances.md)
+ [Esecuzione di attività di database comuni per le istanze database Amazon RDS per Db2](db2-performing-common-database-tasks-db-instances.md)
# Esecuzione di attività di sistema comuni per le istanze database Amazon RDS per Db2
Nelle istanze database Amazon RDS che eseguono Db2 è possibile eseguire determinate attività di Database Administrator comuni relative al sistema. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
Per informazioni sulla concessione e la revoca dei privilegi e sul collegamento al database remoto per RDS per Db2, consulta i seguenti argomenti.
**Argomenti**
+ [Concessione e revoca dei privilegi per RDS per Db2](db2-granting-revoking-privileges.md)
+ [Collegamento all’istanza database RDS per Db2 remota](db2-attaching-to-remote.md)
## Creazione di un endpoint personalizzato per il database
Quando esegui la migrazione ad Amazon RDS for Db2, puoi utilizzare un endpoint di database personalizzato per ridurre al minimo URLs le modifiche all'applicazione. Ad esempio, se utilizzi `db2.example.com` come record DNS corrente, puoi aggiungerlo ad Amazon Route 53. In Route 53, puoi utilizzare zone ospitate private per mappare l’endpoint del database DNS corrente a un endpoint del database RDS per Db2. Per aggiungere un record `A` o `CNAME` personalizzato per un endpoint del database Amazon RDS, consulta [Come registrare e gestire domini tramite Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar.html) nella *Guida per sviluppatori di Amazon Route 53*.
**Nota**
Se non riesci a trasferire il dominio in Route 53, puoi utilizzare il tuo provider DNS per creare un record `CNAME` per l’URL dell’endpoint del database RDS per Db2. Consulta la documentazione del tuo provider DNS.
# Concessione e revoca dei privilegi per RDS per Db2
Gli utenti ottengono l’accesso ai database tramite l’appartenenza a gruppi collegati ai database.
Utilizza le seguenti procedure per concedere e revocare i privilegi per controllare l’accesso al database.
Queste procedure utilizzano IBM Db2 CLP in esecuzione su un computer locale per connettersi a un’istanza database RDS per Db2. Assicurati di catalogare il nodo TCPIP e il database per connetterti all’istanza database RDS per Db2 in esecuzione sul tuo computer locale. Per ulteriori informazioni, consulta [Connessione a un’istanza database Amazon RDS per Db2 con IBM Db2 CLP](db2-connecting-with-clp-client.md).
**Topics**
+ [Concessione dell’accesso al database a un utente](#db2-granting-user-access)
+ [Modifica della password di un utente](#db2-changing-user-password)
+ [Aggiunta di gruppi a un utente](#db2-adding-group-to-user)
+ [Rimozione di gruppi da un utente](#db2-removing-groups-from-user)
+ [Rimozione di un utente](#db2-removing-user)
+ [Elencare gli utenti](#db2-listing-users-database)
+ [Creazione di un ruolo](#db2-creating-role)
+ [Concessione di un ruolo](#db2-granting-role)
+ [Revoca di un ruolo](#db2-revoking-role)
+ [Eliminazione di un ruolo](#db2-dropping-role)
+ [Concessione dell’autorizzazione per il database](#db2-granting-dbadmin-auth)
+ [Revoca dell’autorizzazione per il database](#db2-revoking-dbadmin-auth)
## Concessione dell’accesso al database a un utente
**Per concedere a un utente l’accesso al tuo database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
Questo comando genera un output simile all’esempio seguente:
```
Database Connection Information
Database server = DB2/LINUXX8664 11.5.8.0
SQL authorization ID = ADMIN
Local database alias = RDSADMIN
```
1. Aggiungi un utente all’elenco di autorizzazioni chiamando `rdsadmin.add_user`. Per ulteriori informazioni, consulta [rdsadmin.add\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-add-user).
```
db2 "call rdsadmin.add_user(
'username',
'password',
'group_name,group_name')"
```
1. (Facoltativo) Aggiungi altri gruppi all’utente chiamando `rdsadmin.add_groups`. Per ulteriori informazioni, consulta [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
1. Conferma le autorità disponibili per l’utente. Nell'esempio seguente *rds\$1database\$1alias**master\$1user*, sostituisci e *master\$1password* con le tue informazioni. Inoltre, *username* sostituiscilo con il nome utente dell'utente.
```
db2 terminate
db2 connect to rds_database_alias user master_user using master_password
db2 "SELECT SUBSTR(AUTHORITY,1,20) AUTHORITY, D_USER, D_GROUP, D_PUBLIC
FROM TABLE (SYSPROC.AUTH_LIST_AUTHORITIES_FOR_AUTHID ('username', 'U') ) AS T
ORDER BY AUTHORITY"
```
Questo comando genera un output simile all’esempio seguente:
```
AUTHORITY D_USER D_GROUP D_PUBLIC
-------------------- ------ ------- --------
ACCESSCTRL N N N
BINDADD N N N
CONNECT N N N
CREATETAB N N N
CREATE_EXTERNAL_ROUT N N N
CREATE_NOT_FENCED_RO N N N
CREATE_SECURE_OBJECT N N N
DATAACCESS N N N
DBADM N N N
EXPLAIN N N N
IMPLICIT_SCHEMA N N N
LOAD N N N
QUIESCE_CONNECT N N N
SECADM N N N
SQLADM N N N
SYSADM * N *
SYSCTRL * N *
SYSMAINT * N *
SYSMON * N *
WLMADM N N N
```
1. Concedi i ruoli `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` e `ROLE_PROCEDURES` di RDS per Db2 al gruppo a cui hai aggiunto l’utente. Per ulteriori informazioni, consulta [Ruoli predefiniti di Amazon RDS per Db2](db2-default-roles.md).
**Nota**
Le istanze database RDS per Db2 vengono create in modalità `RESTRICTIVE`. Pertanto, i ruoli `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` e `ROLE_PROCEDURES` di RDS per Db2 concedono privilegi di esecuzione sui pacchetti `NULLID` per IBM Db2 CLP e Dynamic SQL. Questi ruoli concedono anche privilegi utente sui tablespace.
1. Connettiti al tuo database Db2. Nell'esempio seguente *database\$1name**master\$1user*, sostituisci e *master\$1password* con le tue informazioni.
```
db2 connect to database_name user master_user using master_password
```
1. Assegna il ruolo `ROLE_NULLED_PACKAGES` a un gruppo. Nell'esempio seguente, sostituiscilo *group\$1name* con il nome del gruppo a cui desideri aggiungere il ruolo.
```
db2 "grant role ROLE_NULLID_PACKAGES to group group_name"
```
1. Assegna il ruolo `ROLE_TABLESPACES` allo stesso gruppo. Nell'esempio seguente, sostituiscilo *group\$1name* con il nome del gruppo a cui desideri aggiungere il ruolo.
```
db2 "grant role ROLE_TABLESPACES to group group_name"
```
1. Assegna il ruolo `ROLE_PROCEDURES` allo stesso gruppo. Nell'esempio seguente, sostituiscilo *group\$1name* con il nome del gruppo a cui desideri aggiungere il ruolo.
```
db2 "grant role ROLE_PROCEDURES to group group_name"
```
1. Concedi le autorità `connect`, `bindadd`, `createtab` e `IMPLICIT_SCHEMA` al gruppo a cui hai aggiunto l’utente. Nell'esempio seguente, *group\$1name* sostituiscilo con il nome del secondo gruppo a cui hai aggiunto l'utente.
```
db2 "grant usage on workload SYSDEFAULTUSERWORKLOAD to public"
db2 "grant connect, bindadd, createtab, implicit_schema on database to group group_name"
```
1. Ripeti i passaggi da 4 a 6 per ogni gruppo aggiuntivo a cui hai aggiunto l’utente.
1. Testa l’accesso dell’utente connettendoti come tale utente, creando una tabella, inserendo valori nella tabella e restituendo dati dalla tabella. Nell'esempio seguente, sostituisci *rds\$1database\$1alias**username*, e *password* con il nome del database e il nome utente e la password dell'utente.
```
db2 connect to rds_database_alias user username using password
db2 "create table t1(c1 int not null)"
db2 "insert into t1 values (1),(2),(3),(4)"
db2 "select * from t1"
```
## Modifica della password di un utente
**Per cambiare la password di un utente**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Cambia la password chiamando `rdsadmin.change_password`. Per ulteriori informazioni, consulta [rdsadmin.change\$1password](db2-sp-granting-revoking-privileges.md#db2-sp-change-password).
```
db2 "call rdsadmin.change_password(
'username',
'new_password')"
```
## Aggiunta di gruppi a un utente
**Per aggiungere gruppi a un utente**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Aggiungi gruppi a un utente chiamando `rdsadmin.add_groups`. Per ulteriori informazioni, consulta [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
## Rimozione di gruppi da un utente
**Per rimuovere gruppi da un utente**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Rimuovi i gruppi chiamando `rdsadmin.remove_groups`. Per ulteriori informazioni, consulta [rdsadmin.remove\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-remove-groups).
```
db2 "call rdsadmin.remove_groups(
'username',
'group_name,group_name')"
```
## Rimozione di un utente
**Per rimuovere un utente dall’elenco di autorizzazioni**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Rimuovi un utente dall’elenco di autorizzazioni chiamando `rdsadmin.remove_user`. Per ulteriori informazioni, consulta [rdsadmin.remove\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-remove-user).
```
db2 "call rdsadmin.remove_user('username')"
```
## Elencare gli utenti
Per elencare gli utenti in un elenco di autorizzazioni, chiama la stored procedure `rdsadmin.list_users`. Per ulteriori informazioni, consulta [rdsadmin.list\$1users](db2-sp-granting-revoking-privileges.md#db2-sp-list-users).
```
db2 "call rdsadmin.list_users()"
```
## Creazione di un ruolo
È possibile utilizzare la stored procedure [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role) per creare un ruolo.
**Per creare un ruolo**
1. Connettiti al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Imposta Db2 in modo che restituisca il contenuto come output.
```
db2 set serveroutput on
```
1. Creare un ruolo. Per ulteriori informazioni, consulta [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'database_name',
'role_name')"
```
1. Imposta Db2 in modo che non restituisca il contenuto come output.
```
db2 set serveroutput off
```
## Concessione di un ruolo
È possibile utilizzare la stored procedure [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role) per assegnare un ruolo a un ruolo, utente o gruppo.
**Per assegnare un ruolo**
1. Connettiti al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Imposta Db2 in modo che restituisca il contenuto come output.
```
db2 set serveroutput on
```
1. Assegna un ruolo. Per ulteriori informazioni, consulta [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role).
```
db2 "call rdsadmin.grant_role(
'database_name',
'role_name',
'grantee',
'admin_option')"
```
1. Imposta Db2 in modo che non restituisca il contenuto come output.
```
db2 set serveroutput off
```
## Revoca di un ruolo
È possibile utilizzare la stored procedure [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role) per revocare un ruolo da un ruolo, utente o gruppo.
**Per revocare un ruolo**
1. Connettiti al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Revoca un ruolo. Per ulteriori informazioni, consulta [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role).
```
db2 "call rdsadmin.revoke_role(
?,
'database_name',
'role_name',
'grantee')"
```
## Eliminazione di un ruolo
È possibile utilizzare la stored procedure [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role) per eliminare un ruolo.
**Per eliminare un ruolo**
1. Connettiti al database `rdsadmin`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Elimina un ruolo. Per ulteriori informazioni, consulta [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role).
```
db2 "call rdsadmin.drop_role(
?,
'database_name',
'role_name')"
```
## Concessione dell’autorizzazione per il database
L’utente principale, che dispone dell’autorizzazione `DBADM`, può concedere l’autorizzazione `DBADM`, `ACCESSCTRL` o `DATAACCESS` a un ruolo, utente o gruppo.
**Per concedere l’autorizzazione per il database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Concedi l’accesso a un utente chiamando `rdsadmin.dbadm_grant`. Per ulteriori informazioni, consulta [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'database_name,
'authorization',
'grantee')"
```
**Esempio di caso d’uso**
La procedura seguente illustra come creare un ruolo, concedere l’autorizzazione `DBADM` al ruolo, assegnare il ruolo a un utente e concedere il ruolo a un gruppo.
****
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Crea un ruolo denominato `PROD_ROLE` per un database denominato `TESTDB`. Per ulteriori informazioni, consulta [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'TESTDB',
'PROD_ROLE')"
```
1. Assegna il ruolo a un utente denominato `PROD_USER`. All’utente `PROD_USER` viene concessa l’autorizzazione di amministrazione per assegnare ruoli. Per ulteriori informazioni, consulta [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role).
```
db2 "call rdsadmin.grant_role(
?,
'TESTDB',
'PROD_ROLE',
'USER PROD_USER',
'Y')"
```
1. (Facoltativo) Fornisci ulteriori autorizzazioni o privilegi. Nell’esempio seguente viene concessa l’autorizzazione `DBADM` a un ruolo denominato `PROD_ROLE` per un database denominato `FUNDPROD`. Per ulteriori informazioni, consulta [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'FUNDPROD',
'DBADM',
'ROLE PROD_ROLE')"
```
1. Termina la sessione.
```
db2 terminate
```
1. Connettiti al database `TESTDB` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to TESTDB user master_username using master_password
```
1. Aggiungi altre autorizzazioni al ruolo.
```
db2 "grant connect, implicit_schema on database to role PROD_ROLE"
```
1. Assegna il ruolo `PROD_ROLE` a un gruppo.
```
db2 "grant role PROD_ROLE to group PRODGRP"
```
Gli utenti che appartengono al gruppo `PRODGRP` possono ora eseguire azioni come la connessione al database `TESTDB`, la creazione di tabelle o la creazione di schemi.
## Revoca dell’autorizzazione per il database
L’utente principale, che dispone dell’autorizzazione `DBADM`, può revocare l’autorizzazione `DBADM`, `ACCESSCTRL` o `DATAACCESS` a un ruolo, utente o gruppo.
**Per revocare l’autorizzazione per il database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Revoca l’accesso utente chiamando `rdsadmin.dbadm_revoke`. Per ulteriori informazioni, consulta [rdsadmin.dbadm\$1revoke](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-revoke).
```
db2 "call rdsadmin.dbadm_revoke(
?,
'database_name,
'authorization',
'grantee')"
```
# Collegamento all’istanza database RDS per Db2 remota
Per collegarti all’istanza database RDS per Db2 remota ed eseguire le operazioni `get snapshot`, utilizza i passaggi descritti di seguito.
**Per collegarti all’istanza database RDS per Db2 remota**
1. Esegui una sessione IBM Db2 CLP lato client. Per informazioni su come catalogare l’istanza database RDS per Db2 e il database, consulta [Connessione a un’istanza database Amazon RDS per Db2 con IBM Db2 CLP](db2-connecting-with-clp-client.md). Prendi nota del nome utente e della password principale per l’istanza database RDS per Db2.
1. Effettua il collegamento all’istanza database RDS per Db2. Nell'esempio seguente *node\$1name**master\$1username*, sostituisci e *master\$1password* con il nome del nodo TCPIP che hai catalogato e il nome utente e la password principale per l'istanza DB RDS for Db2.
```
db2 attach to node_name user master_username using master_password
```
Dopo il collegamento all’istanza database RDS per Db2 remota, puoi eseguire i seguenti comandi e altri comandi `get snapshot`. Per ulteriori informazioni, consulta [GET SNAPSHOT command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-get-snapshot) nella documentazione di IBM Db2.
```
db2 list applications
db2 get snapshot for all databases
db2 get snapshot for database manager
db2 get snapshot for all applications
```
# Esecuzione di attività di database comuni per le istanze database Amazon RDS per Db2
Nelle istanze database Amazon RDS per Db2 è possibile eseguire determinate attività DBA comuni relative ai database. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Inoltre, l’utente master non può eseguire comandi o utilità che richiedono autorità `SYSADM`, `SYSMAINT` o `SYSCTRL`.
Per informazioni sulle attività comuni relative a pool di buffer, database e tablespace, fai riferimento agli argomenti elencati di seguito.
**Argomenti**
+ [Attività comuni per i pool di buffer](db2-managing-buffer-pools.md)
+ [Attività comuni per i database](db2-managing-databases.md)
+ [Attività comuni per i tablespace](db2-managing-tablespaces.md)
# Attività comuni per i pool di buffer
Puoi creare, modificare o eliminare i pool di buffer per un database RDS per Db2. La creazione, la modifica o l’eliminazione di pool di buffer richiede un’autorità `SYSADM` o `SYSCTRL` di livello superiore, di cui l’utente principale non dispone. Puoi invece utilizzare le stored procedure di Amazon RDS.
Puoi anche svuotare i pool di buffer.
**Topics**
+ [Creazione di un pool di buffer](#db2-creating-buffer-pool)
+ [Modifica di un pool di buffer](#db2-altering-buffer-pool)
+ [Eliminazione di un pool di buffer](#db2-dropping-buffer-pool)
+ [Svuotamento dei pool di buffer](#db2-flushing-buffer-pools)
## Creazione di un pool di buffer
Per creare un pool di buffer per il database RDS per Db2, chiama la stored procedure `rdsadmin.create_bufferpool`. Per ulteriori informazioni, consulta [CREATE BUFFERPOOL statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-bufferpool) nella documentazione di IBM Db2.
**Per creare un pool di buffer**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell’esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crea un pool di buffer chiamando `rdsadmin.create_bufferpool`. Per ulteriori informazioni, consulta [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool).
```
db2 "call rdsadmin.create_bufferpool(
'database_name',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
page_size,
number_block_pages,
block_size)"
```
## Modifica di un pool di buffer
Per modificare un pool di buffer per il database RDS per Db2, chiama la stored procedure `rdsadmin.alter_bufferpool`. Per ulteriori informazioni, consulta [ALTER BUFFERPOOL statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-bufferpool) nella documentazione di IBM Db2.
**Per modificare un pool di buffer**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell’esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Modifica un pool di buffer chiamando `rdsadmin.alter_bufferpool`. Per ulteriori informazioni, consulta [rdsadmin.alter\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-alter-buffer-pool).
```
db2 "call rdsadmin.alter_bufferpool(
'database_name',
'buffer_pool_name',
buffer_pool_size,
'immediate',
'automatic',
change_number_blocks,
number_block_pages,
block_size)"
```
## Eliminazione di un pool di buffer
Per eliminare un pool di buffer per il database RDS per Db2, chiama la stored procedure `rdsadmin.drop_bufferpool`. Per ulteriori informazioni, consulta [Dropping buffer pools](https://www.ibm.com/docs/en/db2/11.5?topic=pools-dropping-buffer) nella documentazione di IBM Db2.
**Importante**
Assicurati che al pool di buffer da eliminare non sia assegnato alcun tablespace.
**Per eliminare un pool di buffer**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell’esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Elimina un pool di buffer chiamando `rdsadmin.drop_bufferpool`. Per ulteriori informazioni, consulta [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 "call rdsadmin.drop_bufferpool(
'database_name',
'buffer_pool_name')"
```
## Svuotamento dei pool di buffer
È possibile svuotare i pool di buffer per forzare un checkpoint in modo che RDS per Db2 scriva pagine dalla memoria all’archiviazione.
**Nota**
Non è necessario svuotare i pool di buffer. Db2 scrive i log in modo sincrono prima di eseguire il commit delle transazioni. È possibile che le pagine sporche si trovino ancora in un pool di buffer, ma Db2 le scrive nell’archiviazione in modo asincrono. Anche in caso di spegnimento imprevisto del sistema, al riavvio del database, Db2 esegue automaticamente il ripristino da arresto anomalo. Durante il ripristino da arresto anomalo, Db2 scrive nel database le modifiche di cui è stato eseguito il commit oppure esegue il rollback delle modifiche per le transazioni di cui non è stato eseguito il commit.
**Per svuotare i pool di buffer**
1. Connettiti al database Db2 utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell’esempio seguente, sostituisci *rds\$1database\$1alias*, *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Svuota i pool di buffer.
```
db2 flush bufferpools all
```
# Attività comuni per i database
Puoi creare, eliminare o ripristinare i database sulla tua istanza database RDS per Db2. La creazione, l’eliminazione o il ripristino di database richiede un’autorità `SYSADM` di livello superiore, di cui l’utente principale non dispone. Puoi invece utilizzare le stored procedure di Amazon RDS.
Puoi anche eseguire attività di gestione comuni come il monitoraggio, la manutenzione e la raccolta di informazioni sui tuoi database.
**Topics**
+ [Creazione di un database](#db2-creating-database)
+ [Configurazione delle impostazioni per un database](#db2-configuring-database)
+ [Modifica dei parametri del database](#db2-modifying-db-parameters)
+ [Configurazione della conservazione dei log](#db2-configuring-log-retention)
+ [Elencare le informazioni relative ai log](#db2-listing-log-information)
+ [Utilizzo del controllo degli accessi a grana fine (FGAC)](#db2-using-fine-grained-access-control)
+ [Disattivazione di un database](#db2-deactivating-database)
+ [Attivazione di un database](#db2-activating-database)
+ [Riattivazione di un database](#db2-reactivating-database)
+ [Eliminazione di un database.](#db2-dropping-database)
+ [Backup di un database](#db2-backing-up-database)
+ [Copiare i log di archivio su Amazon S3](#db2-copying-archive-logs-to-s3)
+ [Ripristino di un database](#db2-restoring-database)
+ [Elencare i database](#db2-listing-databases)
+ [Raccolta di informazioni sui database](#db2-collecting-info-db)
+ [Forzare la disconnessione di applicazioni dai database](#db2-forcing-application-off-db)
+ [Generazione di report sulle prestazioni](#db2-generating-performance-reports)
## Creazione di un database
Per creare un database sulla tua istanza database RDS per Db2, chiama la stored procedure `rdsadmin.create_database`. Per ulteriori informazioni, consulta [CREATE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-create-database) nella documentazione di IBM Db2.
**Nota**
Se intendi modificare il parametro `db2_compatibility_vector`, modificalo prima di creare un database. Per ulteriori informazioni, consulta [Impostazione del parametro db2\$1compatibility\$1vector](db2-known-issues-limitations.md#db2-known-issues-limitations-db2-compatibility-vector).
**Come creare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crea un database chiamando `rdsadmin.create_database`. Per ulteriori informazioni, consulta [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database(
'database_name',
'database_page_size',
'database_code_set',
'database_territory',
'database_collation',
'database_autoconfigure_str',
'database_non-restrictive')"
```
1. (Facoltativo) Crea database aggiuntivi chiamando `rdsadmin.create_database` per ogni database che desideri creare. Ogni istanza database Db2 può contenere fino a 50 database. Per ulteriori informazioni, consulta [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database('database_name')"
```
1. (Facoltativo) Assicurati che il database sia stato creato utilizzando uno dei metodi seguenti:
+ Chiama `rdsadmin.list_databases`. Per ulteriori informazioni, consulta [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
+ Esegui il seguente comando SQL:
```
db2 "select varchar(r.task_type,25) as task_type, r.database_name,
varchar(r.lifecycle,15) as lifecycle, r.created_at, r.database_name,
varchar(bson_to_json(task_input_params),256) as input_params,
varchar(r.task_output,1024) as task_output
from table(rdsadmin.get_task_status(null,null,'create_database'))
as r order by created_at desc"
```
## Configurazione delle impostazioni per un database
Per configurare le impostazioni per un database sulla tua istanza database RDS per Db2, chiama la stored procedure `rdsadmin.set_configuration`. Ad esempio, puoi configurare il numero di buffer o manipolatori di buffer da creare durante un’operazione di ripristino.
**Per configurare le impostazioni per un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facoltativo) Controlla le impostazioni di configurazione correnti chiamando `rdsadmin.show_configuration`. Per ulteriori informazioni, consulta [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Configura le impostazioni per il database chiamando `rdsadmin.set_configuration`. Per ulteriori informazioni, consulta [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
## Modifica dei parametri del database
Amazon RDS per Db2 utilizza tre tipi di parametri: parametri di configurazione del gestore di database, variabili di registro e parametri di configurazione del database. È possibile aggiornare i primi due tipi tramite gruppi di parametri e l’ultimo tipo tramite la stored procedure [rdsadmin.update\$1db\$1param](db2-sp-managing-databases.md#db2-sp-update-db-param).
**Nota**
È possibile modificare solo i valori di parametri esistenti. Non è possibile aggiungere nuovi parametri non supportati da RDS per Db2.
Per ulteriori informazioni su questi parametri e su come modificarne i valori, consulta [Parametri di Amazon RDS per Db2](db2-supported-parameters.md).
## Configurazione della conservazione dei log
Per configurare il tempo per cui Amazon RDS mantiene i file di log per il tuo database RDS per Db2, chiama la stored procedure `rdsadmin.set_archive_log_retention`.
**Per configurare la conservazione dei log per un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facoltativo) Controlla la configurazione corrente per la conservazione dei log chiamando `rdsadmin.show_archive_log_retention`. Per ulteriori informazioni, consulta [rdsadmin.show\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-show-archive-log-retention).
```
db2 "call rdsadmin.show_archive_log_retention(
?,
'database_name')"
```
1. Configura la conservazione dei log per il database chiamando `rdsadmin.set_archive_log_retention`. Per ulteriori informazioni, consulta [rdsadmin.set\$1archive\$1log\$1retention](db2-sp-managing-databases.md#db2-sp-set-archive-log-retention).
```
db2 "call rdsadmin.set_archive_log_retention(
?,
'database_name',
'archive_log_retention_hours')"
```
## Elencare le informazioni relative ai log
Per elencare i dettagli sui file di log di archivio, ad esempio la dimensione totale di archiviazione utilizzata, chiama la stored procedure `rdsadmin.list_archive_log_information`.
**Per elencare le informazioni relative ai log per un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Chiama `rdsadmin.list_archive_log_information` per ottenere un elenco di informazioni sui file di log. Per ulteriori informazioni, consulta [rdsadmin.list\$1archive\$1log\$1information](db2-sp-managing-databases.md#db2-sp-list-archive-log-information).
```
db2 "call rdsadmin.list_archive_log_information(
?,
'database_name')"
```
## Utilizzo del controllo degli accessi a grana fine (FGAC)
Per utilizzare comandi di controllo di accesso granulari per controllare l'accesso ai dati delle tabelle in un database su un'istanza DB RDS for Db2, chiamate la stored procedure. `rdsadmin.fgac_command` Potresti voler utilizzare FGAC per limitare l'accesso ai dati in base ai ruoli utente o agli attributi dei dati. Ad esempio, è possibile limitare l'accesso ai dati sanitari dei pazienti in base al tipo di dati o a determinati fornitori di assistenza medica.
**Utilizzare un controllo di accesso granulare per controllare l'accesso ai dati delle tabelle in un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Esegui vari comandi di controllo degli accessi dettagliati chiamando. `rdsadmin.fgac_command` Per ulteriori informazioni, consulta [rdsadmin.fgac\$1commandParameters](db2-sp-managing-databases.md#db2-sp-fgac-command).
```
db2 "call rdsadmin.fgac_command(
?,
'database_name',
'fgac_command')"
```
## Disattivazione di un database
Per disattivare un database sulla tua istanza database RDS per Db2, chiama la stored procedure `rdsadmin.deactivate_database`.
Per impostazione predefinita, Amazon RDS attiva un database quando si crea un database su un’istanza database RDS per Db2. È possibile disattivare i database di uso meno frequente per risparmiare risorse di memoria.
**Per disattivare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Disattiva un database chiamando `rdsadmin.deactivate_database`. Per ulteriori informazioni, consulta [rdsadmin.deactivate\$1database](db2-sp-managing-databases.md#db2-sp-deactivate-database).
```
db2 "call rdsadmin.deactivate_database(
?,
'database_name')"
```
## Attivazione di un database
Per attivare un database su un’istanza database RDS per Db2 autonoma, chiama la stored procedure `rdsadmin.activate_database`.
Per impostazione predefinita, Amazon RDS attiva un database quando si crea un database su un’istanza database RDS per Db2. È possibile disattivare i database di uso meno frequente per risparmiare risorse di memoria, quindi attivare in seguito un database disattivato.
**Per attivare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Attiva un database chiamando `rdsadmin.activate_database`. Per ulteriori informazioni, consulta [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database).
```
db2 "call rdsadmin.activate_database(
?,
'database_name')"
```
## Riattivazione di un database
Per riattivare un database su un’istanza database RDS per Db2 di origine replica, chiama la stored procedure `rdsadmin.reactivate_database`. Dopo aver apportato modifiche alle configurazioni del database, potrebbe essere necessario riattivare un database su un’istanza database RDS per Db2. Per stabilire se è necessario riattivare un database, connettiti al database ed esegui `db2 get db cfg show detail`.
Puoi anche chiamare questa stored procedure per riattivare un database su un’istanza database RDS per Db2 autonoma dopo aver apportato modifiche alla configurazione del database. In alternativa, è possibile riattivare un database su un’istanza database RDS per Db2 autonoma chiamando prima la stored procedure `rdsadmin.deactivate_database` e poi la stored procedure `rdsadmin.activate_database`. Per ulteriori informazioni, consultare [Disattivazione di un database](#db2-deactivating-database) e [Attivazione di un database](#db2-activating-database).
**Per riattivare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Riattiva un database chiamando `rdsadmin.reactivate_database`. Per ulteriori informazioni, consulta [rdsadmin.reactivate\$1database](db2-sp-managing-databases.md#db2-sp-reactivate-database).
```
db2 "call rdsadmin.reactivate_database(
?,
'database_name')"
```
## Eliminazione di un database.
Per eliminare un database dalla tua istanza database RDS per Db2, chiama la stored procedure `rdsadmin.drop_database`. Per ulteriori informazioni, consulta [Dropping databases](https://www.ibm.com/docs/en/db2/11.5?topic=databases-dropping) nella documentazione di IBM Db2.
**Nota**
È possibile eliminare un database chiamando la stored procedure solo se sono soddisfatte determinate condizioni. Per ulteriori informazioni, consulta [Note per l’utilizzo](db2-sp-managing-databases.md#db2-sp-drop-database-usage-notes) per `rdsadmin.drop_database`.
**Per eliminare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Elimina un database chiamando `rdsadmin.drop_database`. Per ulteriori informazioni, consulta [rdsadmin.drop\$1database](db2-sp-managing-databases.md#db2-sp-drop-database).
```
db2 "call rdsadmin.drop_database('database_name')"
```
## Backup di un database
Per eseguire il backup di un database nella tua istanza DB RDS for Db2 su Amazon S3, richiama `rdsadmin.backup_database` la stored procedure. Per ulteriori informazioni, consulta il [comando BACKUP DATABASE nella documentazione](https://www.ibm.com/docs/en/db2/11.5.x?topic=commands-backup-database). IBM Db2
**Nota**
Questa procedura memorizzata utilizza l'integrazione con Amazon S3. Assicurati di aver configurato l'integrazione prima di procedere. Per ulteriori informazioni, consulta [Integrazione di un’istanza database Amazon RDS per Db2 con Amazon S3](db2-s3-integration.md).
**Per eseguire il backup di un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crea un endpoint gateway VPC per S3. Se disponi già di un endpoint gateway VPC per S3, vai al passaggio 4.
Affinché un'istanza DB RDS for Db2 sia in grado di interagire con Amazon S3, è necessario disporre di un VPC e di un endpoint gateway Amazon S3 per l'utilizzo di sottoreti private. Per ulteriori informazioni, consulta [Fase 1: creare un endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-creating-endpoint).
1. Conferma l'endpoint del gateway VPC per S3. Per ulteriori informazioni, consulta [Fase 2: verificare l’esistenza dell’endpoint gateway VPC per Amazon S3](db2-troubleshooting.md#db2-confirming-endpoint).
1. Esegui il backup di un database chiamando. `rdsadmin.backup_database` Per ulteriori informazioni, consulta [rdsadmin.backup\$1database](db2-sp-managing-databases.md#db2-sp-backup-database).
```
db2 "call rdsadmin.backup_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
'backup_type',
'compression_option',
'util_impact_priority',
'num_files',
'parallelism',
'num_buffers')"
```
1. Termina la connessione.
```
terminate
```
1. (Facoltativo) Verifica che i file di backup siano stati caricati nel tuo bucket Amazon S3 sotto. *s3\$1prefix/dbi\$1resource\$1id/db\$1name* Se i file non vengono visualizzati in*s3\$1prefix/dbi\$1resource\$1id/db\$1name*, controlla lo stato del backup del database per identificare eventuali problemi. Per ulteriori informazioni, consulta [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status). Se non riesci a risolvere i problemi identificati, contatta l'[AWS assistenza](https://aws.amazon.com/premiumsupport/).
1. (Facoltativo) Una volta completato il backup su Amazon S3, puoi ripristinare il backup su un'istanza DB RDS for Db2 o in un'altra posizione, ad esempio un server locale. Per informazioni sul ripristino su un'istanza DB RDS for Db2, consulta. [Ripristino di un database](#db2-restoring-database)
## Copiare i log di archivio su Amazon S3
I log di archivio Db2 possono ora essere copiati dall'istanza DB RDS per Db2 su Amazon S3. I log di archivio combinati con il backup nativo creato utilizzando `rdsadmin.backup_database` possono essere utilizzati per ripristinare e riportare il database in modo che sia point-in-time su un'altra istanza RDS for Db2 o su un database EC2.
Prima di configurare questa funzionalità, utilizza la stored procedure per configurare il database RDS for `rdsadmin.backup_database` Db2.
Questa funzionalità funziona a livello di istanza DB RDS for Db2, sebbene la copia dei log di archivio possa essere abilitata o disabilitata per database.
**Per configurare la copia dei log di archivio su Amazon S3**
1. Connect al `rdsadmin` database utilizzando il nome utente principale e la password principale per l'istanza database RDS for Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Imposta il backup del registro degli archivi su S3 [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration) chiamando.
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
**Esempio**:
```
db2 "call rdsadmin.set_configuration('ARCHIVE_LOG_COPY_TARGET_S3_ARN', 'arn:aws:s3:::my_rds_db2_backups/archive-log-copy/')"
```
1. Abilita la copia del registro di archivio per un database chiamando. `rdsadmin.enable_archive_log_copy` *database\$1name*Sostituiscilo con il nome del tuo database.
```
db2 "call rdsadmin.enable_archive_log_copy(?, 'database_name')"
```
1. Allo stesso modo, per disabilitare la copia dei registri di archivio per un database, chiama`rdsadmin.disable_archive_log_copy`.
```
db2 "call rdsadmin.disable_archive_log_copy(?, 'database_name')"
```
1. Conferma lo stato della copia del registro di archivio `rdsadmin.list_databases` chiamando.
```
db2 "select * from table(rdsadmin.list_databases())"
```
**Output di esempio**:
```
DATABASE_NAME CREATE_TIME DATABASE_UNIQUE_ID ARCHIVE_LOG_RETENTION_HOURS ARCHIVE_LOG_COPY ARCHIVE_LOG_LAST_UPLOAD_FILE ARCHIVE_LOG_LAST_UPLOAD_FILE_TIME ARCHIVE_LOG_COPY_STATUS
--------------- -------------------------- -------------------------------------------------- --------------------------- ---------------- ---------------------------- --------------------------------- ------------------------------
RDSADMIN 2026-01-06-02.03.42.569069 RDSADMIN 0 DISABLED - - -
FOO 2026-01-06-02.13.42.885650 F0D81C7E-7213-4565-B376-4F33FCF420E3 7 ENABLED S0006536.LOG 2026-01-28-19.15.10.000000 UPLOADING
CODEP 2026-01-14-19.42.42.508476 106EEF95-6E30-4FFF-85AE-B044352DF095 0 DISABLED - - -
...
```
## Ripristino di un database
Per spostare un database da un bucket Amazon S3 alla tua istanza database RDS per Db2, chiama la stored procedure `rdsadmin.restore_database`. Per ulteriori informazioni, consulta [RESTORE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database) nella documentazione di IBM Db2.
**Per ripristinare un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facoltativo) Controlla le impostazioni di configurazione correnti per ottimizzare l’operazione di ripristino chiamando `rdsadmin.show_configuration`. Per ulteriori informazioni, consulta [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Configura le impostazioni per ottimizzare l’operazione di ripristino chiamando `rdsadmin.set_configuration`. L’impostazione esplicita di questi valori può migliorare le prestazioni durante il ripristino di database con grandi volumi di dati. Per ulteriori informazioni, consulta [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
1. Ripristina il database chiamando `rdsadmin.restore_database`. Per ulteriori informazioni, consulta [rdsadmin.restore\$1database](db2-sp-managing-databases.md#db2-sp-restore-database).
```
db2 "call rdsadmin.restore_database(
?,
'database_name',
's3_bucket_name',
's3_prefix',
restore_timestamp,
'backup_type')"
```
1. (Facoltativo) Assicurati che il database sia stato ripristinato chiamando `rdsadmin.list_databases` e controllando che il database ripristinato sia elencato. Per ulteriori informazioni, consulta [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
1. Riporta online il database e applica ulteriori log delle transazioni chiamando `rdsadmin.rollforward_database`. Per ulteriori informazioni, consulta [rdsadmin.rollforward\$1database](db2-sp-managing-databases.md#db2-sp-rollforward-database).
```
db2 "call rdsadmin.rollforward_database(
?,
'database_name',
's3_bucket_name',
s3_prefix,
'rollforward_to_option',
'complete_rollforward')"
```
1. (Facoltativo) Controlla lo stato della stored procedure `rdsadmin.rollforward_database` chiamando la stored procedure [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
1. Se hai impostato `complete_rollforward` su `FALSE` nel passaggio precedente, devi terminare di riportare online il database chiamando `rdsadmin.complete_rollforward`. Per ulteriori informazioni, consulta [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward).
```
db2 "call rdsadmin.complete_rollforward(
?,
'database_name')"
```
1. (Facoltativo) Controlla lo stato della stored procedure `rdsadmin.complete_rollforward` chiamando la stored procedure [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
## Elencare i database
Puoi elencare tutti i database in esecuzione su Amazon RDS per Db2 chiamando la funzione definita dall’utente `rdsadmin.list_databases`.
**Per elencare i tuoi database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Elenca i tuoi database chiamando `rdsadmin.list_databases`. Per ulteriori informazioni, consulta [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
```
db2 "select * from table(rdsadmin.list_databases())"
```
## Raccolta di informazioni sui database
Per raccogliere informazioni su un database su un’istanza database RDS per Db2, chiama la stored procedure `rdsadmin.db2pd_command`. Queste informazioni possono essere utili per il monitoraggio dei database o per la risoluzione dei problemi.
**Per raccogliere informazioni su un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Raccogli informazioni sul database chiamando `rdsadmin.db2pd_command`. Per ulteriori informazioni, consulta [rdsadmin.db2pd\$1command](db2-sp-managing-databases.md#db2-sp-db2pd-command).
```
db2 "call rdsadmin.db2pd_command('db2pd_cmd')"
```
## Forzare la disconnessione di applicazioni dai database
Per forzare la disconnessione di applicazioni da un database su un’istanza database RDS per Db2, chiama la stored procedure `rdsadmin.force_application`. Prima di eseguire la manutenzione dei database, forza la disconnessione delle applicazioni dai database.
**Per forzare la disconnessione delle applicazioni da un database**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Forza la disconnessione delle applicazioni da un database chiamando `rdsadmin.force_application`. Per ulteriori informazioni, consulta [rdsadmin.force\$1application](db2-sp-managing-databases.md#db2-sp-force-application).
```
db2 "call rdsadmin.force_application(
?,
'applications')"
```
## Generazione di report sulle prestazioni
È possibile generare report sulle prestazioni con una procedura o uno script. Per informazioni sull’utilizzo di una procedura, consulta [DBSUMMARY procedure ‐ Generate a summary report of system and application performance metrics](https://www.ibm.com/docs/en/db2/11.5?topic=mm-dbsummary-procedure-generate-summary-report-system-application-performance-metrics) nella documentazione di IBM Db2.
Db2 include un file `db2mon.sh` nella sua directory `~sqllib/sample/perf`. L’esecuzione dello script produce un report completo e a basso costo sulle metriche SQL. Per scaricare il file `db2mon.sh` e i file di script correlati, consulta la directory [https://github.com/IBM/db2-samples/tree/master/perf](https://github.com/IBM/db2-samples/tree/master/perf) nel repository GitHub IBM db2-samples.
**Per generare report sulle prestazioni con lo script**
1. Connettiti al database Db2 utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Crea un pool di buffer denominato `db2monbp` con una dimensione di pagina 4096 chiamando `rdsadmin.create_bufferpool`. Per ulteriori informazioni, consulta [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool).
```
db2 "call rdsadmin.create_bufferpool('database_name','db2monbp',4096)"
```
1. Crea un tablespace temporaneo denominato `db2montmptbsp` che utilizza il pool di buffer `db2monbp` chiamando `rdsadmin.create_tablespace`. Per ulteriori informazioni, consulta [rdsadmin.create\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-create-tablespace).
```
db2 "call rdsadmin.create_tablespace('database_name',\
'db2montmptbsp','db2monbp',4096,1000,100,'T')"
```
1. Apri lo script `db2mon.sh` e modifica la riga relativa alla connessione a un database.
1. Rimuovi la seguente riga.
```
db2 -v connect to $dbName
```
1. Sostituisci la riga del passaggio precedente con la riga seguente. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con il nome utente principale e la password principale per l'istanza DB RDS for Db2.
```
db2 -v connect to $dbName user master_username using master_password
```
1. Rimuovi le seguenti righe.
```
db2 -v create bufferpool db2monbp
db2 -v create user temporary tablespace db2montmptbsp bufferpool db2monbp
db2 -v drop tablespace db2montmptbsp
db2 -v drop bufferpool db2monbp
```
1. Esegui lo script `db2mon.sh` per generare un report a determinati intervalli. Nell'esempio seguente, sostituitelo *absolute\$1path* con il percorso completo del file di script, *rds\$1database\$1alias* con il nome del database e *seconds* con il numero di secondi (da 0 a 3600) tra la generazione del report.
```
absolute_path/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
**Esempi**
L’esempio seguente mostra che il file di script si trova nella directory `perf` sotto la directory `home`.
```
/home/db2inst1/sqllib/samples/perf/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
1. Elimina il pool di buffer e il tablespace creati per il file `db2mon.sh`. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con il nome utente principale e la password principale per l'istanza DB RDS for Db2. *database\$1name*Sostituiscilo con il nome del tuo database. Per ulteriori informazioni, consultare [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace) e [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 connect to rdsadmin user master_username using master_password
db2 "call rdsadmin.drop_tablespace('database_name','db2montmptbsp')"
db2 "call rdsadmin.drop_bufferpool('database_name','db2monbp')"
```
## Gestione dello storage
Db2 utilizza l’archiviazione automatica per gestire l’archiviazione fisica degli oggetti del database quali tabelle, indici e file temporanei. Anziché allocare manualmente lo spazio di archiviazione e tenere traccia dei percorsi di archiviazione utilizzati, è possibile utilizzare l’archiviazione automatica che consente al sistema Db2 di creare e gestire i percorsi di archiviazione in base alle necessità. Ciò può semplificare l’amministrazione dei database Db2 e ridurre la probabilità di errori dovuti a errori umani. Per ulteriori informazioni, consulta [Automatic storage](https://www.ibm.com/docs/en/db2/11.5?topic=overview-automatic-storage) nella documentazione di IBM Db2.
Con RDS per Db2, è possibile aumentare dinamicamente le dimensioni di archiviazione con l’espansione automatica dei volumi logici e del file system. Per ulteriori informazioni, consulta [Uso dello storage per istanze database di Amazon RDS](USER_PIOPS.StorageTypes.md).
# Attività comuni per i tablespace
È possibile creare, modificare, rinominare o eliminare tablespace per un database RDS per Db2. La creazione, la modifica, la ridenominazione o l’eliminazione di tablespace richiede un’autorità `SYSADM` di livello superiore, di cui l’utente principale non dispone. Puoi invece utilizzare le stored procedure di Amazon RDS.
**Topics**
+ [Creazione di un tablespace](#db2-creating-tablespace)
+ [Modifica di un tablespace](#db2-altering-tablespace)
+ [Ridenominazione di un tablespace](#db2-renaming-tablespace)
+ [Eliminazione di un tablespace](#db2-dropping-tablespace)
+ [Controllo dello stato di un tablespace](#db2-checking-tablespaces-procedure)
+ [Restituzione di informazioni dettagliate sui tablespace](#db2-tablespaces-info-db2pd)
+ [Elencare lo stato e il gruppo di archiviazione per un tablespace](#db2-state-storage-group-tablespace-sql)
+ [Elencare i tablespace di una tabella](#db2-return-tablespaces-sql)
+ [Elencare i container di tablespace](#db2-listing-tablespace-containers)
## Creazione di un tablespace
Per creare un tablespace per il database RDS per Db2, chiama la stored procedure `rdsadmin.create_tablespace`. Per ulteriori informazioni, consulta [CREATE TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-tablespace) nella documentazione di IBM Db2.
**Importante**
Per creare un tablespace, è necessario disporre di un pool di buffer della stessa dimensione di pagina da associare al tablespace. Per ulteriori informazioni, consulta [Attività comuni per i pool di buffer](db2-managing-buffer-pools.md).
**Per creare un tablespace**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crea un tablespace chiamando `rdsadmin.create_tablespace`. Per ulteriori informazioni, consulta [rdsadmin.create\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-create-tablespace).
```
db2 "call rdsadmin.create_tablespace(
'database_name',
'tablespace_name',
'buffer_pool_name',
tablespace_initial_size,
tablespace_increase_size,
'tablespace_type')"
```
## Modifica di un tablespace
Per modificare un tablespace per il database RDS per Db2, chiama la stored procedure `rdsadmin.alter_tablespace`. Questa stored procedure consente di modificare il pool di buffer di un tablespace, abbassare il livello più alto o portare online un tablespace. Per ulteriori informazioni, consulta [ALTER TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-tablespace) nella documentazione di IBM Db2.
**Per modificare un tablespace**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Modifica un tablespace chiamando `rdsadmin.alter_tablespace`. Per ulteriori informazioni, consulta [rdsadmin.alter\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-alter-tablespace).
```
db2 "call rdsadmin.alter_tablespace(
'database_name',
'tablespace_name',
'buffer_pool_name',
buffer_pool_size,
tablespace_increase_size,
'max_size', 'reduce_max',
'reduce_stop',
'reduce_value',
'lower_high_water',
'lower_high_water_stop',
'switch_online')"
```
## Ridenominazione di un tablespace
Per cambiare il nome di un tablespace per il database RDS per Db2, chiama la stored procedure `rdsadmin.rename_tablespace`. Per ulteriori informazioni, consulta [RENAME TABLESPACE statement](https://www.ibm.com/docs/en/db2/11.5?topic=statements-rename-tablespace) nella documentazione di IBM Db2.
**Per rinominare un tablespace**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, sostituisci *master\$1username* e *master\$1password* con le tue informazioni.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Rinomina un tablespace chiamando `rdsadmin.rename_tablespace`. Per ulteriori informazioni, incluse le restrizioni che riguardano il nome che è possibile assegnare a un tablespace, consulta [rdsadmin.rename\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-rename-tablespace).
```
db2 "call rdsadmin.rename_tablespace(
'database_name',
'source_tablespace_name',
'target_tablespace_name')"
```
## Eliminazione di un tablespace
Per eliminare un tablespace per il database RDS per Db2, chiama la stored procedure `rdsadmin.drop_tablespace`. Prima di eliminare una tablespace, rilasciate prima tutti gli oggetti nella tablespace, ad esempio tabelle, indici o oggetti di grandi dimensioni (). LOBs Per ulteriori informazioni, consulta [Dropping table spaces](https://www.ibm.com/docs/en/db2/11.5?topic=spaces-dropping-table) nella documentazione di IBM Db2.
**Per eliminare un tablespace**
1. Connettiti al database `rdsadmin` utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente, *master\$1username* sostituite e con le vostre informazioni. *master\$1password*
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Elimina un tablespace chiamando `rdsadmin.drop_tablespace`. Per ulteriori informazioni, consulta [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace).
```
db2 "call rdsadmin.drop_tablespace(
'database_name',
'tablespace_name')"
```
## Controllo dello stato di un tablespace
È possibile controllare lo stato di un tablespace utilizzando la funzione `cast`.
**Per controllare lo stato di un tablespace**
1. Connettiti al database Db2 utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente *rds\$1database\$1alias**master\$1username*, sostituisci e *master\$1password* con le tue informazioni.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Ottieni un output di riepilogo.
Per un output di riepilogo:
```
db2 "select cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents from table(mon_get_tablespace(null,-1)) order by tbsp_id"
```
## Restituzione di informazioni dettagliate sui tablespace
È possibile restituire informazioni su un tablespace per uno o tutti i membri utilizzando la funzione `cast`.
**Per restituire informazioni dettagliate sui tablespace**
1. Connettiti al database Db2 utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente *rds\$1database\$1alias**master\$1username*, sostituisci e *master\$1password* con le tue informazioni.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Ottieni informazioni dettagliate su tutti i tablespace nel database per un membro o per tutti i membri.
Per un membro:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents,
cast(tbsp_total_pages as integer) as total_pages,
cast(tbsp_used_pages as integer) as used_pages,
cast(tbsp_free_pages as integer) as free_pages,
cast(tbsp_page_top as integer) as page_hwm,
cast(tbsp_page_size as integer) as page_sz,
cast(tbsp_extent_size as smallint) as extent_sz,
cast(tbsp_prefetch_size as smallint) as prefetch_sz,
cast(tbsp_initial_size as integer) as initial_size,
cast(tbsp_increase_size_percent as smallint) as increase_pct,
cast(storage_group_name as varchar(12)) as stogroup from table(mon_get_tablespace(null,-1)) order by member, tbsp_id "
```
Per tutti i membri:
```
db2 "select cast(member as smallint) as member
cast(tbsp_id as smallint) as tbsp_id,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(tbsp_type as varchar(3)) as tbsp_type,
cast(tbsp_state as varchar(10)) as state,
cast(tbsp_content_type as varchar(8)) as contents,
cast(tbsp_total_pages as integer) as total_pages,
cast(tbsp_used_pages as integer) as used_pages,
cast(tbsp_free_pages as integer) as free_pages,
cast(tbsp_page_top as integer) as page_hwm,
cast(tbsp_page_size as integer) as page_sz,
cast(tbsp_extent_size as smallint) as extent_sz,
cast(tbsp_prefetch_size as smallint) as prefetch_sz,
cast(tbsp_initial_size as integer) as initial_size,
cast(tbsp_increase_size_percent as smallint) as increase_pct,
cast(storage_group_name as varchar(12)) as stogroup from table(mon_get_tablespace(null,-2)) order by member, tbsp_id "
```
## Elencare lo stato e il gruppo di archiviazione per un tablespace
È possibile elencare lo stato e il gruppo di archiviazione per un tablespace eseguendo un’istruzione SQL.
Per elencare lo stato e il gruppo di archiviazione di un tablespace, esegui la seguente istruzione SQL:
```
db2 "SELECT varchar(tbsp_name, 30) as tbsp_name,
varchar(TBSP_STATE, 30) state,
tbsp_type,
varchar(storage_group_name,30) storage_group
FROM TABLE(MON_GET_TABLESPACE('',-2)) AS t"
```
## Elencare i tablespace di una tabella
È possibile elencare i tablespace di una tabella eseguendo un’istruzione SQL.
Per elencare i tablespace di una tabella, esegui la seguente istruzione SQL. Nell'esempio seguente, sostituisci *SCHEMA\$1NAME* e *TABLE\$1NAME* con i nomi dello schema e della tabella:
```
db2 "SELECT
VARCHAR(SD.TBSPACE,30) AS DATA_SPACE,
VARCHAR(SL.TBSPACE,30) AS LONG_SPACE,
VARCHAR(SI.TBSPACE,30) AS INDEX_SPACE
FROM
SYSCAT.DATAPARTITIONS P
JOIN SYSCAT.TABLESPACES SD ON SD.TBSPACEID = P.TBSPACEID
LEFT JOIN SYSCAT.TABLESPACES SL ON SL.TBSPACEID = P.LONG_TBSPACEID
LEFT JOIN SYSCAT.TABLESPACES SI ON SI.TBSPACEID = P.INDEX_TBSPACEID
WHERE
TABSCHEMA = 'SCHEMA_NAME'
AND TABNAME = 'TABLE_NAME'"
```
## Elencare i container di tablespace
È possibile elencare tutti i container di tablespace o specifici container di tablespace utilizzando il comando `cast`.
**Per elencare i container di tablespace per un tablespace**
1. Connettiti al database Db2 utilizzando il nome utente e la password principali dell’istanza database RDS per Db2. Nell'esempio seguente *rds\$1database\$1alias**master\$1username*, sostituisci e *master\$1password* con le tue informazioni:
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Ottieni un elenco di tutti i container di tablespace nel database o specifici container di tablespace.
Per tutti i container di tablespace:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(container_id as smallint) as id,
cast(container_name as varchar(60)) as container_path, container_type as type from table(mon_get_container(null,-2)) order by member,tbsp_id,container_id"
```
Per container di tablespace specifici:
```
db2 "select cast(member as smallint) as member,
cast(tbsp_name as varchar(35)) as tbsp_name,
cast(container_id as smallint) as id,
cast(container_name as varchar(60)) as container_path, container_type as type from table(mon_get_container('TBSP_1',-2)) order by member, tbsp_id,container_id"
```