Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Administration de votre instance de base de données Amazon RDS for Db2
Cette rubrique couvre les tâches de gestion courantes que vous effectuez avec une instance de base de données Amazon RDS for Db2. Certaines tâches sont les mêmes pour toutes les instances de base de données Amazon RDS. D’autres tâches sont spécifiques à RDS for Db2.
Les tâches suivantes sont communes à toutes les bases de données RDS. Il existe également des tâches spécifiques à RDS for Db2, telles que la connexion à une base de données RDS for Db2 avec un client SQL standard.
| Type de tâche | Documentation |
| --- | --- |
| **Classes d’instance, stockage et PIOPS** Si vous créez une instance de production, découvrez comment fonctionnent les classes d'instance, les types de stockage et les IOPS provisionnées dans Amazon RDS. | [Classes d'instances de base de données ](Concepts.DBInstanceClass.md) [Types de stockage Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Déploiements multi-AZ** Une instance de base de données de production doit utiliser des déploiements multi-AZ. Les déploiements Multi-AZ améliorent la disponibilité, la durabilité des donnés et la tolérance aux pannes pour les instances de bases de données. | [Configuration et gestion d’un déploiement multi-AZ pour Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Si vous disposez Compte AWS d'un cloud privé virtuel (VPC) par défaut, votre instance de base de données est automatiquement créée dans le VPC par défaut. Si votre compte n'a pas de VPC par défaut et que vous voulez que l'instance de base de données soit dans un VPC, créez le VPC et les groupes de sous-réseaux avant de créer l'instance de base de données. | [Utilisation d’une instance de base de données dans un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Groupes de sécurité** Par défaut, les instances de base de données utilisent un pare-feu qui empêche l’accès. Veillez à créer un groupe de sécurité avec les adresses IP et la configuration réseau voulues pour accéder à l'instance de base de données. | [Contrôle d’accès par groupe de sécurité](Overview.RDSSecurityGroups.md) |
| **Groupes de paramètres** Étant donné que votre instance de base de données RDS for Db2 nécessite que vous ajoutiez les paramètres `rds.ibm_customer_id` et `rds.ibm_site_id`, créez un groupe de paramètres avant de créer l’instance de base de données. Si votre instance de base de données nécessite d’autres paramètres de base de données spécifiques, ajoutez-les à ce groupe de paramètres avant de créer l’instance de base de données. | [Ajout IBM IDs à un groupe de paramètres pour les instances de base de données RDS pour DB2](db2-licensing.md#db2-licensing-options-byol-adding-ids) [Groupes de paramètres pour Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Groupes d’options** Si votre instance de base de données nécessite des options spécifiques, créez un groupe d'options avant de créer l'instance de base de données. | [Options pour les instances de base de données Amazon RDS for Db2](Db2.Options.md) |
| **Connexion à votre instance de base de données** Après avoir créé un groupe de sécurité et l’avoir associé à une instance de base de données, vous pouvez vous connecter à l’instance de base de données en utilisant une application cliente SQL standard quelconque telle que IBM Db2 CLP. | [Connexion à votre instance de base de données Db2](USER_ConnectToDb2DBInstance.md) |
| **Sauvegarde et restauration** Vous pouvez configurer votre instance de base de données pour que les sauvegardes de stockage soient exécutées automatiquement ou que les instantanés de stockage soient créés manuellement, puis que les instances soient restaurées à partir des sauvegardes ou des instantanés. | [Sauvegarde, restauration et exportation de données](CHAP_CommonTasks.BackupRestore.md) |
| **Surveillance** Vous pouvez surveiller une instance de base de données RDS for Db2 avec IBM Db2 Data Management Console. Vous pouvez également surveiller une instance de base de données RDS pour DB2 à l'aide des métriques, des événements et de la surveillance améliorée d' CloudWatch Amazon RDS. | [Connexion à votre instance de base de données Amazon RDS for Db2 avec IBM Db2 Data Management Console](db2-connecting-with-ibm-data-management-console.md) [Affichage des métriques dans la console Amazon RDS](USER_Monitoring.md) [Affichage d’événements Amazon RDS](USER_ListEvents.md) [Surveillance des métriques du système d’exploitation à l’aide de la Surveillance améliorée](USER_Monitoring.OS.md) |
| **Les fichiers journaux** Vous pouvez accéder aux fichiers journaux de votre instance de base de données RDS for Db2. | [Surveillance des fichiers journaux Amazon RDS](USER_LogAccess.md) |
**Topics**
+ [Exécution des tâches système courantes pour les instances de base de données RDS for Db2](db2-performing-common-system-tasks-db-instances.md)
+ [Exécution des tâches de base de données courantes pour les instances de base de données RDS for Db2](db2-performing-common-database-tasks-db-instances.md)
# Exécution des tâches système courantes pour les instances de base de données RDS for Db2
Vous pouvez effectuer certaines tâches d’administrateur de base de données courantes liées au système sur vos instances de base de données Amazon RDS en exécutant Db2. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données et limite l'accès à certaines tables et procédures système qui requièrent des privilèges avancés.
Pour plus d’informations sur l’octroi et la révocation de privilèges et sur l’attachement à la base de données distante pour RDS for Db2, consultez les rubriques suivantes.
**Rubriques**
+ [Octroi et révocation de privilèges pour RDS for Db2](db2-granting-revoking-privileges.md)
+ [Connexion à l’instance de base de données RDS for Db2 distante](db2-attaching-to-remote.md)
## Création d’un point de terminaison de base de données personnalisé
Lorsque vous migrez vers Amazon RDS pour DB2, vous pouvez utiliser un point de terminaison de base de données personnalisé URLs afin de minimiser les modifications apportées à votre application. Par exemple, si vous utilisez `db2.example.com` comme enregistrement DNS actuel, vous pouvez l’ajouter à Amazon Route 53. Dans Route 53, vous pouvez utiliser des zones hébergées privées pour mapper le point de terminaison de votre base de données DNS actuel à un point de terminaison de base de données RDS for Db2. Pour ajouter un enregistrement `A` ou `CNAME` pour un point de terminaison de base de données Amazon RDS, consultez [Enregistrement et gestion de domaines à l’aide d’Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/registrar.html) dans le *Guide du développeur Amazon Route 53*.
**Note**
Si vous ne parvenez pas à transférer votre domaine vers Route 53, vous pouvez utiliser votre fournisseur DNS pour créer un enregistrement `CNAME` pour l’URL du point de terminaison de base de données RDS for Db2. Consultez la documentation de votre fournisseur DNS.
# Octroi et révocation de privilèges pour RDS for Db2
Les utilisateurs accèdent aux bases de données par le biais de l’appartenance à des groupes attachés aux bases de données.
Utilisez les procédures suivantes pour accorder et révoquer des privilèges afin de contrôler l’accès à votre base de données.
Ces procédures utilisent IBM Db2 CLP exécuté sur une machine locale pour se connecter à une instance de base de données RDS for Db2. Assurez-vous de cataloguer le nœud TCP/IP et la base de données pour vous connecter à votre instance de base de données RDS for Db2 exécutée sur votre machine locale. Pour plus d’informations, consultez [Connexion à votre instance de base de données Amazon RDS for Db2 avec IBM Db2 CLP](db2-connecting-with-clp-client.md).
**Topics**
+ [Octroi à un utilisateur l’accès à votre base de données](#db2-granting-user-access)
+ [Modification du mot de passe d’un utilisateur](#db2-changing-user-password)
+ [Ajout de groupes à un utilisateur](#db2-adding-group-to-user)
+ [Suppression des groupes d’un utilisateur](#db2-removing-groups-from-user)
+ [Suppression d’un utilisateur](#db2-removing-user)
+ [Affichage d’une liste d’utilisateurs](#db2-listing-users-database)
+ [Création d'un rôle](#db2-creating-role)
+ [Octroi d’un rôle](#db2-granting-role)
+ [Révocation d’un rôle](#db2-revoking-role)
+ [Suppression d’un rôle](#db2-dropping-role)
+ [Octroi des autorisations de base de donnée](#db2-granting-dbadmin-auth)
+ [Révocation de l’autorisation de base de données](#db2-revoking-dbadmin-auth)
## Octroi à un utilisateur l’accès à votre base de données
**Pour accorder à un utilisateur l’accès à votre base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
Le résultat produit lors de l’exécution de cette commande est semblable à l’exemple suivant :
```
Database Connection Information
Database server = DB2/LINUXX8664 11.5.8.0
SQL authorization ID = ADMIN
Local database alias = RDSADMIN
```
1. Ajoutez un utilisateur à votre liste d’autorisation en appelant `rdsadmin.add_user`. Pour plus d’informations, consultez [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. (Facultatif) Ajoutez des groupes supplémentaires à l’utilisateur en appelant `rdsadmin.add_groups`. Pour plus d’informations, consultez [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
1. Vérifiez les autorisations dont dispose l’utilisateur. Dans l'exemple suivant, remplacez *rds\$1database\$1alias**master\$1user*, et *master\$1password* par vos propres informations. Remplacez également *username* par le nom d'utilisateur de l'utilisateur.
```
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"
```
Le résultat produit lors de l’exécution de cette commande est semblable à l’exemple suivant :
```
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. Accordez les rôles RDS for Db2 pour `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` et `ROLE_PROCEDURES` au groupe auquel vous avez ajouté l’utilisateur. Pour plus d’informations, consultez [Rôles par défaut d’Amazon RDS for Db2](db2-default-roles.md).
**Note**
Nous créons des instances de base de données RDS for Db2 en mode `RESTRICTIVE`. Par conséquent, les rôles RDS for Db2 `ROLE_NULLID_PACKAGES`, `ROLE_TABLESPACES` et `ROLE_PROCEDURES` accorde des privilèges d’exécution sur les packages `NULLID` pour IBM Db2 CLP et Dynamic SQL. Ces rôles accordent également des privilèges aux utilisateurs sur les tablespaces.
1. Connectez-vous à votre base de données Db2. Dans l'exemple suivant, remplacez *database\$1name**master\$1user*, et *master\$1password* par vos propres informations.
```
db2 connect to database_name user master_user using master_password
```
1. Accordez le rôle `ROLE_NULLED_PACKAGES` à un groupe. Dans l'exemple suivant, remplacez *group\$1name* par le nom du groupe auquel vous souhaitez ajouter le rôle.
```
db2 "grant role ROLE_NULLID_PACKAGES to group group_name"
```
1. Accordez le rôle `ROLE_TABLESPACES` au même groupe. Dans l'exemple suivant, remplacez *group\$1name* par le nom du groupe auquel vous souhaitez ajouter le rôle.
```
db2 "grant role ROLE_TABLESPACES to group group_name"
```
1. Accordez le rôle `ROLE_PROCEDURES` au même groupe. Dans l'exemple suivant, remplacez *group\$1name* par le nom du groupe auquel vous souhaitez ajouter le rôle.
```
db2 "grant role ROLE_PROCEDURES to group group_name"
```
1. Accordez les autorités `connect`, `bindadd`, `createtab` et `IMPLICIT_SCHEMA` au groupe auquel vous avez ajouté l’utilisateur. Dans l'exemple suivant, remplacez *group\$1name* par le nom du deuxième groupe auquel vous avez ajouté l'utilisateur.
```
db2 "grant usage on workload SYSDEFAULTUSERWORKLOAD to public"
db2 "grant connect, bindadd, createtab, implicit_schema on database to group group_name"
```
1. Répétez les étapes 4 à 6 pour chaque groupe supplémentaire auquel vous avez ajouté l’utilisateur.
1. Testez l’accès de l’utilisateur en vous connectant en tant qu’utilisateur, en créant une table, en insérant des valeurs dans la table et en renvoyant les données de la table. Dans l'exemple suivant, remplacez *rds\$1database\$1alias**username*, et *password* par le nom de la base de données ainsi que le nom d'utilisateur et le mot de passe de l'utilisateur.
```
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"
```
## Modification du mot de passe d’un utilisateur
**Pour modifier le mot de passe d’un utilisateur**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Modifiez le mot de passe en appelant `rdsadmin.change_password`. Pour plus d’informations, consultez [rdsadmin.change\$1password](db2-sp-granting-revoking-privileges.md#db2-sp-change-password).
```
db2 "call rdsadmin.change_password(
'username',
'new_password')"
```
## Ajout de groupes à un utilisateur
**Pour ajouter des groupes à un utilisateur**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Ajoutez des groupes à un utilisateur en appelant `rdsadmin.add_groups`. Pour plus d’informations, consultez [rdsadmin.add\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-add-groups).
```
db2 "call rdsadmin.add_groups(
'username',
'group_name,group_name')"
```
## Suppression des groupes d’un utilisateur
**Suppression de groupes d’un utilisateur**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Supprimez des groupes en appelant `rdsadmin.remove_groups`. Pour plus d’informations, consultez [rdsadmin.remove\$1groups](db2-sp-granting-revoking-privileges.md#db2-sp-remove-groups).
```
db2 "call rdsadmin.remove_groups(
'username',
'group_name,group_name')"
```
## Suppression d’un utilisateur
**Suppression d’un utilisateur de la liste d’autorisations**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Supprimez un utilisateur de votre liste d’autorisation en appelant `rdsadmin.remove_user`. Pour plus d’informations, consultez [rdsadmin.remove\$1user](db2-sp-granting-revoking-privileges.md#db2-sp-remove-user).
```
db2 "call rdsadmin.remove_user('username')"
```
## Affichage d’une liste d’utilisateurs
Pour afficher les utilisateurs sur une liste d’autorisation, appelez la procédure stockée `rdsadmin.list_users`. Pour plus d’informations, consultez [rdsadmin.list\$1users](db2-sp-granting-revoking-privileges.md#db2-sp-list-users).
```
db2 "call rdsadmin.list_users()"
```
## Création d'un rôle
Vous pouvez utiliser la procédure stockée [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role) pour créer un rôle.
**Création d’un rôle**
1. Connectez-vous à la base de données `rdsadmin`. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Configurez Db2 pour qu’il affiche le contenu.
```
db2 set serveroutput on
```
1. Créez un rôle. Pour plus d’informations, consultez [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'database_name',
'role_name')"
```
1. Configurez Db2 pour qu’il n’affiche le contenu.
```
db2 set serveroutput off
```
## Octroi d’un rôle
Vous pouvez utiliser la procédure stockée [rdsadmin.grant\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-grant-role) pour attribuer un rôle à un rôle, à un utilisateur ou à un groupe.
**Attribution d’un rôle**
1. Connectez-vous à la base de données `rdsadmin`. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Configurez Db2 pour qu’il affiche le contenu.
```
db2 set serveroutput on
```
1. Attribuez un rôle. Pour plus d’informations, consultez [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. Configurez Db2 pour qu’il n’affiche le contenu.
```
db2 set serveroutput off
```
## Révocation d’un rôle
Vous pouvez utiliser la procédure stockée [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role) pour révoquer un rôle d’un rôle, d’un utilisateur ou d’un groupe.
**Pour révoquer un rôle**
1. Connectez-vous à la base de données `rdsadmin`. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Révoquez un rôle. Pour plus d’informations, consultez [rdsadmin.revoke\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-revoke-role).
```
db2 "call rdsadmin.revoke_role(
?,
'database_name',
'role_name',
'grantee')"
```
## Suppression d’un rôle
Vous pouvez utiliser la procédure stockée [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role) pour supprimer un rôle.
**Pour supprimer un rôle**
1. Connectez-vous à la base de données `rdsadmin`. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Supprimez un rôle. Pour plus d’informations, consultez [rdsadmin.drop\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-drop-role).
```
db2 "call rdsadmin.drop_role(
?,
'database_name',
'role_name')"
```
## Octroi des autorisations de base de donnée
L’utilisateur principal, qui dispose de l’autorisation `DBADM`, peut octroyer l’autorisation `DBADM`, `ACCESSCTRL` ou `DATAACCESS` à un rôle, un utilisateur ou un groupe.
**Pour accorder des autorisations de base de donnée**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Accordez l’accès à un utilisateur en appelant `rdsadmin.dbadm_grant`. Pour plus d’informations, consultez [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'database_name,
'authorization',
'grantee')"
```
**Exemple de cas d’utilisation**
La procédure suivante explique comment créer un rôle, octroyer une autorisation `DBADM` au rôle, attribuer le rôle à un utilisateur et octroyer le rôle à un groupe.
****
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Créez un rôle appelé `PROD_ROLE` pour une base de données appelée `TESTDB`. Pour plus d’informations, consultez [rdsadmin.create\$1role](db2-sp-granting-revoking-privileges.md#db2-sp-create-role).
```
db2 "call rdsadmin.create_role(
'TESTDB',
'PROD_ROLE')"
```
1. Attribuez le rôle à un utilisateur appelé `PROD_USER`. Le `PROD_USER` reçoit l’autorisation d’attribuer des rôles. Pour plus d’informations, consultez [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. (Facultatif) Fournissez des autorisations ou des privilèges supplémentaires. L’exemple suivant octroie l’autorisation `DBADM` à un rôle nommé `PROD_ROLE` pour une base de données appelée`FUNDPROD`. Pour plus d’informations, consultez [rdsadmin.dbadm\$1grant](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-grant).
```
db2 "call rdsadmin.dbadm_grant(
?,
'FUNDPROD',
'DBADM',
'ROLE PROD_ROLE')"
```
1. Mettez fin à votre séance.
```
db2 terminate
```
1. Connectez-vous à la base de données `TESTDB` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to TESTDB user master_username using master_password
```
1. Ajoutez d’autres autorisations au rôle.
```
db2 "grant connect, implicit_schema on database to role PROD_ROLE"
```
1. Accordez le rôle `PROD_ROLE` à un groupe.
```
db2 "grant role PROD_ROLE to group PRODGRP"
```
Les utilisateurs appartenant au groupe `PRODGRP` peuvent désormais effectuer des actions telles que la connexion à la base de données `TESTDB`, la création de tables ou la création de schémas.
## Révocation de l’autorisation de base de données
L’utilisateur principal, qui dispose de l’autorisation `DBADM`, peut révoquer l’autorisation `DBADM`, `ACCESSCTRL` ou `DATAACCESS` d’un rôle, d’un utilisateur ou d’un groupe.
**Pour révoquer l’autorisation de base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Révoquez l’accès de l’utilisateur en appelant `rdsadmin.dbadm_revoke`. Pour plus d’informations, consultez [rdsadmin.dbadm\$1revoke](db2-sp-granting-revoking-privileges.md#db2-sp-dbadm-revoke).
```
db2 "call rdsadmin.dbadm_revoke(
?,
'database_name,
'authorization',
'grantee')"
```
# Connexion à l’instance de base de données RDS for Db2 distante
Suivez les étapes suivantes pour vous connecter à votre instance de base de données RDS for Db2 distante et exécutez les opérations `get snapshot`.
**Se connecter à l’instance de base de données RDS for Db2 distante**
1. Exécutez une session côté client IBM Db2 CLP. Pour plus d’informations sur le catalogage de votre instance de base de données RDS for Db2 et votre base de données, consultez [Connexion à votre instance de base de données Amazon RDS for Db2 avec IBM Db2 CLP](db2-connecting-with-clp-client.md). Notez le nom d’utilisateur principal et le mot de passe principal de votre instance de base de données RDS for Db2.
1. Connectez-vous à l’instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *node\$1name**master\$1username*, et *master\$1password* par le nom du nœud TCP/IP que vous avez catalogué ainsi que le nom d'utilisateur principal et le mot de passe principal de votre instance de base de données RDS pour DB2.
```
db2 attach to node_name user master_username using master_password
```
Après vous être connecté à l’instance de base de données RDS for Db2 distante, vous pouvez exécuter les commandes suivantes et d’autres commandes `get snapshot`. Pour plus d’informations, consultez [Commande GET SNAPSHOT](https://www.ibm.com/docs/en/db2/11.5?topic=commands-get-snapshot) dans la documentation IBM Db2.
```
db2 list applications
db2 get snapshot for all databases
db2 get snapshot for database manager
db2 get snapshot for all applications
```
# Exécution des tâches de base de données courantes pour les instances de base de données RDS for Db2
Vous pouvez effectuer certaines tâches DBA courantes liées aux bases de données sur vos instances de base de données Amazon RDS for Db2. Pour offrir une expérience de service géré, Amazon RDS ne fournit pas l'accès shell aux instances de base de données. En outre, l’utilisateur principal ne peut pas exécuter de commandes ou d’utilitaires nécessitant les autorisations `SYSADM`, `SYSMAINT` ou `SYSCTRL`.
Pour plus d’informations sur les tâches courantes relatives aux groupes de mémoires tampons, aux bases de données et aux tablespaces, consultez les rubriques suivantes.
**Rubriques**
+ [Tâches courantes pour les pools de mémoires tampons](db2-managing-buffer-pools.md)
+ [Tâches courantes pour les bases de données](db2-managing-databases.md)
+ [Tâches courantes pour les tablespaces](db2-managing-tablespaces.md)
# Tâches courantes pour les pools de mémoires tampons
Vous pouvez créer, modifier ou supprimer des pools de mémoires tampons pour votre base de données RDS for Db2. La création, la modification ou la suppression de pools de mémoires tampons nécessitent une autorité `SYSADM` ou `SYSCTRL` de niveau supérieur, qui n’est pas disponible pour l’utilisateur principal. Utilisez plutôt les procédures stockées Amazon RDS.
Vous pouvez également vider les pools de mémoires tampons.
**Topics**
+ [Création d’un pool de mémoires tampons](#db2-creating-buffer-pool)
+ [Modification d’un pool de mémoires tampons](#db2-altering-buffer-pool)
+ [Suppression d’un pool de mémoires tampons](#db2-dropping-buffer-pool)
+ [Vidage des pools de mémoires tampons](#db2-flushing-buffer-pools)
## Création d’un pool de mémoires tampons
Pour créer un pool de mémoires tampons pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.create_bufferpool`. Pour plus d’informations, consultez [Instruction CREATE BUFFERPOOL](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-bufferpool) dans la documentation IBM Db2.
**Pour créer un pool de mémoires tampons**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l’exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Créez un pool de mémoires tampons en appelant `rdsadmin.create_bufferpool`. Pour plus d’informations, consultez [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)"
```
## Modification d’un pool de mémoires tampons
Pour modifier un pool de mémoires tampons pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.alter_bufferpool`. Pour plus d’informations, consultez [Instruction ALTER BUFFERPOOL](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-bufferpool) dans la documentation IBM Db2.
**Pour modifier un pool de mémoires tampons**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l’exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Modifiez un pool de mémoires tampons en appelant `rdsadmin.alter_bufferpool`. Pour plus d’informations, consultez [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)"
```
## Suppression d’un pool de mémoires tampons
Pour supprimer un pool de mémoires tampons pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.drop_bufferpool`. Pour plus d’informations, consultez [Suppression de pools de mémoires tampons](https://www.ibm.com/docs/en/db2/11.5?topic=pools-dropping-buffer) dans la documentation IBM Db2.
**Important**
Assurez-vous qu’aucun tablespace n’est attribué au pool de mémoires tampons que vous souhaitez supprimer.
**Pour supprimer un pool de mémoires tampons**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l’exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Supprimez un pool de mémoires tampons en appelant `rdsadmin.drop_bufferpool`. Pour plus d’informations, consultez [rdsadmin.drop\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-drop-buffer-pool).
```
db2 "call rdsadmin.drop_bufferpool(
'database_name',
'buffer_pool_name')"
```
## Vidage des pools de mémoires tampons
Vous pouvez vider les pools de mémoires tampons pour forcer un point de contrôle afin que RDS for Db2 enregistre des pages de la mémoire vers le stockage.
**Note**
Vous n’avez pas besoin de vider les pools de mémoires tampons. Db2 écrit les journaux de manière synchrone avant de valider les transactions. Les pages de modification se trouvent peut-être toujours dans un pool de mémoires tampons, mais Db2 les écrit dans le stockage de manière asynchrone. Même si le système s’arrête de façon inattendue, lorsque vous redémarrez la base de données, Db2 effectue automatiquement une récupération sur incident. Lors de la récupération sur incident, Db2 écrit les modifications validées dans la base de données ou annule les modifications pour les transactions non validées.
**Pour vider les pools de mémoires tampons**
1. Connectez-vous à votre base de données Db2 à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l’exemple suivant, remplacez *rds\$1database\$1alias*, *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Videz les pools de mémoires tampons.
```
db2 flush bufferpools all
```
# Tâches courantes pour les bases de données
Vous pouvez créer, supprimer ou restaurer des bases de données sur votre instance de base de données RDS for Db2. La création, la suppression ou la restauration de bases de données nécessitent une autorité `SYSADM` de niveau supérieur, qui n’est pas disponible pour l’utilisateur principal. Utilisez plutôt les procédures stockées Amazon RDS.
Vous pouvez également effectuer des tâches de gestion courantes telles que la surveillance, la maintenance et la collecte d’informations sur vos bases de données.
**Topics**
+ [Création d’une base de données](#db2-creating-database)
+ [Configuration des paramètres d’une base de données](#db2-configuring-database)
+ [Modification des paramètres de base de données](#db2-modifying-db-parameters)
+ [Configuration de la conservation des journaux](#db2-configuring-log-retention)
+ [Liste d’informations sur le journal](#db2-listing-log-information)
+ [Utilisation d'un contrôle d'accès précis (FGAC)](#db2-using-fine-grained-access-control)
+ [Désactivation d’une base de données](#db2-deactivating-database)
+ [Activation d’une base de données](#db2-activating-database)
+ [Réactivation d’une base de données](#db2-reactivating-database)
+ [Suppression d’une base de données.](#db2-dropping-database)
+ [Sauvegarde d'une base de données](#db2-backing-up-database)
+ [Copie des journaux d'archives vers Amazon S3](#db2-copying-archive-logs-to-s3)
+ [Restauration d'une base de données](#db2-restoring-database)
+ [Liste des bases de données](#db2-listing-databases)
+ [Collecte d’informations sur les bases de données](#db2-collecting-info-db)
+ [Forcer les applications à quitter les bases de données](#db2-forcing-application-off-db)
+ [Génération de rapports de performance](#db2-generating-performance-reports)
## Création d’une base de données
Pour créer une base de données pour votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.create_database`. Pour plus d’informations, consultez [Commande CREATE DATABASE](https://www.ibm.com/docs/en/db2/11.5?topic=commands-create-database) dans la documentation IBM Db2.
**Note**
Si vous envisagez de modifier le paramètre `db2_compatibility_vector`, modifiez-le avant de créer une base de données. Pour plus d’informations, consultez [Définition du paramètre db2\$1compatibility\$1vector](db2-known-issues-limitations.md#db2-known-issues-limitations-db2-compatibility-vector).
**Pour créer une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Créez une base de données en appelant `rdsadmin.create_database`. Pour plus d’informations, consultez [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. (Facultatif) Créez des bases de données supplémentaires en appelant `rdsadmin.create_database` pour chaque base de données que vous souhaitez créer. Chaque instance de base de données Db2 peut contenir jusqu’à 50 bases de données. Pour plus d’informations, consultez [rdsadmin.create\$1database](db2-sp-managing-databases.md#db2-sp-create-database).
```
db2 "call rdsadmin.create_database('database_name')"
```
1. (Facultatif) Vérifiez que votre base de données a été créée en utilisant l’une des méthodes suivantes :
+ Appelez `rdsadmin.list_databases`. Pour plus d’informations, consultez [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
+ Exécutez la commande SQL suivante :
```
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"
```
## Configuration des paramètres d’une base de données
Pour créer les paramètres d’une base de données sur votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.set_configuration`. Par exemple, vous pouvez configurer le nombre de mémoires tampons ou de manipulateurs de mémoire tampon à créer lors d’une opération de restauration.
**Pour configurer les paramètres d’une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facultatif) Vérifiez vos paramètres de configuration actuels en appelant `rdsadmin.show_configuration`. Pour plus d’informations, consultez [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Configurez les paramètres de la base de données en appelant `rdsadmin.set_configuration`. Pour plus d’informations, consultez [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
## Modification des paramètres de base de données
Amazon RDS for Db2 utilise trois types de paramètres : les paramètres de configuration du gestionnaire de base de données, les variables de registre et les paramètres de configuration de base de données. Vous pouvez mettre à jour les deux premiers types par le biais de groupes de paramètres et le dernier par le biais de la procédure stockée [rdsadmin.update\$1db\$1param](db2-sp-managing-databases.md#db2-sp-update-db-param).
**Note**
Vous ne pouvez modifier que les valeurs des paramètres existants. Vous ne pouvez pas ajouter de nouveaux paramètres que RDS for Db2 ne prend pas en charge.
Pour plus d’informations sur ces paramètres et sur la façon de modifier leurs valeurs, consultez [Paramètres Amazon RDS for Db2](db2-supported-parameters.md).
## Configuration de la conservation des journaux
Pour configurer la durée pendant laquelle Amazon RDS conserve les fichiers journaux de votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.set_archive_log_retention`.
**Configuration de la conservation des journaux pour une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facultatif) Vérifiez votre configuration actuelle pour la conservation des journaux en appelant `rdsadmin.show_archive_log_retention`. Pour plus d’informations, consultez [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. Configurez la conservation des journaux pour la base de données en appelant `rdsadmin.set_archive_log_retention`. Pour plus d’informations, consultez [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')"
```
## Liste d’informations sur le journal
Pour établir la liste des informations relatives aux fichiers journaux d’archivage, y compris des informations telles que la taille totale de stockage utilisée, appelez la procédure stockée `rdsadmin.list_archive_log_information`.
**Création de la liste des informations sur le journal d’une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Renvoyez une liste d’informations sur le fichier journal en appelant `rdsadmin.list_archive_log_information`. Pour de plus amples informations, veuillez consulter [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')"
```
## Utilisation d'un contrôle d'accès précis (FGAC)
Pour utiliser des commandes de contrôle d'accès détaillées afin de contrôler l'accès aux données de table d'une base de données sur une instance de base de données RDS pour DB2, appelez la procédure stockée. `rdsadmin.fgac_command` Vous pouvez utiliser le FGAC pour limiter l'accès aux données en fonction des rôles des utilisateurs ou des attributs des données. Par exemple, vous pouvez limiter l'accès aux données de santé des patients en fonction du type de données ou à certains prestataires de soins médicaux.
**Pour utiliser un contrôle d'accès précis pour contrôler l'accès aux données des tables dans une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Exécutez diverses commandes de contrôle d'accès détaillées en appelant. `rdsadmin.fgac_command` Pour de plus amples informations, veuillez consulter [rdsadmin.fgac\$1commandParameters](db2-sp-managing-databases.md#db2-sp-fgac-command).
```
db2 "call rdsadmin.fgac_command(
?,
'database_name',
'fgac_command')"
```
## Désactivation d’une base de données
Pour désactiver une base de données sur votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.deactivate_database`.
Par défaut, Amazon RDS active une base de données lorsque vous créez une base de données sur votre instance de base de données RDS for Db2. Vous pouvez désactiver les bases de données peu utilisées pour économiser les ressources de mémoire.
**Pour désactiver une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Désactivez une base de données en appelant `rdsadmin.deactivate_database`. Pour plus d’informations, consultez [rdsadmin.deactivate\$1database](db2-sp-managing-databases.md#db2-sp-deactivate-database).
```
db2 "call rdsadmin.deactivate_database(
?,
'database_name')"
```
## Activation d’une base de données
Pour activer une base de données sur une instance de base de données RDS for Db2 autonome, appelez la procédure stockée `rdsadmin.activate_database`.
Par défaut, Amazon RDS active une base de données lorsque vous créez une base de données sur votre instance de base de données RDS for Db2. Vous pouvez désactiver les bases de données peu utilisées pour économiser les ressources de mémoire, puis activer ultérieurement une base de données désactivée.
**Pour activer une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Activez une base de données en appelant `rdsadmin.activate_database`. Pour plus d’informations, consultez [rdsadmin.activate\$1database](db2-sp-managing-databases.md#db2-sp-activate-database).
```
db2 "call rdsadmin.activate_database(
?,
'database_name')"
```
## Réactivation d’une base de données
Pour réactiver une base de données sur une instance de base de données RDS for Db2 source de réplica, vous devez appeler la procédure stockée `rdsadmin.reactivate_database`. Après avoir modifié les configurations des bases de données, vous devrez peut-être réactiver une base de données sur une instance de base de données RDS for Db2. Pour déterminer si vous devez réactiver une base de données, connectez-vous à la base de données et exécutez `db2 get db cfg show detail`.
Vous pouvez également appeler cette procédure stockée pour réactiver une base de données sur une instance de base de données RDS for Db2 autonome après avoir modifié les configurations de base de données. Vous pouvez également réactiver une base de données sur une instance de base de données RDS for Db2 autonome en appelant d’abord la procédure stockée `rdsadmin.deactivate_database`, puis la procédure stockée `rdsadmin.activate_database`. Pour plus d’informations, consultez [Désactivation d’une base de données](#db2-deactivating-database) et [Activation d’une base de données](#db2-activating-database).
**Pour réactiver une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Réactivez une base de données en appelant `rdsadmin.reactivate_database`. Pour plus d’informations, consultez [rdsadmin.reactivate\$1database](db2-sp-managing-databases.md#db2-sp-reactivate-database).
```
db2 "call rdsadmin.reactivate_database(
?,
'database_name')"
```
## Suppression d’une base de données.
Pour supprimer une base de données de votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.drop_database`. Pour plus d’informations, consultez [Suppression de bases de données](https://www.ibm.com/docs/en/db2/11.5?topic=databases-dropping) dans la documentation IBM Db2.
**Note**
Vous ne pouvez supprimer une base de données en appelant la procédure stockée que si certaines conditions sont réunies. Pour plus d’informations, consultez [Notes d’utilisation](db2-sp-managing-databases.md#db2-sp-drop-database-usage-notes) pour `rdsadmin.drop_database`.
**Suppression d’une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Supprimez une base de données en appelant `rdsadmin.drop_database`. Pour de plus amples informations, veuillez consulter [rdsadmin.drop\$1database](db2-sp-managing-databases.md#db2-sp-drop-database).
```
db2 "call rdsadmin.drop_database('database_name')"
```
## Sauvegarde d'une base de données
Pour sauvegarder une base de données de votre instance de base de données RDS pour DB2 sur Amazon S3, appelez la procédure `rdsadmin.backup_database` stockée. Pour plus d'informations, consultez la [commande BACKUP DATABASE](https://www.ibm.com/docs/en/db2/11.5.x?topic=commands-backup-database) dans la IBM Db2 documentation.
**Note**
Cette procédure stockée utilise l'intégration avec Amazon S3. Assurez-vous d'avoir configuré l'intégration avant de continuer. Pour de plus amples informations, veuillez consulter [Intégration d’une instance de base de données Amazon RDS for Db2 avec Amazon S3](db2-s3-integration.md).
**Pour sauvegarder une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Créez un point de terminaison de passerelle VPC pour S3. Si vous disposez déjà d'un point de terminaison de passerelle VPC pour S3, passez à l'étape 4.
Pour qu'une instance de base de données RDS for Db2 puisse interagir avec Amazon S3, vous devez disposer d'un VPC et d'un point de terminaison de passerelle Amazon S3 que les sous-réseaux privés peuvent utiliser. Pour de plus amples informations, veuillez consulter [Étape 1 : création d’un point de terminaison de passerelle VPC pour Amazon S3](db2-troubleshooting.md#db2-creating-endpoint).
1. Confirmez le point de terminaison de la passerelle VPC pour S3. Pour de plus amples informations, veuillez consulter [Étape 2 : vérification de l’existence du point de terminaison de votre passerelle VPC pour Amazon S3 existe](db2-troubleshooting.md#db2-confirming-endpoint).
1. Sauvegardez une base de données en appelant`rdsadmin.backup_database`. Pour de plus amples informations, veuillez consulter [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. Résiliez votre connexion.
```
terminate
```
1. (Facultatif) Vérifiez que les fichiers de sauvegarde ont été chargés dans votre compartiment Amazon S3 sous*s3\$1prefix/dbi\$1resource\$1id/db\$1name*. Si les fichiers n'apparaissent pas sur*s3\$1prefix/dbi\$1resource\$1id/db\$1name*, vérifiez l'état de la sauvegarde de votre base de données pour identifier les éventuels problèmes. Pour de plus amples informations, veuillez consulter [rdsadmin.get\$1task\$1status](db2-user-defined-functions.md#db2-udf-get-task-status). Si vous ne parvenez pas à résoudre les problèmes identifiés, contactez le [AWS Support](https://aws.amazon.com/premiumsupport/).
1. (Facultatif) Une fois la sauvegarde sur Amazon S3 terminée, vous pouvez restaurer la sauvegarde sur une instance de base de données RDS pour DB2 ou sur un autre emplacement tel qu'un serveur local. Pour plus d'informations sur la restauration vers une instance de base de données RDS pour DB2, consultez. [Restauration d'une base de données](#db2-restoring-database)
## Copie des journaux d'archives vers Amazon S3
Les journaux d'archive DB2 peuvent désormais être copiés depuis votre instance de base de données RDS pour DB2 vers Amazon S3. Les journaux d'archivage combinés à la sauvegarde native créée à l'aide `rdsadmin.backup_database` peuvent être utilisés pour restaurer et faire avancer la base de données à un moment précis sur une autre instance RDS pour Db2 ou une base de données EC2.
Avant de configurer cette fonctionnalité, utilisez la procédure stockée `rdsadmin.backup_database` pour configurer RDS pour la base de données DB2.
Cette fonctionnalité fonctionne au niveau de l'instance de base de données RDS pour DB2, bien que la copie des journaux d'archives puisse être activée ou désactivée par base de données.
**Pour configurer la copie du journal d'archives vers Amazon S3**
1. Connectez-vous à la `rdsadmin` base de données à l'aide du nom d'utilisateur principal et du mot de passe principal de votre instance de base de données RDS pour DB2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Configurez la sauvegarde du journal des archives sur S3 en appelant[rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
**Exemple :**
```
db2 "call rdsadmin.set_configuration('ARCHIVE_LOG_COPY_TARGET_S3_ARN', 'arn:aws:s3:::my_rds_db2_backups/archive-log-copy/')"
```
1. Activez la copie du journal d'archivage pour une base de données en appelant`rdsadmin.enable_archive_log_copy`. Remplacez *database\$1name* par le nom de votre base de données.
```
db2 "call rdsadmin.enable_archive_log_copy(?, 'database_name')"
```
1. De même, pour désactiver la copie du journal des archives d'une base de données, appelez`rdsadmin.disable_archive_log_copy`.
```
db2 "call rdsadmin.disable_archive_log_copy(?, 'database_name')"
```
1. Confirmez l'état de copie du journal d'archivage en appelant`rdsadmin.list_databases`.
```
db2 "select * from table(rdsadmin.list_databases())"
```
**Exemple de sortie** :
```
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 - - -
...
```
## Restauration d'une base de données
Pour déplacer une base de données d’un compartiment Amazon S3 vers votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.restore_database`. Pour plus d’informations, consultez [Commande RESTORE DATABASE](https://www.ibm.com/docs/en/db2/11.5?topic=commands-restore-database) dans la documentation IBM Db2.
**Pour restaurer une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. (Facultatif) Vérifiez vos paramètres de configuration actuels pour optimiser l’opération de restauration en appelant `rdsadmin.show_configuration`. Pour plus d’informations, consultez [rdsadmin.show\$1configuration](db2-sp-managing-databases.md#db2-sp-show-configuration).
```
db2 "call rdsadmin.show_configuration('name')"
```
1. Configurez les paramètres pour optimiser l’opération de restauration en appelant `rdsadmin.set_configuration`. La définition explicite de ces valeurs peut améliorer les performances lors de la restauration de bases de données contenant de gros volumes de données. Pour plus d’informations, consultez [rdsadmin.set\$1configuration](db2-sp-managing-databases.md#db2-sp-set-configuration).
```
db2 "call rdsadmin.set_configuration(
'name',
'value')"
```
1. Restaurez la base de données en appelant `rdsadmin.restore_database`. Pour plus d’informations, consultez [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. (Facultatif) Vérifiez que votre base de données a été restaurée en appelant `rdsadmin.list_databases` et en vérifiant que la base de données restaurée est répertoriée. Pour plus d’informations, consultez [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
1. Remettez la base de données en ligne et appliquez des journaux de transactions supplémentaires en appelant `rdsadmin.rollforward_database`. Pour plus d’informations, consultez [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. (Facultatif) Vérifiez l’état de la procédure stockée `rdsadmin.rollforward_database` en appelant la procédure stockée [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
1. Si vous avez défini `complete_rollforward` sur `FALSE` à l’étape précédente, vous devez terminer de remettre la base de données en ligne en appelant `rdsadmin.complete_rollforward`. Pour plus d’informations, consultez [rdsadmin.complete\$1rollforward](db2-sp-managing-databases.md#db2-sp-complete-rollforward).
```
db2 "call rdsadmin.complete_rollforward(
?,
'database_name')"
```
1. (Facultatif) Vérifiez l’état de la procédure stockée `rdsadmin.complete_rollforward` en appelant la procédure stockée [rdsadmin.rollforward\$1status](db2-sp-managing-databases.md#db2-sp-rollforward-status).
## Liste des bases de données
Vous pouvez établir la liste de toutes vos bases de données exécutées sur Amazon RDS for Db2 en appelant la fonction définie par l’utilisateur `rdsadmin.list_databases`.
**Création de la liste de vos bases de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Établissez la liste de vos bases de données en appelant `rdsadmin.list_databases`. Pour plus d’informations, consultez [rdsadmin.list\$1databases](db2-user-defined-functions.md#db2-udf-list-databases).
```
db2 "select * from table(rdsadmin.list_databases())"
```
## Collecte d’informations sur les bases de données
Pour collecter des informations sur une base de données sur une instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.db2pd_command`. Ces informations peuvent vous aider à surveiller vos bases de données ou à résoudre les problèmes.
**Collecte des informations sur une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Collectez des informations sur la base de données en appelant `rdsadmin.db2pd_command`. Pour plus d’informations, consultez [rdsadmin.db2pd\$1command](db2-sp-managing-databases.md#db2-sp-db2pd-command).
```
db2 "call rdsadmin.db2pd_command('db2pd_cmd')"
```
## Forcer les applications à quitter les bases de données
Pour forcer les application à quitter une base de données sur votre instance de base de données RDS for Db2, appelez la procédure stockée `rdsadmin.force_application`. Avant de procéder à la maintenance de vos bases de données, forcez les applications à quitter vos bases de données.
**Forcer les applications à quitter une base de données**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Forcez les applications à quitter une base de données en appelant `rdsadmin.force_application`. Pour plus d’informations, consultez [rdsadmin.force\$1application](db2-sp-managing-databases.md#db2-sp-force-application).
```
db2 "call rdsadmin.force_application(
?,
'applications')"
```
## Génération de rapports de performance
Vous pouvez générer des rapports de performance à l’aide d’une procédure ou d’un script. Pour plus d’informations sur l’utilisation d’une procédure, consultez [Procédure DBSUMMARY ‐ Générer un rapport récapitulatif des mesures de performance du système et de l’application](https://www.ibm.com/docs/en/db2/11.5?topic=mm-dbsummary-procedure-generate-summary-report-system-application-performance-metrics) dans la documentation IBM Db2.
Db2 inclut un fichier `db2mon.sh` dans son annuaire `~sqllib/sample/perf`. L’exécution du script produit un rapport détaillé et peu coûteux sur les mesures SQL. Pour télécharger le fichier `db2mon.sh` et les fichiers de script associés, consultez l’annuaire [https://github.com/IBM/db2-samples/tree/master/perf](https://github.com/IBM/db2-samples/tree/master/perf) dans le référentiel IBM db2-samples GitHub.
**Génération des rapports de performance à l’aide du script**
1. Connectez-vous à votre base de données Db2 à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 connect to rdsadmin user master_username using master_password
```
1. Créez un groupe de mémoires tampons nommé `db2monbp` avec une taille de page de 4096 en appelant `rdsadmin.create_bufferpool`. Pour plus d’informations, consultez [rdsadmin.create\$1bufferpool](db2-sp-managing-buffer-pools.md#db2-sp-create-buffer-pool).
```
db2 "call rdsadmin.create_bufferpool('database_name','db2monbp',4096)"
```
1. Créez un tablespace temporaire nommé `db2montmptbsp` qui utilise le groupe de mémoires tampons `db2monbp` en appelant `rdsadmin.create_tablespace`. Pour plus d’informations, consultez [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. Ouvrez le script `db2mon.sh` et modifiez la ligne concernant la connexion à une base de données.
1. Supprimez la ligne suivante.
```
db2 -v connect to $dbName
```
1. Remplacez la ligne de l’étape précédente par la ligne suivante. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par le nom d'utilisateur principal et le mot de passe principal de votre instance de base de données RDS pour DB2.
```
db2 -v connect to $dbName user master_username using master_password
```
1. Supprimez les lignes suivantes.
```
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. Exécutez le script `db2mon.sh` pour générer un rapport à des intervalles spécifiés. Dans l'exemple suivant, remplacez *absolute\$1path* par le chemin complet du fichier de script, *rds\$1database\$1alias* par le nom de votre base de données et *seconds* par le nombre de secondes (0 à 3 600) entre la génération du rapport.
```
absolute_path/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
**Exemples**
L’exemple suivant montre que le fichier de script se trouve dans l’annuaire `perf` situé sous l’annuaire `home`.
```
/home/db2inst1/sqllib/samples/perf/db2mon.sh rds_database_alias seconds | tee -a db2mon.out
```
1. Supprimez le groupe de mémoires tampons et le tablespace créés pour le fichier `db2mon.sh`. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par le nom d'utilisateur principal et le mot de passe principal de votre instance de base de données RDS pour DB2. Remplacez *database\$1name* par le nom de votre base de données. Pour plus d'informations, consultez [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace) et [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')"
```
## Gestion du stockage
Db2 utilise le stockage automatique pour gérer le stockage physique des objets de base de données tels que les tables, les index et les fichiers temporaires. Au lieu d’allouer manuellement de l’espace de stockage et de suivre les chemins de stockage utilisés, le stockage automatique permet au système Db2 de créer et de gérer les chemins de stockage selon les besoins. Cela peut simplifier l’administration des bases de données Db2 et réduire le risque d’erreurs dues à des erreurs humaines. Pour plus d’informations, consultez [Stockage automatique](https://www.ibm.com/docs/en/db2/11.5?topic=overview-automatic-storage) dans la documentation IBM Db2.
Avec RDS for Db2, vous pouvez augmenter dynamiquement la taille de stockage grâce à l’extension automatique des volumes logiques et du système de fichiers. Pour de plus amples informations, veuillez consulter [Utilisation du stockage pour les instances de base de données Amazon RDS](USER_PIOPS.StorageTypes.md).
# Tâches courantes pour les tablespaces
Vous pouvez créer, modifier, renommer ou supprimer des tablespaces pour une base de données RDS for Db2. La création, la modification, le changement de nom ou la suppression de tablespaces nécessitent une autorité `SYSADM` de niveau supérieur, qui n’est pas disponible pour l’utilisateur principal. Utilisez plutôt les procédures stockées Amazon RDS.
**Topics**
+ [Création d’un tablespace](#db2-creating-tablespace)
+ [Modification d’un tablespace](#db2-altering-tablespace)
+ [Changement de nom d’un tablespace](#db2-renaming-tablespace)
+ [Suppression d’un tablespace](#db2-dropping-tablespace)
+ [Vérification du statut d’un tablespace](#db2-checking-tablespaces-procedure)
+ [Renvoi d’informations détaillées sur les tablespaces](#db2-tablespaces-info-db2pd)
+ [Liste de l’état et du groupe de stockage d’un tablespace](#db2-state-storage-group-tablespace-sql)
+ [Liste des tablespaces d’une table](#db2-return-tablespaces-sql)
+ [Liste des conteneurs de tablespaces](#db2-listing-tablespace-containers)
## Création d’un tablespace
Pour créer un tablespace pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.create_tablespace`. Pour plus d’informations, consultez [Instruction CREATE TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-create-tablespace) dans la documentation IBM Db2.
**Important**
Pour créer un tablespace vous devez disposer d’un groupe de mémoires tampons de même taille de page à associer au tablespace. Pour plus d’informations, consultez [Tâches courantes pour les pools de mémoires tampons](db2-managing-buffer-pools.md).
**Pour créer un tablespace**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Créez un tablespace en appelant `rdsadmin.create_tablespace`. Pour plus d’informations, consultez [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')"
```
## Modification d’un tablespace
Pour modifier un tablespace pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.alter_tablespace`. Vous pouvez utiliser cette procédure stockée pour modifier le groupe de mémoires tampons d’un tablespace, abaisser la limite maximale ou mettre un tablespace en ligne. Pour plus d’informations, consultez [Instruction ALTER TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-alter-tablespace) dans la documentation IBM Db2.
**Pour modifier un tablespace**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Modifiez un tablespace en appelant `rdsadmin.alter_tablespace`. Pour plus d’informations, consultez [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')"
```
## Changement de nom d’un tablespace
Pour changer le nom d’un tablespace pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.rename_tablespace`. Pour plus d’informations, consultez [Instruction RENAME TABLESPACE](https://www.ibm.com/docs/en/db2/11.5?topic=statements-rename-tablespace) dans la documentation IBM Db2.
**Modification du nom d’un tablespace**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Renommez un tablespace en appelant `rdsadmin.rename_tablespace`. Pour plus d’informations, y compris les restrictions relatives au nom que vous pouvez donner à un tablespace, consultez [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')"
```
## Suppression d’un tablespace
Pour supprimer un tablespace pour votre base de données RDS for Db2, appelez la procédure stockée `rdsadmin.drop_tablespace`. Avant de supprimer un espace disque logique, supprimez d'abord tous les objets qu'il contient, tels que des tables, des index ou des objets volumineux (). LOBs Pour plus d’informations, consultez [Suppression de tablespaces](https://www.ibm.com/docs/en/db2/11.5?topic=spaces-dropping-table) dans la documentation IBM Db2.
**Pour supprimer un tablespace**
1. Connectez-vous à la base de données `rdsadmin` à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *master\$1username* et *master\$1password* par vos propres informations.
```
db2 "connect to rdsadmin user master_username using master_password"
```
1. Supprimez un tablespace en appelant `rdsadmin.drop_tablespace`. Pour plus d’informations, consultez [rdsadmin.drop\$1tablespace](db2-sp-managing-tablespaces.md#db2-sp-drop-tablespace).
```
db2 "call rdsadmin.drop_tablespace(
'database_name',
'tablespace_name')"
```
## Vérification du statut d’un tablespace
Vous pouvez vérifier le statut d’un tablespace en utilisant la fonction `cast`.
**Pour vérifier le statut d’un tablespace**
1. Connectez-vous à votre base de données Db2 à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *rds\$1database\$1alias**master\$1username*, et *master\$1password* par vos propres informations.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Renvoyez une sortie récapitulative.
Pour une sortie récapitulative :
```
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"
```
## Renvoi d’informations détaillées sur les tablespaces
Vous pouvez renvoyer des informations sur un tablespace pour un membre ou pour tous les membres à l’aide de la fonction `cast`.
**Pour renvoyer des informations détaillées sur les tablespaces**
1. Connectez-vous à votre base de données Db2 à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *rds\$1database\$1alias**master\$1username*, et *master\$1password* par vos propres informations.
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Renvoyez des informations sur tous les tablespaces de la base de données pour un membre ou pour tous les membres.
Pour un membre :
```
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 "
```
Pour tous les membres :
```
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 "
```
## Liste de l’état et du groupe de stockage d’un tablespace
Vous pouvez répertorier l’état et le groupe de stockage d’un tablespace en exécutant une instruction SQL.
Pour répertorier l’état et le groupe de stockage d’un tablespace, exécutez l’instruction SQL suivante :
```
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"
```
## Liste des tablespaces d’une table
Vous pouvez répertorier les tablespaces d’une table en exécutant une instruction SQL.
Pour répertorier les tablespaces d’une table, exécutez l’instruction SQL suivante. Dans l'exemple suivant, remplacez *SCHEMA\$1NAME* et par *TABLE\$1NAME* les noms de votre schéma et de votre table :
```
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'"
```
## Liste des conteneurs de tablespaces
Vous pouvez répertorier tous les conteneurs de tablespaces ou des conteneurs de tablespaces spécifiques à l’aide de la commande `cast`.
**Création de la liste des conteneurs d’un tablespace**
1. Connectez-vous à votre base de données Db2 à l’aide du nom d’utilisateur principal et du mot de passe principal de votre instance de base de données RDS for Db2. Dans l'exemple suivant, remplacez *rds\$1database\$1alias**master\$1username*, et *master\$1password* par vos propres informations :
```
db2 connect to rds_database_alias user master_username using master_password
```
1. Renvoyez une liste de tous les conteneurs de tablespaces de la base de données ou de conteneurs de tablespaces spécifiques.
Pour tous les conteneurs de tablespaces :
```
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"
```
Pour des conteneurs de tablespaces spécifiques :
```
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"
```