# Administrar a instância de banco de dados do Amazon RDS para Db2
Este tópico abrange as tarefas de gerenciamento comuns que você realiza com uma instância de banco de dados do Amazon RDS para Db2. Algumas tarefas são as mesmas para todas as instâncias de banco de dados do Amazon RDS. Outras tarefas são específicas do RDS para Db2.
As tarefas a seguir são comuns a todos os bancos de dados do RDS. Também há tarefas específicas do RDS para Db2, como conectar-se a um banco de dados do RDS para Db2 com um cliente SQL padrão.
| Área de tarefa | Documentação relevante |
| --- | --- |
| **Classes de instância, armazenamento e PIOPS** Se você estiver criando uma instância de produção, saiba como funcionam as classes de instância, os tipos de armazenamento e as IOPS provisionadas no Amazon RDS. | [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md) [Tipos de armazenamento do Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Implantações multi-AZ** Uma instância de banco de dados de produção deve usar implantações multi-AZ. As implantações multi-AZ oferecem maior disponibilidade, durabilidade de dados e tolerância a falhas para instâncias de banco de dados. | [Configurar e gerenciar uma implantação multi-AZ para o Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Se a Conta da AWS tiver uma nuvem privada virtual (VPC) padrão, a instância de banco de dados será criada automaticamente na VPC padrão. Se a sua conta não tiver uma VPC padrão e você quiser a instância de banco de dados em uma VPC, deverá criar os grupos de VPC e sub-redes antes de criar a instância de banco de dados. | [Trabalhar com uma instância de banco de dados em uma VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Grupos de segurança** Por padrão, as instâncias de banco de dados usam um firewall que impede o acesso. Crie um grupo de segurança com os endereços IP corretos e uma configuração de rede para acessar a instância de banco de dados. | [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md) |
| **Grupos de parâmetros** Como a instância de banco de dados do RDS para Db2 exige que você adicione os parâmetros `rds.ibm_customer_id` e `rds.ibm_site_id`, crie um grupo de parâmetros antes de criar a instância de banco de dados. Se a instância de banco de dados exigir outros parâmetros de banco de dados específicos, adicione-os também a esse grupo de parâmetros antes de criar a instância de banco de dados. | [Adicionar IDs da IBM a um grupo de parâmetros para instâncias de banco de dados do RDS para Db2](db2-licensing.md#db2-licensing-options-byol-adding-ids) [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Grupos de opções** Se a sua instância de banco de dados exigir opções de banco de dados específicas, crie um grupo de opções antes de criar a instância de banco de dados. | [Opções para instâncias de banco de dados do Amazon RDS para Db2](Db2.Options.md) |
| **Conexão à instância de banco de dados** Depois de criar um grupo de segurança e associá-lo a uma instância de banco de dados, será possível se conectar à instância de banco de dados com qualquer aplicação de cliente SQL padrão, como IBM Db2 CLP. | [Conectar-se à instância de banco de dados do Db2](USER_ConnectToDb2DBInstance.md) |
| **Backup e restauração** É possível configurar a instância de banco de dados para fazer backups de armazenamento automatizados ou criar snapshots manuais e, depois, restaurar instâncias por meio dos backups ou dos snapshots. | [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md) |
| **Monitoramento** É possível monitorar uma instância de banco de dados do RDS para Db2 com o IBM Db2 Data Management Console. Também é possível monitorar uma instância de banco de dados do RDS para Db2 usando métricas, eventos e o monitoramento aprimorado do Amazon RDS do CloudWatch. | [Conectar-se à instância de banco de dados do Amazon RDS para Db2 com o IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md) [Visualizar métricas no console do Amazon RDS](USER_Monitoring.md) [Visualizar eventos do Amazon RDS](USER_ListEvents.md) [Monitorar métricas do SO com o monitoramento avançado](USER_Monitoring.OS.md) |
| **Arquivos de log** É possível acessar os arquivos de log da instância de banco de dados do RDS para Db2. | [Monitorar arquivos de log do Amazon RDS](USER_LogAccess.md) |
**Topics**
+ [Realizar tarefas comuns do sistema para instâncias de banco de dados do Amazon RDS para Db2](db2-performing-common-system-tasks-db-instances.md)
+ [Realizar tarefas comuns de banco de dados para instâncias de banco de dados do Amazon RDS para Db2](db2-performing-common-database-tasks-db-instances.md)
# Realizar tarefas comuns do sistema para instâncias de banco de dados do Amazon RDS para Db2
É possível executar determinadas tarefas comuns de administrador de banco de dados relacionadas ao sistema nas instâncias de bancos de dados do Amazon RDS que executam o Db2. Para oferecer uma experiência de serviço gerenciado, o Amazon RDS não fornece acesso ao shell para instâncias de bancos de dados e restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados.
Consulte informações sobre como conceder e revogar privilégios e anexar ao banco de dados remoto do RDS para Db2 nos tópicos a seguir.
**Tópicos**
+ [Conceder e revogar privilégios do RDS para Db2](db2-granting-revoking-privileges.md)
+ [Conectar-se à instância de banco de dados remota do RDS para Db2](db2-attaching-to-remote.md)
## Criar um endpoint de banco de dados personalizado
Ao migrar para o Amazon RDS para Db2, é possível usar URLs de endpoint de banco de dados personalizados para minimizar as alterações na aplicação. Por exemplo, se você usar `db2.example.com` como o registro do DNS atual, poderá adicioná-lo ao Amazon Route 53. No Route 53, é possível usar zonas hospedadas privadas para associar o endpoint de banco de dados do DNS atual a um endpoint de banco de dados do RDS para Db2. Para adicionar um registro personalizado `A` ou `CNAME` ou um endpoint de banco de dados do Amazon RDS, consulte [Registering and managing domains using Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar.html) no *Guia do desenvolvedor do Amazon Route 53*.
**nota**
Se não for possível conseguir transferir o domínio para o Route 53, poderá usar o provedor de DNS para criar um registro `CNAME` para o URL do endpoint do banco de dados do RDS para Db2. Consulte a documentação do provedor de DNS.
# Conceder e revogar privilégios do RDS para Db2
Os usuários recebem acesso aos bancos de dados por meio da participação em grupos associados aos bancos de dados.
Use os procedimentos a seguir para conceder e revogar privilégios a fim de controlar o acesso ao banco de dados.
Esses procedimentos usam IBM Db2 CLP em execução em uma máquina local para se conectar a uma instância de banco de dados do RDS para Db2. Catalogue o nó TCP/IP e o banco de dados para se conectar à instância de banco de dados do RDS para Db2 em execução na máquina local. Para obter mais informações, consulte [Conectar-se à instância de banco de dados do Amazon RDS para Db2 com o IBM Db2 CLP](db2-connecting-with-clp-client.md).
**Topics**
+ [Conceder a um usuário acesso ao banco de dados](#db2-granting-user-access)
+ [Alterar a senha de um usuário](#db2-changing-user-password)
+ [Adicionar grupos a um usuário](#db2-adding-group-to-user)
+ [Remover grupos de um usuário](#db2-removing-groups-from-user)
+ [Remover um usuário](#db2-removing-user)
+ [Listar usuários](#db2-listing-users-database)
+ [Criar uma função](#db2-creating-role)
+ [Conceder um perfil](#db2-granting-role)
+ [Revogar um perfil](#db2-revoking-role)
+ [Eliminação de um perfil](#db2-dropping-role)
+ [Conceder autorização de banco de dados](#db2-granting-dbadmin-auth)
+ [Revogar autorização de banco de dados](#db2-revoking-dbadmin-auth)
## Conceder a um usuário acesso ao banco de dados
**Como conceder a um usuário acesso ao banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
Esse comando vai produzir uma saída semelhante ao seguinte exemplo:
```
Database Connection Information
Database server = DB2/LINUXX8664 11.5.8.0
SQL authorization ID = ADMIN
Local database alias = RDSADMIN
```
1. Adicione um usuário à lista de autorizações chamando `rdsadmin.add_user`. Para obter mais informações, consulte [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. (Opcional) Adicione outros grupos ao usuário chamando `rdsadmin.add_groups`. Para obter mais informações, consulte [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
1. Confirme as autoridades que estão disponíveis para o usuário. No exemplo a seguir, substitua *rds\$1database\$1alias*, *master\$1user* e *master\$1password* por suas próprias informações. Além disso, substitua *username* pelo nome do usuário.
```
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"
```
Esse comando vai produzir uma saída semelhante ao seguinte exemplo:
```
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. Conceda os perfis do RDS para Db2 `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` e `ROLE_PROCEDURES` ao grupo ao qual você adicionou o usuário. Para obter mais informações, consulte [Perfis padrão do Amazon RDS para Db2](db2-default-roles.md).
**nota**
Criamos instâncias de banco de dados do RDS para Db2 no modo `RESTRICTIVE`. Portanto, os perfis do RDS para Db2 `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` e `ROLE_PROCEDURES` concedem privilégios de execução em pacotes `NULLID` para IBM Db2 CLP e Dynamic SQL. Esses perfis também concedem privilégios de usuário em espaços de tabela.
1. Conecte-se ao banco de dados Db2. No exemplo a seguir, substitua *database\$1name*, *master\$1user* e *master\$1password* por suas próprias informações.
```
db2 connect to database_name user master_user using master_password
```
1. Conceda o perfil `ROLE_NULLED_PACKAGES` a um grupo. No exemplo a seguir, substitua *group\$1name* pelo nome do grupo ao qual você deseja adicionar o perfil.
```
db2 "grant role ROLE_NULLID_PACKAGES to group group_name"
```
1. Conceda o perfil `ROLE_TABLESPACES` ao mesmo grupo. No exemplo a seguir, substitua *group\$1name* pelo nome do grupo ao qual você deseja adicionar o perfil.
```
db2 "grant role ROLE_TABLESPACES to group group_name"
```
1. Conceda o perfil `ROLE_PROCEDURES` ao mesmo grupo. No exemplo a seguir, substitua *group\$1name* pelo nome do grupo ao qual você deseja adicionar o perfil.
```
db2 "grant role ROLE_PROCEDURES to group group_name"
```
1. Conceda as autoridades `connect`, `bindadd`, `createtab` e `IMPLICIT_SCHEMA` ao grupo ao qual você adicionou o usuário. No exemplo a seguir, substitua *group\$1name* pelo nome do segundo grupo ao qual você adicionou o usuário.
```
db2 "grant usage on workload SYSDEFAULTUSERWORKLOAD to public"
db2 "grant connect, bindadd, createtab, implicit_schema on database to group group_name"
```
1. Repita as etapas 4 a 6 para cada grupo adicional ao qual o usuário foi adicionado.
1. Para testar o acesso do usuário, faça o seguinte: conecte-se como ele, crie uma tabela, insira valores nela e exiba os dados da tabela. No exemplo a seguir, substitua *rds\$1database\$1alias*, *username* e *password* pelo nome do banco de dados e pelo nome de usuário e senha do usuário.
```
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"
```
## Alterar a senha de um usuário
**Para alterar a senha de um usuário**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Altere a senha chamando `rdsadmin.change_password`. Para obter mais informações, consulte [rdsadmin.change\$1password](db2-sp-granting-revoking-privileges.md#db2-sp-change-password).
```
db2 "call rdsadmin.change_password(
'username',
'new_password')"
```
## Adicionar grupos a um usuário
**Como adicionar grupos a um usuário**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Adicione grupos a um usuário chamando `rdsadmin.add_groups`. Para obter mais informações, consulte [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
## Remover grupos de um usuário
**Como remover grupos a um usuário**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Remova grupos chamando `rdsadmin.remove_groups`. Para obter mais informações, consulte [rdsadmin.remove\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-remove-groups).
```
db2 "call rdsadmin.remove_groups(
'username',
'group_name,group_name')"
```
## Remover um usuário
**Como remover um usuário da lista de autorizações**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Remova um usuário da lista de autorizações chamando `rdsadmin.remove_user`. Para obter mais informações, consulte [rdsadmin.remove\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-remove-user).
```
db2 "call rdsadmin.remove_user('username')"
```
## Listar usuários
Para listar usuários em uma lista de autorizações, chame o procedimento armazenado `rdsadmin.list_users`. Para obter mais informações, consulte [rdsadmin.list\$1users](db2-sp-granting-revoking-privileges.md#db2-sp-list-users).
```
db2 "call rdsadmin.list_users()"
```
## Criar uma função
É possível usar o procedimento armazenado [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role) para criar um perfil.
**Para criar uma função**
1. Conecte-se ao banco de dados `rdsadmin`. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Defina o Db2 para gerar conteúdo.
```
db2 set serveroutput on
```
1. Crie uma função. Para obter mais informações, consulte [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'database_name',
'role_name')"
```
1. Defina o Db2 para não gerar conteúdo.
```
db2 set serveroutput off
```
## Conceder um perfil
É possível usar o procedimento armazenado [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role) para atribuir um perfil a um perfil, um usuário ou um grupo.
**Como atribuir um perfil**
1. Conecte-se ao banco de dados `rdsadmin`. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Defina o Db2 para gerar conteúdo.
```
db2 set serveroutput on
```
1. Atribua um perfil. Para obter mais informações, consulte [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. Defina o Db2 para não gerar conteúdo.
```
db2 set serveroutput off
```
## Revogar um perfil
É possível usar o procedimento armazenado [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role) para revogar um perfil de um perfil, um usuário ou um grupo.
**Como revogar um perfil**
1. Conecte-se ao banco de dados `rdsadmin`. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Revogue um perfil. Para obter mais informações, consulte [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role).
```
db2 "call rdsadmin.revoke_role(
?,
'database_name',
'role_name',
'grantee')"
```
## Eliminação de um perfil
É possível usar o procedimento armazenado [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role) para descartar um perfil.
**Como excluir um perfil**
1. Conecte-se ao banco de dados `rdsadmin`. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Descarte um perfil. Para obter mais informações, consulte [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role).
```
db2 "call rdsadmin.drop_role(
?,
'database_name',
'role_name')"
```
## Conceder autorização de banco de dados
O usuário principal, que tem autorização `DBADM`, pode conceder a autorização `DBADM`, `ACCESSCTRL` ou `DATAACCESS` a um perfil, um usuário ou um grupo.
**Como conceder autorização de banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Conceda acesso a um usuário chamando `rdsadmin.dbadm_grant`. Para obter mais informações, consulte [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'database_name,
'authorization',
'grantee')"
```
**Exemplo de caso de uso**
O procedimento a seguir explica como criar um perfil, conceder autorização `DBADM` ao perfil, atribuir o perfil a um usuário e a um grupo.
****
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Crie um perfil chamado `PROD_ROLE` para um banco de dados chamado `TESTDB`. Para obter mais informações, consulte [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'TESTDB',
'PROD_ROLE')"
```
1. Atribua o perfil a um usuário denominado `PROD_USER`. O `PROD_USER` recebe autorização de administrador para atribuir perfis. Para obter mais informações, consulte [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. (Opcional) Forneça autorização ou privilégios adicionais. O exemplo a seguir concede autorização `DBADM` a um perfil denominado `PROD_ROLE` para um banco de dados chamado `FUNDPROD`. Para obter mais informações, consulte [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'FUNDPROD',
'DBADM',
'ROLE PROD_ROLE')"
```
1. Encerre a sessão.
```
db2 terminate
```
1. Conecte-se ao banco de dados `TESTDB` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to TESTDB user master_username using master_password
```
1. Adicione mais autorizações ao perfil.
```
db2 "grant connect, implicit_schema on database to role PROD_ROLE"
```
1. Conceda o perfil `PROD_ROLE` a um grupo.
```
db2 "grant role PROD_ROLE to group PRODGRP"
```
Os usuários que pertencem ao grupo `PRODGRP` agora podem realizar ações como conectar-se ao banco de dados `TESTDB`, criar tabelas ou esquemas.
## Revogar autorização de banco de dados
O usuário principal, que tem a autorização `DBADM`, pode revogar a autorização `DBADM`, `ACCESSCTRL` ou `DATAACCESS` de um perfil, um usuário ou um grupo.
**Como revogar autorização de banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Revogue o acesso do usuário chamando `rdsadmin.dbadm_revoke`. Para obter mais informações, consulte [rdsadmin.dbadm\$1revoke](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-revoke).
```
db2 "call rdsadmin.dbadm_revoke(
?,
'database_name,
'authorization',
'grantee')"
```
# Conectar-se à instância de banco de dados remota do RDS para Db2
Use as etapas a seguir para se conectar à sua instância de banco de dados remota do RDS para Db2 e executar operações `get snapshot`.
**Como se conectar à instância de banco de dados remota do RDS para Db2**
1. Execute uma sessão IBM Db2 CLP do lado do cliente. Para ter informações sobre como catalogar a instância de banco de dados e banco de dados do RDS para Db2, consulte [Conectar-se à instância de banco de dados do Amazon RDS para Db2 com o IBM Db2 CLP](db2-connecting-with-clp-client.md). Anote o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2.
1. Conecte-se à instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *node\$1name*, *master\$1username* e *master\$1password* pelo nome de nó TCPIP catalogado, além do nome de usuário principal e da senha mestra da instância de banco de dados do RDS para Db2.
```
db2 attach to node_name user master_username using master_password
```
Depois de se conectar à instância de banco de dados remota do RDS para Db2, é possível executar os comandos a seguir e outros comandos `get snapshot`. Para ter mais informações, consulte [GET SNAPSHOT command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-get-snapshot) na documentação do IBM Db2.
```
db2 list applications
db2 get snapshot for all databases
db2 get snapshot for database manager
db2 get snapshot for all applications
```
# Realizar tarefas comuns de banco de dados para instâncias de banco de dados do Amazon RDS para Db2
É possível realizar determinadas tarefas comuns de DBA relacionadas aos bancos de dados nas instâncias de bancos de dados do Amazon RDS para Db2. Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para as instâncias de banco de dados. Além disso, o usuário principal não pode executar comandos nem utilitários que exijam as autoridades `SYSADM`, `SYSMAINT` ou `SYSCTRL`.
Consulte informações sobre tarefas comuns para os grupos de buffer, bancos de dados e espaços de tabelas nos tópicos a seguir.
**Tópicos**
+ [Tarefas comuns para grupos de buffer](db2-managing-buffer-pools.md)
+ [Tarefas comuns para bancos de dados](db2-managing-databases.md)
+ [Tarefas comuns para espaços de tabela](db2-managing-tablespaces.md)
# Tarefas comuns para grupos de buffer
É possível criar, alterar ou descartar grupos de buffers para um banco de dados do RDS para Db2. Criar, alterar ou descartar grupos de buffers requer a autoridade `SYSADM` ou `SYSCTRL` de nível mais alto, que não está disponível para o usuário principal. Em vez disso, use procedimentos armazenados do Amazon RDS.
Também é possível limpar grupos de buffers.
**Topics**
+ [Criar um grupo de buffers](#db2-creating-buffer-pool)
+ [Alterar um grupo de buffers](#db2-altering-buffer-pool)
+ [Descartar um grupo de buffers](#db2-dropping-buffer-pool)
+ [Liberar os grupos de buffers](#db2-flushing-buffer-pools)
## Criar um grupo de buffers
Para criar um grupo de buffers para o banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.create_bufferpool`. Para ter mais informações, consulte [Declaração CREATE BUFFERPOOL](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-bufferpool) na documentação do IBM Db2.
**Como criar um grupo de buffers**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crie um grupo de buffers chamando `rdsadmin.create_bufferpool`. Para obter mais informações, consulte [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)"
```
## Alterar um grupo de buffers
Para alterar um grupo de buffers para o banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.alter_bufferpool`. Para ter mais informações, consulte [Declaração ALTER BUFFERPOOL](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-bufferpool) na documentação do IBM Db2.
**Como alterar um grupo de buffers**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Altere um grupo de buffers chamando `rdsadmin.alter_bufferpool`. Para obter mais informações, consulte [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)"
```
## Descartar um grupo de buffers
Para descartar um grupo de buffers para o banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.drop_bufferpool`. Para ter mais informações, consulte [Dropping buffer pools](https://www.ibm.com/docs/en/db2/11.5?topic=pools-dropping-buffer) na documentação do IBM Db2.
**Importante**
Garanta que nenhum espaço de tabela esteja atribuído ao grupo de buffers que você deseja descartar.
**Como descartar um grupo de buffers**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Descarte um grupo de buffers chamando `rdsadmin.drop_bufferpool`. Para obter mais informações, consulte [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 "call rdsadmin.drop_bufferpool(
'database_name',
'buffer_pool_name')"
```
## Liberar os grupos de buffers
É possível liberar os grupos de buffers para forçar um ponto de verificação para que o RDS para Db2 grave páginas da memória para o armazenamento.
**nota**
Não é necessário liberar os grupos de buffers. O Db2 grava logs de forma síncrona antes de confirmar as transações. As páginas sujas ainda podem estar em um grupo de buffers, mas o Db2 as grava no armazenamento de forma assíncrona. Mesmo que o sistema seja desligado inesperadamente, ao reiniciar o banco de dados, o Db2 executa automaticamente a recuperação de falhas. Durante a recuperação de falhas, o Db2 grava as alterações confirmadas no banco de dados ou as reverte para transações não confirmadas.
**Como liberar os grupos de buffers**
1. Conecte-se ao banco de dados Db2 usando o nome de usuário principal e a senha principal da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *rds\$1database\$1alias*, *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Libere os grupos de buffers.
```
db2 flush bufferpools all
```
# Tarefas comuns para bancos de dados
É possível criar, descartar ou restaurar bancos de dados na instância de banco de dados do RDS para Db2. Criar, descartar ou restaurar bancos de dados requer autoridade `SYSADM` de nível mais alto, que não está disponível para o usuário principal. Em vez disso, use procedimentos armazenados do Amazon RDS.
Também é possível realizar tarefas comuns de gerenciamento, como monitoramento, manutenção e coleta de informações sobre seus bancos de dados.
**Topics**
+ [Criação de um banco de dados](#db2-creating-database)
+ [Definir configurações para um banco de dados](#db2-configuring-database)
+ [Modificar parâmetros de banco de dados](#db2-modifying-db-parameters)
+ [Configurar a retenção de logs](#db2-configuring-log-retention)
+ [Listar informações de log](#db2-listing-log-information)
+ [Usar o controle de acesso refinado (FGAC)](#db2-using-fine-grained-access-control)
+ [Desativação de um banco de dados](#db2-deactivating-database)
+ [Ativação de um banco de dados](#db2-activating-database)
+ [Reativar um banco de dados](#db2-reactivating-database)
+ [Descartar um banco de dados](#db2-dropping-database)
+ [Realização de backup de um banco de dados](#db2-backing-up-database)
+ [Copiar logs de arquivamento para o Amazon S3](#db2-copying-archive-logs-to-s3)
+ [Restaurar um banco de dados](#db2-restoring-database)
+ [Listagem de bancos de dados](#db2-listing-databases)
+ [Coletar informações sobre bancos de dados](#db2-collecting-info-db)
+ [Forçar a retirada de aplicações de bancos de dados](#db2-forcing-application-off-db)
+ [Gerar relatórios de performance](#db2-generating-performance-reports)
## Criação de um banco de dados
Para criar um banco de dados na instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.create_database`. Para ter mais informações, consulte [CREATE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-create-database) na documentação do IBM Db2.
**nota**
Se você planeja modificar o parâmetro `db2_compatibility_vector`, modifique-o antes de criar um banco de dados. Para obter mais informações, consulte [Configuração do parâmetro db2\$1compatibility\$1vector](db2-known-issues-limitations.md#db2-known-issues-limitations-db2-compatibility-vector).
**Para criar um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crie um banco de dados chamando `rdsadmin.create_database`. Para obter mais informações, consulte [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. (Opcional) Crie bancos de dados adicionais chamando `rdsadmin.create_database` para cada banco de dados que você deseja criar. Cada instância de banco de dados do Db2 pode conter até 50 bancos de dados. Para obter mais informações, consulte [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database('database_name')"
```
1. (Opcional) Confirme se o seu banco de dados foi criado usando um dos seguintes métodos:
+ Chame `rdsadmin.list_databases`. Para obter mais informações, consulte [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
+ Execute o seguinte 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"
```
## Definir configurações para um banco de dados
Para definir as configurações de um banco de dados na instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.set_configuration`. Por exemplo, é possível configurar o número de buffers ou manipuladores de buffer a serem criados durante uma operação de restauração.
**Como definir as configurações de um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Opcional) Confira suas configurações atuais chamando `rdsadmin.show_configuration`. Para obter mais informações, consulte [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Defina as configurações do banco de dados chamando `rdsadmin.set_configuration`. Para obter mais informações, consulte [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
## Modificar parâmetros de banco de dados
O Amazon RDS para Db2 usa três tipos de parâmetros: parâmetros de configuração do gerenciador de banco de dados, variáveis do registro e parâmetros de configuração do banco de dados. É possível atualizar os dois primeiros tipos por meio de grupos de parâmetros e o último tipo por meio do procedimento armazenado [rdsadmin.update\$1db\$1param](db2-sp-managing-databases.md#db2-sp-update-db-param).
**nota**
É possível modificar apenas os valores dos parâmetros existentes. Não é possível adicionar novos parâmetros não aceitos pelo RDS para Db2.
Para ter mais informações sobre esses parâmetros e como modificar os valores, consulte [Parâmetros do Amazon RDS para Db2](db2-supported-parameters.md).
## Configurar a retenção de logs
Para configurar por quanto tempo o Amazon RDS retém arquivos de log do banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.set_archive_log_retention`.
**Como configurar a retenção de logs de um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Opcional) Confira sua configuração atual para retenção de logs chamando `rdsadmin.show_archive_log_retention`. Para obter mais informações, consulte [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. Configure a retenção de logs do banco de dados chamando `rdsadmin.set_archive_log_retention`. Para obter mais informações, consulte [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')"
```
## Listar informações de log
Para listar detalhes sobre arquivos de log de arquivamento, como o tamanho total de armazenamento usado, chame o procedimento armazenado `rdsadmin.list_archive_log_information`.
**Como listar informações de log de um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Obtenha uma lista de informações do arquivo de log chamando `rdsadmin.list_archive_log_information`. Para obter mais informações, consulte [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')"
```
## Usar o controle de acesso refinado (FGAC)
Para usar comandos de controle de acesso refinado com o objetivo de controlar o acesso aos dados da tabela em um banco de dados em uma instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.fgac_command`. Convém usar o FGAC para limitar o acesso aos dados com base nos perfis de usuário ou nos atributos dos dados. Por exemplo, você pode limitar o acesso aos dados de assistência médica do paciente com base no tipo de dados ou em determinados prestadores de cuidados médicos.
**Como usar o controle de acesso refinado para controlar o acesso aos dados da tabela em um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Execute vários comandos de controle de acesso refinado chamando `rdsadmin.fgac_command`. Para obter mais informações, consulte [rdsadmin.fgac\$1commandParâmetros](db2-sp-managing-databases.md#db2-sp-fgac-command).
```
db2 "call rdsadmin.fgac_command(
?,
'database_name',
'fgac_command')"
```
## Desativação de um banco de dados
Para desativar um banco de dados na instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.deactivate_database`.
Por padrão, o Amazon RDS ativa um banco de dados ao criar um banco de dados na instância de banco de dados do RDS para Db2. Você pode desativar bancos de dados usados com pouca frequência para preservar recursos de memória.
**Como desativar um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Desative um banco de dados chamando `rdsadmin.deactivate_database`. Para obter mais informações, consulte [rdsadmin.deactivate\$1database](db2-sp-managing-databases.md#db2-sp-deactivate-database).
```
db2 "call rdsadmin.deactivate_database(
?,
'database_name')"
```
## Ativação de um banco de dados
Para ativar um banco de dados em uma instância autônoma de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.activate_database`.
Por padrão, o Amazon RDS ativa um banco de dados ao criar um banco de dados na instância de banco de dados do RDS para Db2. Você pode desativar bancos de dados usados com pouca frequência para preservar recursos de memória e, posteriormente, ativar um banco de dados desativado.
**Como ativar um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Ative um banco de dados chamando `rdsadmin.activate_database`. Para obter mais informações, consulte [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database).
```
db2 "call rdsadmin.activate_database(
?,
'database_name')"
```
## Reativar um banco de dados
Para reativar um banco de dados em uma instância de banco de dados do RDS para Db2 de origem de réplica, chame o procedimento armazenado `rdsadmin.reactivate_database`. Depois de fazer alterações nas configurações do banco de dados, talvez seja necessário reativar um banco de dados em uma instância de banco de dados do RDS para Db2. Para determinar se você precisa reativar um banco de dados, conecte-se a ele e execute `db2 get db cfg show detail`.
Também é possível chamar esse procedimento armazenado para reativar um banco de dados em uma instância autônoma de banco de dados do RDS para Db2 depois de fazer alterações nas configurações do banco de dados. Ou você pode reativar um banco de dados em uma instância autônoma de banco de dados RDS para Db2 chamando primeiro o procedimento armazenado `rdsadmin.deactivate_database` e depois o procedimento armazenado `rdsadmin.activate_database`. Para obter mais informações, consulte [Desativação de um banco de dados](#db2-deactivating-database) e [Ativação de um banco de dados](#db2-activating-database).
**Como reativar um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Reative um banco de dados chamando `rdsadmin.reactivate_database`. Para obter mais informações, consulte [rdsadmin.reactivate\$1database](db2-sp-managing-databases.md#db2-sp-reactivate-database).
```
db2 "call rdsadmin.reactivate_database(
?,
'database_name')"
```
## Descartar um banco de dados
Para descartar um banco de dados da instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.drop_database`. Para ter mais informações, consulte [Dropping databases](https://www.ibm.com/docs/en/db2/11.5?topic=databases-dropping) na documentação do IBM Db2.
**nota**
Será possível descartar um banco de dados chamando o procedimento armazenado somente se determinadas condições forem atendidas. Para acessar mais informações, consulte [Observações de uso](db2-sp-managing-databases.md#db2-sp-drop-database-usage-notes) para `rdsadmin.drop_database`.
**Como descartar um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Descarte um banco de dados chamando `rdsadmin.drop_database`. Para obter mais informações, consulte [rdsadmin.drop\$1database](db2-sp-managing-databases.md#db2-sp-drop-database).
```
db2 "call rdsadmin.drop_database('database_name')"
```
## Realização de backup de um banco de dados
Para fazer backup de um banco de dados na instância de banco de dados do RDS para Db2 para o Amazon S3, chame o procedimento armazenado `rdsadmin.backup_database`. Para acessar mais informações, consulte [BACKUP DATABASE command](https://www.ibm.com/docs/en/db2/11.5.x?topic=commands-backup-database) na documentação do IBM Db2.
**nota**
Esse procedimento armazenado usa a integração ao Amazon S3. Antes de continuar, verifique se você configurou a integração. Para obter mais informações, consulte [Integrar uma instância de banco de dados do Amazon RDS para Db2 ao Amazon S3](db2-s3-integration.md).
**Como fazer backup de um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crie um endpoint do gateway da VPC para o S3. Se você já tem um endpoint do gateway da VPC para o S3, vá para a etapa 4.
Para que uma instância de banco de dados do RDS para Db2 interaja com o Amazon S3, é necessário ter uma VPC e um endpoint do gateway do Amazon S3 para uso pelas sub-redes privadas. Para obter mais informações, consulte [Etapa 1: Criar um endpoint do gateway da VPC para o Amazon S3](db2-troubleshooting.md#db2-creating-endpoint).
1. Confirme o endpoint do gateway da VPC para o S3. Para obter mais informações, consulte [Etapa 2: Confirmar se o endpoint do gateway da VPC para o Amazon S3 existe](db2-troubleshooting.md#db2-confirming-endpoint).
1. Faça backup de um banco de dados chamando `rdsadmin.backup_database`. Para obter mais informações, consulte [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. Encerre a conexão.
```
terminate
```
1. (Opcional) Confirme se foi feito upload dos arquivos de backup no bucket do Amazon S3, em *s3\$1prefix/dbi\$1resource\$1id/db\$1name*. Se os arquivos não aparecerem em *s3\$1prefix/dbi\$1resource\$1id/db\$1name*, confira o status do backup do seu banco de dados para identificar quaisquer problemas. Para obter mais informações, consulte [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status). Se você não conseguir resolver nenhum problema identificado, entre em contato com o [AWS Support](https://aws.amazon.com/premiumsupport/).
1. (Opcional) Após a conclusão do backup para o Amazon S3, você pode restaurar o backup para uma instância de banco de dados do RDS para Db2 ou para outro local, como um servidor local. Para acessar informações sobre como realizar a restauração para uma instância de banco de dados do RDS para Db2, consulte [Restaurar um banco de dados](#db2-restoring-database).
## Copiar logs de arquivamento para o Amazon S3
Agora é possível copiar logs de arquivamento do Db2 da instância de banco de dados do RDS para Db2 para o Amazon S3. Os logs de arquivamento, associados ao backup nativo criado com `rdsadmin.backup_database`, podem ser usados para restaurar e recuperar o banco de dados para um ponto no tempo em outra instância do RDS para Db2 ou banco de dados do EC2.
Antes de configurar esse recurso, use o procedimento armazenado `rdsadmin.backup_database` para configurar o RDS para o banco de dados Db2.
Esse recurso opera em nível de instância de banco de dados do RDS para Db2, embora seja possível habilitar ou desabilitar a cópia de logs de arquivamento em nível de banco de dados.
**Como configurar a cópia de logs de arquivamento para o Amazon S3**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Configure o backup de logs de arquivamento para o S3 chamando [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
**Exemplo:**
```
db2 "call rdsadmin.set_configuration('ARCHIVE_LOG_COPY_TARGET_S3_ARN', 'arn:aws:s3:::my_rds_db2_backups/archive-log-copy/')"
```
1. Habilite a cópia de logs de arquivamento para um banco de dados chamando `rdsadmin.enable_archive_log_copy`. Substitua *database\$1name* pelo nome do seu banco de dados.
```
db2 "call rdsadmin.enable_archive_log_copy(?, 'database_name')"
```
1. Da mesma forma, para desabilitar a cópia de logs de arquivamento para um banco de dados, chame `rdsadmin.disable_archive_log_copy`.
```
db2 "call rdsadmin.disable_archive_log_copy(?, 'database_name')"
```
1. Confirme o status da cópia de logs de arquivamento chamando `rdsadmin.list_databases`.
```
db2 "select * from table(rdsadmin.list_databases())"
```
**Exemplo de saída:**
```
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 - - -
...
```
## Restaurar um banco de dados
Para mover um banco de dados de um bucket do Amazon S3 para a instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.restore_database`. Para ter mais informações, consulte [RESTORE DATABASE command](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database) na documentação do IBM Db2.
**Para restaurar um banco de dados do**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Opcional) Confira suas configurações atuais para otimizar a operação de restauração chamando `rdsadmin.show_configuration`. Para obter mais informações, consulte [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Defina as configurações para otimizar a operação de restauração chamando `rdsadmin.set_configuration`. Definir explicitamente esses valores pode melhorar a performance ao restaurar bancos de dados com grandes volumes de dados. Para obter mais informações, consulte [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
1. Restaure o banco de dados chamando `rdsadmin.restore_database`. Para obter mais informações, consulte [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. (Opcional) Confirme se seu banco de dados foi restaurado chamando `rdsadmin.list_databases` e verificando se o banco de dados restaurado está listado. Para obter mais informações, consulte [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
1. Reative o banco de dados e aplique logs de transações adicionais chamando `rdsadmin.rollforward_database`. Para obter mais informações, consulte [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. (Opcional) Verifique o status do procedimento armazenado `rdsadmin.rollforward_database` chamando o procedimento armazenado [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
1. Se você definiu `complete_rollforward` como `FALSE` na etapa anterior, termine de ativar o banco de dados chamando `rdsadmin.complete_rollforward`. Para obter mais informações, consulte [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward).
```
db2 "call rdsadmin.complete_rollforward(
?,
'database_name')"
```
1. (Opcional) Verifique o status do procedimento armazenado `rdsadmin.complete_rollforward` chamando o procedimento armazenado [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
## Listagem de bancos de dados
Você pode listar todos os seus bancos de dados em execução no Amazon RDS para Db2 chamando a função definida pelo usuário `rdsadmin.list_databases`.
**Como listar seus bancos de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Liste seus bancos de dados chamando `rdsadmin.list_databases`. Para obter mais informações, consulte [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
```
db2 "select * from table(rdsadmin.list_databases())"
```
## Coletar informações sobre bancos de dados
Para coletar informações sobre uma instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.db2pd_command`. Essas informações podem ajudar a monitorar os bancos de dados ou solucionar problemas.
**Como coletar informações sobre um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Colete informações sobre o banco de dados chamando `rdsadmin.db2pd_command`. Para obter mais informações, consulte [rdsadmin.db2pd\$1command](db2-sp-managing-databases.md#db2-sp-db2pd-command).
```
db2 "call rdsadmin.db2pd_command('db2pd_cmd')"
```
## Forçar a retirada de aplicações de bancos de dados
Para forçar a retirada das aplicações de um banco de dados em sua instância de banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.force_application`. Antes de realizar a manutenção nos bancos de dados, retire as aplicações dos bancos de dados.
**Como forçar a retirada das aplicações de um banco de dados**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Force a retirada das aplicações de um banco de dados chamando `rdsadmin.force_application`. Para obter mais informações, consulte [rdsadmin.force\$1application](db2-sp-managing-databases.md#db2-sp-force-application).
```
db2 "call rdsadmin.force_application(
?,
'applications')"
```
## Gerar relatórios de performance
É possível gerar relatórios de performance com um procedimento ou um script. Para ter informações sobre o uso de um procedimento, consulte [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) na documentação do IBM Db2.
O Db2 inclui um arquivo `db2mon.sh` no `~sqllib/sample/perf` diretório. A execução do script produz um relatório de métricas SQL extenso e de baixo custo. Para baixar o arquivo `db2mon.sh` e os arquivos de script relacionados, consulte o diretório [https://github.com/IBM/db2-samples/tree/master/perf](https://github.com/IBM/db2-samples/tree/master/perf) no repositório GitHub db2-samples da IBM.
**Como gerar relatórios de performance com o script**
1. Conecte-se ao banco de dados Db2 usando o nome de usuário principal e a senha principal da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Crie um grupo de buffers chamado `db2monbp` com um tamanho de página de 4.096 chamando `rdsadmin.create_bufferpool`. Para obter mais informações, consulte [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool).
```
db2 "call rdsadmin.create_bufferpool('database_name','db2monbp',4096)"
```
1. Crie um espaço de tabela temporário chamado `db2montmptbsp` que use o grupo de buffers `db2monbp` chamando `rdsadmin.create_tablespace`. Para obter mais informações, consulte [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. Abra o script `db2mon.sh` e modifique a linha sobre a conexão com um banco de dados.
1. Remova a linha a seguir.
```
db2 -v connect to $dbName
```
1. Substitua a linha na etapa anterior pela linha a seguir. No exemplo a seguir, substitua *master\$1username* e *master\$1password* pelo nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2.
```
db2 -v connect to $dbName user master_username using master_password
```
1. Remova as linhas a seguir.
```
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. Execute o script `db2mon.sh` para gerar um relatório em intervalos especificados. No exemplo a seguir, substitua *absolute\$1path* pelo caminho completo do arquivo de script, *rds\$1database\$1alias* pelo nome do banco de dados e *seconds* pelo número de segundos (0 a 3.600) entre as gerações do relatório.
```
absolute_path/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
**Exemplos**
O exemplo a seguir mostra que o arquivo de script está localizado no diretório `perf` abaixo do diretório `home`.
```
/home/db2inst1/sqllib/samples/perf/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
1. Descarte o grupo de buffers e o espaço de tabela que foram criados para o arquivo `db2mon.sh`. No exemplo a seguir, substitua *master\$1username* e *master\$1password* pelo nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. Substitua *database\$1name* pelo nome do banco de dados. Para obter mais informações, consulte [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')"
```
## Gerenciar o armazenamento
O Db2 usa armazenamento automático para gerenciar o armazenamento físico de objetos de banco de dados, como tabelas, índices e arquivos temporários. Em vez de alocar espaço de armazenamento manualmente e acompanhar quais caminhos de armazenamento estão sendo usados, o armazenamento automático permite que o sistema Db2 crie e gerencie caminhos de armazenamento conforme necessário. Isso pode simplificar a administração de bancos de dados do Db2 e reduzir a probabilidade de erros humanos. Para ter mais informações, consulte [Armazenamento automático](https://www.ibm.com/docs/en/db2/11.5?topic=overview-automatic-storage), na documentação do IBM Db2.
Com o RDS para Db2, é possível aumentar dinamicamente o tamanho do armazenamento com a expansão automática dos volumes lógicos e do sistema de arquivos. Para obter mais informações, consulte [Trabalhar com armazenamento para instâncias de banco de dados do Amazon RDS](USER_PIOPS.StorageTypes.md).
# Tarefas comuns para espaços de tabela
É possível criar, alterar, renomear ou descartar espaços de tabela de um banco de dados do RDS para Db2. Criar, alterar, renomear ou descartar espaços de tabela requer autoridade `SYSADM` de nível mais alto, que não está disponível para o usuário principal. Em vez disso, use procedimentos armazenados do Amazon RDS.
**Topics**
+ [Criar um espaço de tabela](#db2-creating-tablespace)
+ [Alterar um espaço de tabela](#db2-altering-tablespace)
+ [Renomear um espaço de tabela](#db2-renaming-tablespace)
+ [Descartar um espaço de tabela](#db2-dropping-tablespace)
+ [Conferir o status de um espaço de tabela](#db2-checking-tablespaces-procedure)
+ [Exibir informações detalhadas sobre espaços de tabela](#db2-tablespaces-info-db2pd)
+ [Listar o estado e o grupo de armazenamento de um espaço de tabela](#db2-state-storage-group-tablespace-sql)
+ [Listar os espaços de uma tabela](#db2-return-tablespaces-sql)
+ [Listar contêineres de espaço de tabela](#db2-listing-tablespace-containers)
## Criar um espaço de tabela
Para criar um espaço de tabela do banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.create_tablespace`. Para ter mais informações, consulte [Declaração CREATE TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-tablespace) na documentação do IBM Db2.
**Importante**
Para criar um espaço de tabela, é necessário ter um grupo de buffers do mesmo tamanho de página para associar ao espaço de tabela. Para obter mais informações, consulte [Tarefas comuns para grupos de buffer](db2-managing-buffer-pools.md).
**Como criar um espaço de tabela**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Crie um espaço de tabela chamando `rdsadmin.create_tablespace`. Para obter mais informações, consulte [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')"
```
## Alterar um espaço de tabela
Para alterar um espaço de tabela do banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.alter_tablespace`. É possível usar esse procedimento armazenado para alterar o grupo de buffers de um espaço de tabela, diminuir a marca d'água alta ou colocar um espaço de tabela on-line. Para ter mais informações, consulte [Declaração ALTER TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-tablespace) na documentação do IBM Db2.
**Como alterar um espaço de tabela**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Altere um espaço de tabela chamando `rdsadmin.alter_tablespace`. Para obter mais informações, consulte [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')"
```
## Renomear um espaço de tabela
Para alterar o nome de um espaço de tabela do banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.rename_tablespace`. Para ter mais informações, consulte [Declaração RENAME TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-rename-tablespace) na documentação do IBM Db2.
**Como renomear um espaço de tabela**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Renomeie um espaço de tabela chamando `rdsadmin.rename_tablespace`. Para ter mais informações, bem como conhecer as restrições em relação a como nomear um espaço de tabela, consulte [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')"
```
## Descartar um espaço de tabela
Para descartar um espaço de tabela do banco de dados do RDS para Db2, chame o procedimento armazenado `rdsadmin.drop_tablespace`. Antes de descartar um espaço de tabela, primeiro descarte qualquer objeto no espaço de tabela, como tabelas, índices ou objetos grandes (LOBs). Para ter mais informações, consulte [Dropping table spaces](https://www.ibm.com/docs/en/db2/11.5?topic=spaces-dropping-table) na documentação do IBM Db2.
**Como descartar um espaço de tabela**
1. Conecte-se ao banco de dados `rdsadmin` usando o nome de usuário principal e a senha mestra da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Altere um espaço de tabela chamando `rdsadmin.drop_tablespace`. Para obter mais informações, consulte [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace).
```
db2 "call rdsadmin.drop_tablespace(
'database_name',
'tablespace_name')"
```
## Conferir o status de um espaço de tabela
É possível conferir o status de um espaço de tabela usando a função `cast`.
**Como conferir o status de um espaço de tabela**
1. Conecte-se ao banco de dados Db2 usando o nome de usuário principal e a senha principal da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *rds\$1database\$1alias*, *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Exiba uma saída resumida.
Para exibir uma saída resumida:
```
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"
```
## Exibir informações detalhadas sobre espaços de tabela
É possível exibir informações sobre um espaço de tabela para um membro ou todos os membros usando a função `cast`.
**Como exibir informações detalhadas sobre espaços de tabela**
1. Conecte-se ao banco de dados Db2 usando o nome de usuário principal e a senha principal da instância de banco de dados do RDS para Db2. No exemplo a seguir, substitua *rds\$1database\$1alias*, *master\$1username* e *master\$1password* por suas próprias informações.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Exiba detalhes sobre todos os espaços de tabela no banco de dados para um ou todos os membros.
Para um 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 "
```
Para todos os membros:
```
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 "
```
## Listar o estado e o grupo de armazenamento de um espaço de tabela
É possível listar o estado e o grupo de armazenamento de um espaço de tabela ao executar uma declaração SQL.
Para listar o estado e o grupo de armazenamento de um espaço de tabela, execute a seguinte declaração 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"
```
## Listar os espaços de uma tabela
É possível listar os espaços de tabela de uma tabela executando uma declaração SQL.
Para listar os espaços de uma tabela, execute a declaração SQL a seguir. No seguinte exemplo, substitua *SCHEMA\$1NAME* e *TABLE\$1NAME* pelo nome do esquema e da tabela:
```
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'"
```
## Listar contêineres de espaço de tabela
É possível listar todos os contêineres de espaço de tabela ou contêineres de espaço de tabela específicos usando o comando `cast`.
**Como listar os contêineres de um espaço de tabela**
1. Conecte-se ao banco de dados Db2 usando o nome de usuário principal e a senha principal da instância de banco de dados do RDS para Db2. No seguinte exemplo, substitua *rds\$1database\$1alias*, *master\$1username* e *master\$1password* por suas próprias informações:
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Exiba uma lista de todos os contêineres de espaço de tabela no banco de dados ou de contêineres de espaço de tabela específicos.
Para todos os contêineres de espaço de tabela:
```
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"
```
Para todos os contêineres de espaço de tabela específicos:
```
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"
```