";
public static void main(String[] args) throws SQLException {
final Properties properties = new Properties();
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))",
DB_SERVER_NAME, SSL_PORT, DB_SID);
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
properties.put("oracle.jdbc.J2EE13Compliant", "true");
properties.put("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
properties.put("javax.net.ssl.trustStoreType", "JKS");
properties.put("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
final Connection connection = DriverManager.getConnection(connectionString, properties);
// If no exception, that means handshake has passed, and an SSL connection can be opened
}
}
```
**Importante**
Dopo aver stabilito che le connessioni al database utilizzano SSL/TLS e aver aggiornato l'archivio attendibile delle applicazioni, è possibile aggiornare il database per utilizzare i certificati rds-ca-rsa 2048-g1. Per istruzioni, consulta la fase 3 in [Aggiornamento del certificato CA modificando l’istanza database o il cluster di database](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-updating).
# Utilizzo di native network encryption con un'istanza database RDS per Oracle
Oracle Database offre due modi per crittografare i dati sulla rete: native network encryption (NNE) e Transport Layer Security (TLS). NNE è una funzionalità di sicurezza di proprietà di Oracle, mentre TLS è uno standard di settore. RDS per Oracle supporta NNE per tutte le edizioni di Oracle Database.
NNE ha i vantaggi seguenti rispetto a TLS:
+ È possibile controllare NNE sul client e sul server utilizzando le impostazioni dell'opzione NNE:
+ `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` e `SQLNET.ALLOW_WEAK_CRYPTO`
+ `SQLNET.CRYPTO_CHECKSUM_CLIENT` e `SQLNET.CRYPTO_CHECKSUM_SERVER`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` e `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER`
+ `SQLNET.ENCRYPTION_CLIENT` e `SQLNET.ENCRYPTION_SERVER`
+ `SQLNET.ENCRYPTION_TYPES_CLIENT` e `SQLNET.ENCRYPTION_TYPES_SERVER`
+ Nella maggior parte dei casi, non devi configurare il client o il server. TLS richiede invece una configurazione sia del client che del server.
+ Non sono richiesti certificati. In TLS, il server richiede un certificato (che alla fine scade) e il client richiede un certificato root attendibile per l'autorità di certificazione che ha emesso il certificato del server.
Puoi abilitare la crittografia NNE per un'istanza database Oracle aggiungendo l'opzione Oracle NNE al gruppo di opzioni associato all'istanza database. Per ulteriori informazioni, consulta [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md).
**Nota**
È possibile utilizzare NNE e TLS sulla stessa istanza database.
# Configurazione dell'autenticazione Kerberos per Amazon RDS for Oracle
Puoi utilizzare l'autenticazione Kerberos per autenticare gli utenti quando si connettono all'istanza database di Amazon RDS per Oracle. In questa configurazione, l'istanza database funziona con AWS Directory Service for Microsoft Active Directory, chiamata anche AWS Managed Microsoft AD. Quando gli utenti eseguono l'autenticazione con un'istanza database di RDS per Oracle unita al dominio trusting, le richieste di autenticazione vengono inoltrate alla directory creata con Directory Service.
Mantenere tutte le credenziali nella stessa directory consente di ridurre il tempo e l'impegno. È disponibile una posizione centralizzata per archiviare e gestire le credenziali per più istanze database. L'uso di una directory può inoltre migliorare il profilo di sicurezza complessivo.
# Disponibilità di regioni e versioni
Il supporto varia a seconda delle versioni specifiche di ciascun motore di database e a seconda delle Regioni AWS. Per ulteriori informazioni sulla disponibilità delle versioni e regioni di RDS per Oracle con autenticazione Kerberos, consulta [Regioni e motori di database supportati per l’autenticazione Kerberos in Amazon RDS](Concepts.RDS_Fea_Regions_DB-eng.Feature.KerberosAuthentication.md).
**Nota**
L'autenticazione Kerberos non è supportata per classi di istanze database dichiarate obsolete per istanze database di RDS per Oracle. Per ulteriori informazioni, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
**Topics**
+ [Disponibilità di regioni e versioni](oracle-kerberos-setting-up.RegionVersionAvailability.md)
+ [Configurazione di Kerberos per le istanze database Oracle](oracle-kerberos-setting-up.md)
+ [Gestione di un'istanza database in un dominio](oracle-kerberos-managing.md)
+ [Connessione a Oracle con Autenticazione Kerberos](oracle-kerberos-connecting.md)
# Configurazione di Kerberos per le istanze database Oracle
Utilizzare AWS Directory Service for Microsoft Active Directory, chiamato anche AWS Managed Microsoft AD, per configurare l'autenticazione Kerberos per un'istanza DB Oracle. Per configurare Autenticazione Kerberos, completa le fasi seguenti:
+ [Passaggio 1: creare una directory utilizzando il AWS Managed Microsoft AD](#oracle-kerberos.setting-up.create-directory)
+ [Fase 2: creazione di un trust](#oracle-kerberos.setting-up.create-forest-trust)
+ [Fase 3: configurazione delle autorizzazioni IAM per Amazon RDS](#oracle-kerberos.setting-up.CreateIAMRole)
+ [Fase 4: creazione e configurazione di utenti](#oracle-kerberos.setting-up.create-users)
+ [Fase 5: abilitazione del traffico tra VPC tra la directory e l'istanza database](#oracle-kerberos.setting-up.vpc-peering)
+ [Fase 6: creazione o modifica di un'istanza database Oracle](#oracle-kerberos.setting-up.create-modify)
+ [Fase 7: creazione di login Oracle di autenticazione Kerberos](#oracle-kerberos.setting-up.create-logins)
+ [Fase 8: configurazione di un client Oracle](#oracle-kerberos.setting-up.configure-oracle-client)
**Nota**
Durante la configurazione, RDS crea un utente del database Oracle denominato *managed\$1service\$1user* @ *example.com* con il `CREATE SESSION` privilegio, dove si *example.com* trova il nome di dominio. Questo utente corrisponde all'utente creato dal servizio directory all'interno di Active Directory gestito. Periodicamente, RDS utilizza le credenziali fornite dal servizio directory per accedere al database Oracle. Successivamente, RDS distrugge immediatamente la cache dei ticket.
## Passaggio 1: creare una directory utilizzando il AWS Managed Microsoft AD
Directory Service crea una Active Directory completamente gestita nel AWS cloud. Quando crei una AWS Managed Microsoft AD directory, Directory Service crea due controller di dominio e server DNS (Domain Name System) per tuo conto. I server di directory vengono creati in sottoreti diverse in un VPC. Questa ridondanza assicura che la directory rimanga accessibile anche se si verifica un errore.
Quando crei una AWS Managed Microsoft AD directory, Directory Service esegue le seguenti attività per tuo conto:
+ Configura una Active Directory all'interno del VPC.
+ Crea un account amministratore della directory con nome utente Admin e la password specificata. Puoi utilizzare questo account per gestire le directory.
**Nota**
Assicurati di salvare questa password. Directory Service non la memorizza. È possibile reimpostarla ma non recuperarla.
+ Crea un gruppo di sicurezza per i controller della directory.
Quando si avvia un AWS Managed Microsoft AD, AWS crea un'unità organizzativa (OU) che contiene tutti gli oggetti della directory. Questa unità organizzativa ha lo stesso nome NetBIOS che hai digitato al momento della creazione della directory e si trova nella radice del dominio. La radice del dominio è di proprietà e gestita da AWS.
L'account amministratore creato con la AWS Managed Microsoft AD directory dispone delle autorizzazioni per le attività amministrative più comuni dell'unità organizzativa:
+ Creazione, aggiornamento o eliminazione di utenti
+ Aggiungi risorse al dominio, come file server o server di stampa, e assegna le autorizzazioni per tali risorse a utenti dell'unità organizzativa
+ Crea contenitori aggiuntivi OUs e
+ Delega dell'autorità
+ Ripristino degli oggetti eliminati dal cestino di Active Directory
+ Esegui i PowerShell moduli Windows AD e DNS sul servizio Web Active Directory
L'account Admin dispone inoltre dei diritti per eseguire le seguenti attività estese a tutto il dominio:
+ gestione delle configurazioni DNS (aggiunta, eliminazione o aggiornamento di record, zone e server d'inoltro);
+ visualizzazione di log di eventi DNS;
+ visualizzazione di log di eventi di sicurezza.
Per creare la directory, usa l' Console di gestione AWS AWS CLI, o l' Directory Service API. Assicurati di aprire le porte in uscita pertinenti nel gruppo di sicurezza delle directory in modo che la directory possa comunicare con l'istanza database Oracle.
**Per creare una directory con AWS Managed Microsoft AD**
1. Accedi a Console di gestione AWS e apri la Directory Service console all'indirizzo [https://console.aws.amazon.com/directoryservicev2/](https://console.aws.amazon.com/directoryservicev2/).
1. Nel riquadro di navigazione, seleziona **Directories (Directory)** e quindi **Set up directory (Configura la directory)**.
1. Scegli **AWS Managed Microsoft AD**. AWS Managed Microsoft AD è l'unica opzione attualmente utilizzabile con Amazon RDS.
1. Immettere le seguenti informazioni:
**Nome DNS directory**
Il nome completo della directory, ad esempio **corp.example.com**.
**Nome NetBIOS della directory**
Nome breve per la directory, ad esempio **CORP**.
**Descrizione della directory**
(Opzionale) Una descrizione della directory.
**Password amministratore**
La password dell'amministratore della directory. Con il processo di creazione della directory viene generato un account amministratore con il nome utente Admin e questa password.
La password dell'amministratore della directory e non può includere il termine "admin". La password distingue tra maiuscole e minuscole e la lunghezza deve essere compresa tra 8 e 64 caratteri. Deve anche contenere un carattere di almeno tre delle seguenti quattro categorie:
+ Lettere minuscole (a–z)
+ Lettere maiuscole (A–Z)
+ Numeri (0–9)
+ Caratteri non alfanumerici (\$1\$1@\$1\$1%^&\$1\$1-\$1=`\$1\$1()\$1\$1[]:;"'<>,.?/)
**Confirm password (Conferma password)**
La password dell'amministratore digitata nuovamente.
1. Scegli **Next (Successivo)**.
1. Immettere le seguenti informazioni nella sezione **Networking (Rete)** e quindi scegliere **Next (Avanti)**:
**VPC**
VPC per la directory. Creare l'istanza database Oracle in questo stesso VPC.
**Sottoreti**
Sottoreti per i server di directory. Le due sottoreti devono trovarsi in diverse zone di disponibilità.
1. Esaminare le informazioni relative alla directory e apportare eventuali modifiche. Quando le informazioni sono corrette, scegli **Create Directory (Crea directory)**.
![\[Pagina dei dettagli della directory durante la creazione\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/WinAuth2.png)
Per creare la directory sono necessari alcuni minuti. Una volta creata correttamente la directory, il valore **Status (Stato)** viene modificato in **Active (Attivo)**.
Per consultare le informazioni sulla directory, selezionare il nome della directory nell'elenco di directory. Prendere nota del valore di **Directory ID (ID directory)** perché sarà necessario quando si crea o si modifica l'istanza database Oracle.
![\[Pagina dei dettagli della directory\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/WinAuth3.png)
## Fase 2: creazione di un trust
Se prevedi di utilizzarla AWS Managed Microsoft AD solo, passa a[Fase 3: configurazione delle autorizzazioni IAM per Amazon RDS](#oracle-kerberos.setting-up.CreateIAMRole).
Per abilitare l'autenticazione Kerberos utilizzando l'Active Directory autogestito, è necessario creare una relazione di trust forestale tra Active Directory autogestita e quella AWS Managed Microsoft AD creata nel passaggio precedente. La fiducia può essere unidirezionale, laddove si AWS Managed Microsoft AD affida all'Active Directory autogestito. Il trust può anche essere bidirezionale, in cui entrambe le Active Directory si considerano reciprocamente attendibili. *Per ulteriori informazioni sulla configurazione dei trust forestali utilizzando Directory Service, vedere [Quando creare una relazione di fiducia](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_setup_trust.html) nella Guida all'amministrazione.Directory Service *
## Fase 3: configurazione delle autorizzazioni IAM per Amazon RDS
Directory Service Per chiamarti, Amazon RDS richiede un ruolo IAM che utilizzi la policy `AmazonRDSDirectoryServiceAccess` IAM gestita. Questo ruolo permette ad Amazon RDS di effettuare chiamate alla Directory Service.
**Nota**
Affinché il ruolo consenta l'accesso, l'endpoint AWS Security Token Service (AWS STS) deve essere attivato nel modo corretto Regione AWS per te. Account AWS AWS STS Gli endpoint sono tutti Regioni AWS attivi per impostazione predefinita e puoi usarli senza ulteriori azioni. *Per ulteriori informazioni, consulta [Attivazione e disattivazione AWS STSRegione AWS in un](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#sts-regions-activate-deactivate) capitolo della IAM User Guide.*
### Creazione di un ruolo IAM
Quando crei un'istanza DB utilizzando e l' Console di gestione AWS utente della console dispone dell'`iam:CreateRole`autorizzazione, la console viene creata automaticamente. `rds-directoryservice-kerberos-access-role` In caso contrario, è necessario creare manualmente il ruolo IAM. Quando crei manualmente un ruolo IAM`Directory Service`, scegli e allega la policy AWS gestita `AmazonRDSDirectoryServiceAccess` ad esso.
Per ulteriori informazioni sulla creazione di ruoli IAM per un servizio, consulta [Creating a role to delegate permissions to an AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *IAM User* Guide.
**Nota**
Il ruolo IAM utilizzato per l'autenticazione Windows per RDS per Microsoft SQL Server non può essere utilizzato per RDS per Oracle.
### Creazione manuale di una policy di attendibilità IAM
Facoltativamente, puoi creare policy delle risorse con le autorizzazioni richieste anziché utilizzare la policy IAM gestita `AmazonRDSDirectoryServiceAccess`. Specifica sia `directoryservice.rds.amazonaws.com` che `rds.amazonaws.com` come principali.
Per limitare le autorizzazioni alle risorse che Amazon RDS fornisce a un altro servizio per una risorsa specifica, si consiglia di utilizzare le chiavi di contesto delle condizioni globali [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) nelle policy delle risorse. Il modo più efficace per proteggersi dal problema "confused deputy" è usare la chiave di contesto della condizione globale `aws:SourceArn` con l'ARN completo di una risorsa di Amazon RDS. Per ulteriori informazioni, consulta [Prevenzione del problema "confused deputy" tra servizi](cross-service-confused-deputy-prevention.md).
L'esempio seguente mostra il modo in cui puoi utilizzare le chiavi di contesto `aws:SourceArn` e `aws:SourceAccount` delle condizioni globali in Amazon RDS per prevenire il problema “confused deputy”.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:us-east-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
Per le Regioni di adesione, è necessario utilizzare un principale del servizio relativo alla Regione in formato `directoryservice.rds.region_name.amazonaws.com`. Ad esempio, nella Regione Africa (Città del Capo), utilizza la seguente policy di attendibilità:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"directoryservice.rds.af-south-1.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"ArnLike": {
"aws:SourceArn": "arn:aws:rds:af-south-1:123456789012:db:mydbinstance"
},
"StringEquals": {
"aws:SourceAccount": "123456789012"
}
}
}
]
}
```
------
Il ruolo deve anche disporre della seguente policy IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ds:DescribeDirectories",
"ds:AuthorizeApplication",
"ds:UnauthorizeApplication",
"ds:GetAuthorizedApplicationDetails"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
## Fase 4: creazione e configurazione di utenti
Puoi creare utenti utilizzando lo strumento Users and Computers (Utenti e computer) di Active Directory, che è uno degli strumenti Domain Services (Servizi di dominio) e Lightweight Directory Services (Servizi di Lightweight Directory) di Active Directory. In questo caso, gli *utenti* sono individui singoli o entità che hanno accesso alla tua directory.
Per creare utenti in una Directory Service directory, devi essere connesso a un'istanza Amazon EC2 basata su Windows che fa parte della directory. Directory Service Allo stesso tempo, devi essere connesso come un utente che dispone di privilegi per creare utenti. Per ulteriori informazioni sulla creazione di utenti Microsoft Active Directory, consulta [Gestione di utenti e gruppi in AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html) nella *Guida all’amministrazione di Directory Service *.
## Fase 5: abilitazione del traffico tra VPC tra la directory e l'istanza database
Se prevedi di individuare la directory e l'istanza database nello stesso VPC, ignora questa fase e passa a [Fase 6: creazione o modifica di un'istanza database Oracle](#oracle-kerberos.setting-up.create-modify).
[Se prevedi di localizzare la directory e l'istanza DB in AWS account diversi o VPCs configurare il traffico cross-VPC utilizzando il peering VPC o il Transit Gateway.AWS](https://docs.aws.amazon.com/vpc/latest/tgw/what-is-transit-gateway.html) La procedura seguente abilita il traffico tra un VPCs utilizzo e l'altro del peering VPC. Segui le istruzioni in [Che cos'è il peering di VPC?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) nella *Amazon Virtual Private Cloud Peering Guide*.
**Per abilitare il traffico tra VPC utilizzando il peering di VPC**
1. Configurare le regole di routing VPC appropriate per garantire che il traffico di rete possa scorrere in entrambe le direzioni.
1. Assicurarsi che il gruppo di protezione dell'istanza database possa ricevere traffico in entrata dal gruppo di sicurezza della directory. Per ulteriori informazioni, consulta [Best practice per AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_best_practices.html) nella *Guida all’amministrazione di Directory Service *.
1. Assicurati che non sia presente una regola della lista di controllo accessi (ACL) di rete per bloccare il traffico.
Se la directory è di proprietà di un altro AWS account, è necessario condividerla.
**Per condividere la cartella tra AWS account**
1. *Inizia a condividere la directory con l' AWS account in cui verrà creata l'istanza DB seguendo le istruzioni riportate nel [Tutorial: Sharing your AWS Managed Microsoft AD directory for seamless EC2 Domain-join](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html) nella Administration Guide.Directory Service *
1. Accedi alla Directory Service console utilizzando l'account per l'istanza DB e assicurati che il dominio abbia lo stato prima di procedere. `SHARED`
1. Dopo aver effettuato l'accesso alla Directory Service console utilizzando l'account per l'istanza DB, annota il valore **Directory ID**. Utilizzare questo ID directory per aggiungere l'istanza database al dominio.
## Fase 6: creazione o modifica di un'istanza database Oracle
Crea o modifica un'istanza database Oracle per l'utilizzo con la directory. Puoi utilizzare la console, CLI o l'API RDS per associare un'istanza database a una directory. Questa operazione può essere eseguita in uno dei seguenti modi:
+ Crea una nuova istanza Oracle DB utilizzando la console, il comando [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)CLI o l'operazione [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) RDS API.
Per istruzioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza Oracle DB esistente utilizzando la console, il comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI o l'operazione [Modify DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) RDS API.
Per istruzioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ [Ripristina un'istanza Oracle DB da uno snapshot DB utilizzando la console, il comando CLI [ restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) o l'operazione Restore From RDS API. DBInstance DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html)
Per istruzioni, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
+ Ripristina un'istanza Oracle DB point-in-time utilizzando la console, il comando [ restore-db-instance-to- point-in-time](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html) CLI o l'operazione [Restore DBInstance ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceToPointInTime.html) RDS API.
Per istruzioni, consulta [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md).
L'autenticazione Kerberos è supportata solo per istanze database Oracle in un VPC. L'istanza database Oracle può trovarsi nello stesso VPC della directory o in un VPC diverso. Quando crei o modifichi l'istanza database, completa le seguenti operazioni:
+ Specifica l'identificativo del dominio (identificativo `d-*`) generato al momento della creazione della directory.
+ Specifica anche il nome del ruolo IAM creato.
+ Assicurati che il gruppo di sicurezza dell'istanza database possa ricevere traffico in ingresso dal gruppo di sicurezza della directory e inviare traffico in uscita alla directory.
Quando utilizzi la console per creare un'istanza database, scegli **Password and Kerberos authentication (Password e autenticazione Kerberos)** nella sezione **Database authentication (Autenticazione database)**. Scegli **Browse Directory (Sfoglia directory)** quindi seleziona la directory oppure scegli **Create a new directory (Crea una nuova directory)**.
![\[Impostazione dell'autenticazione Kerberos durante la creazione di un'istanza database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/kerberos-authentication.png)
Quando utilizzi la console per modificare o ripristinare un'istanza database, scegli la directory nella sezione **Kerberos authentication (Autenticazione Kerberos)** oppure scegli **Create a new directory (Crea una nuova directory)**.
![\[Impostazione di autenticazione Kerberos durante la modifica o il ripristino di un'istanza database\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/kerberos-auth-modify-restore.png)
Quando si utilizza il AWS CLI, sono necessari i seguenti parametri affinché l'istanza DB possa utilizzare la directory creata:
+ Per il parametro `--domain`, utilizza l'identificatore di dominio (identificatore "d-\$1") generato durante la creazione della directory.
+ Per il parametro `--domain-iam-role-name`, utilizza il ruolo creato che utilizza la policy IAM gestita `AmazonRDSDirectoryServiceAccess`.
Ad esempio, il comando CLI seguente modifica un'istanza database per utilizzare una directory.
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--domain d-ID \
--domain-iam-role-name role-name
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier mydbinstance ^
--domain d-ID ^
--domain-iam-role-name role-name
```
**Importante**
Se modifichi un'istanza database per abilitare l'autenticazione Kerberos, riavvia l'istanza database dopo aver apportato la modifica.
**Nota**
*MANAGED\$1SERVICE\$1USER*è un account di servizio il cui nome viene generato casualmente da Directory Service for RDS. Durante l'impostazione dell'autenticazione Kerberos, RDS per Oracle crea un utente con lo stesso nome e gli assegna il privilegio `CREATE SESSION`. L'utente Oracle DB viene identificato esternamente come*MANAGED\$1SERVICE\$1USER@EXAMPLE.COM*, where *EXAMPLE.COM* è il nome del dominio. Periodicamente, RDS utilizza le credenziali fornite dal servizio directory per accedere al database Oracle. Successivamente, RDS distrugge immediatamente la cache dei ticket.
## Fase 7: creazione di login Oracle di autenticazione Kerberos
Usa le credenziali dell'utente master Amazon RDS per eseguire la connessione all'istanza database Oracle come con qualunque altra istanza database. L'istanza DB viene aggiunta al AWS Managed Microsoft AD dominio. Pertanto, puoi eseguire il provisioning di login e utenti Oracle da utenti Microsoft Active Directory nel dominio. Per gestire autorizzazioni del database, concedi e revoca autorizzazioni Oracle standard a questi login.
**Per consentire a un utente di Microsoft Active Directory di eseguire l'autenticazione con Oracle**
1. Per connetterti all’istanza database Oracle utilizza invece le credenziali dell'utente master Amazon RDS.
1. Crea un utente autenticato esternamente nel database Oracle.
Nell'esempio seguente, sostituisci `KRBUSER@CORP.EXAMPLE.COM` con il nome utente e il nome di dominio.
```
CREATE USER "KRBUSER@CORP.EXAMPLE.COM" IDENTIFIED EXTERNALLY;
GRANT CREATE SESSION TO "KRBUSER@CORP.EXAMPLE.COM";
```
Gli utenti (persone e applicazioni) del dominio possono ora connettersi all'istanza database Oracle da un computer client associato al dominio utilizzando l'autenticazione Kerberos.
## Fase 8: configurazione di un client Oracle
Per configurare un client Oracle, devi rispettare i requisiti seguenti:
+ Crea un file di configurazione denominato krb5.conf (Linux) o krb5.ini (Windows) che faccia riferimento al dominio. Per utilizzare questo file di configurazione, configura il client Oracle.
+ Verifica che il traffico possa fluire tra l'host client e la porta DNS 53 Directory Service su TCP/UDP, le porte Kerberos (88 e 464 per quelle gestite Directory Service) su TCP e la porta LDAP 389 su TCP.
+ Verifica che il traffico scorra senza problemi tra l'host client e l'istanza database sulla porta del database.
Di seguito è riportato un esempio di contenuto per. AWS Managed Microsoft AD
```
[libdefaults]
default_realm = EXAMPLE.COM
[realms]
EXAMPLE.COM = {
kdc = example.com
admin_server = example.com
}
[domain_realm]
.example.com = CORP.EXAMPLE.COM
example.com = CORP.EXAMPLE.COM
```
Di seguito è riportato un esempio di contenuto per Microsoft AD on-premise. Nel file krb5.conf o krb5.ini, sostituiscilo *on-prem-ad-server-name* con il nome del server AD locale.
```
[libdefaults]
default_realm = ONPREM.COM
[realms]
AWSAD.COM = {
kdc = awsad.com
admin_server = awsad.com
}
ONPREM.COM = {
kdc = on-prem-ad-server-name
admin_server = on-prem-ad-server-name
}
[domain_realm]
.awsad.com = AWSAD.COM
awsad.com= AWSAD.COM
.onprem.com = ONPREM.COM
onprem.com= ONPREM.COM
```
**Nota**
Dopo aver configurato il file krb5.ini o krb5.conf, riavvia il server.
Di seguito viene fornito il contenuto di esempio del file sqlnet.ora per una configurazione SQL\$1Plus:
```
SQLNET.AUTHENTICATION_SERVICES=(KERBEROS5PRE,KERBEROS5)
SQLNET.KERBEROS5_CONF=path_to_krb5.conf_file
```
Per un esempio di una configurazione di SQL Developer, consulta [Documento 1609359.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1609359.1) del supporto di Oracle.
# Gestione di un'istanza database in un dominio
Puoi utilizzare la console, la CLI o l'API RDS per gestire l'istanza database e la sua relazione con Microsoft Active Directory. Ad esempio, puoi associare una Microsoft Active Directory per abilitare l'autenticazione Kerberos. Puoi anche annullare l'associazione di una Microsoft Active Directory per disabilitare l'autenticazione Kerberos. Puoi anche spostare un'istanza database affinché venga autenticata esternamente da una Microsoft Active Directory a un'altra.
Ad esempio, utilizzando la CLI, puoi effettuare quanto segue:
+ Per tentare nuovamente di abilitare Autenticazione Kerberos per un'appartenenza non riuscita, utilizza il comando CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) e specifica l'ID directory dell'appartenenza corrente per l'opzione `--domain`.
+ Per disabilitare Autenticazione Kerberos su un'istanza database, utilizza il comando CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) e specifica `none` per l'opzione `--domain`.
+ Per spostare un'istanza database da un dominio a un altro, utilizza il comando CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) e specifica l'identificatore di dominio del nuovo dominio per l'opzione `--domain`.
## Visualizzazione dello stato dell'appartenenza al dominio
Quando l'istanza database viene creata o modificata, questa diventa membro del dominio. Puoi visualizzare lo stato dell'appartenenza al dominio per l'istanza database nella console eseguendo il comando CLI [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). Lo stato dell'istanza di database può essere uno dei seguenti:
+ `kerberos-enabled`: l'autenticazione Kerberos è abilitata nell'istanza database.
+ `enabling-kerberos`: AWS si trova nella fase di abilitazione dell'autenticazione Kerberos su questa istanza database.
+ `pending-enable-kerberos`: l'abilitazione dell'autenticazione Kerberos è in corso su questa istanza database.
+ `pending-maintenance-enable-kerberos`: AWS proverà ad abilitare l'autenticazione Kerberos sull'istanza database durante la prossima finestra di manutenzione pianificata.
+ `pending-disable-kerberos`: la disabilitazione dell'autenticazione Kerberos è in corso su questa istanza database.
+ `pending-maintenance-disable-kerberos`: AWS proverà a disabilitare l'autenticazione Kerberos sull'istanza database durante la prossima finestra di manutenzione pianificata.
+ `enable-kerberos-failed`: un problema di configurazione ha impedito a AWS di abilitare l'autenticazione Kerberos sull'istanza database. Correggi il problema di configurazione prima di inviare nuovamente il comando per modificare l'istanza database.
+ `disabling-kerberos`: AWS si trova nella fase di disabilitazione dell'autenticazione Kerberos su questa istanza database.
Una richiesta per abilitare l'autenticazione Kerberos potrebbe non andare a buon fine a causa di un problema di connettività di rete o un ruolo IAM non corretto. Se il tentativo di abilitare l'autenticazione Kerberos non va a buon fine quando crei o modifichi un'istanza database, assicurati innanzitutto di utilizzare il ruolo IAM corretto. Quindi, modifica l'istanza database per l'aggiunta al dominio
**Nota**
Solo l'autenticazione Kerberos con Amazon RDS for Oracle invia traffico ai server DNS del dominio. Tutte le altre richieste DNS vengono gestite come accesso di rete in uscita sulle istanze database che eseguono Oracle. Per ulteriori informazioni sull'accesso di rete in uscita con Amazon RDS for Oracle, consulta [Impostazione di un server DNS personalizzato](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
## Chiavi Kerberos con rotazione forzata
Una chiave segreta viene condivisa tra AWS Managed Microsoft AD e l’istanza database Amazon RDS for Oracle. Questa chiave viene ruotata automaticamente ogni 45 giorni. Puoi utilizzare la procedura Amazon RDS seguente per forzare la rotazione di questa chiave.
```
SELECT rdsadmin.rdsadmin_kerberos_auth_tasks.rotate_kerberos_keytab AS TASK_ID FROM DUAL;
```
**Nota**
In una configurazione replica di lettura, questa procedura è disponibile solo nell'istanza database di origine e non nella replica di lettura.
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. È possibile visualizzare lo stato di un'attività in corso in un file bdump. I file bdump si trovano nella directory `/rdsdbdata/log/trace`. Il nome del file bdump ha il formato che segue.
```
dbtask-task-id.log
```
È possibile visualizzare il risultato visualizzando il file di output dell'attività.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
Sostituire *`task-id`* con l'ID attività restituito dalla procedura.
**Nota**
Le attività vengono eseguite in modo asincrono.
# Connessione a Oracle con Autenticazione Kerberos
In questa sezione si assume che il client Oracle sia stato configurato come descritto in [Fase 8: configurazione di un client Oracle](oracle-kerberos-setting-up.md#oracle-kerberos.setting-up.configure-oracle-client). Per connetterti a Oracle DB con Autenticazione Kerberos, accedi utilizzando il tipo di autenticazione Kerberos. Ad esempio, dopo l’avvio di Oracle SQL Developer, scegli **Kerberos Authentication** come tipo di autenticazione, come mostrato nell’esempio seguente.
![\[Finestra di dialogo New/Select Database Connection in Oracle SQL Developer. La casella di controllo Kerberos Authentication è selezionata.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/ora-kerberos-auth.png)
Per connettersi a Oracle con l'autenticazione Kerberos con SQL\$1Plus:
1. Al prompt dei comandi, esegui il comando seguente:
```
kinit username
```
Sostituisci *`username`* con il nome utente e, quando richiesto, immetti la password memorizzata nella Microsoft Active Directory per l'utente.
1. Apri SQL\$1Plus ed esegui la connessione utilizzando il nome DNS e il numero di porta per l'istanza database Oracle.
Per ulteriori informazioni sulla connessione a un'istanza database Oracle in SQL\$1Plus, consulta [Connessione all'istanza database tramite SQL\$1Plus](USER_ConnectToOracleInstance.SQLPlus.md).
**Suggerimento**
Se utilizzi una cache nativa di Windows, puoi anche impostare il parametro `SQLNET.KERBEROS5_CC_NAME` su `OSMSFT://` o `MSLSA` nel file sqlnet.ora per utilizzare le credenziali archiviate in Microsoft Active Directory.
# Configurazione dell'accesso UTL\$1HTTP utilizzando certificati e un portafoglio Oracle
Amazon RDS supporta l’accesso alla rete in uscita nelle istanze database RDS per Oracle. Per connettere l'istanza DB alla rete, è possibile utilizzare i seguenti PL/SQL pacchetti:
`UTL_HTTP`
Questo pacchetto effettua chiamate HTTP da SQL e PL/SQL. Puoi utilizzarlo per accedere ai dati su Internet tramite HTTP. Per ulteriori informazioni, consulta [UTL\$1HTTP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_HTTP.html#GUID-A85D2D1F-90FC-45F1-967F-34368A23C9BB) nella documentazione di Oracle.
`UTL_TCP`
Questo pacchetto fornisce funzionalità di accesso TCP/IP lato client nelle PL/SQL. This package is useful to PL/SQL applicazioni che utilizzano protocolli Internet e posta elettronica. Per ulteriori informazioni, consulta [UTL\$1TCP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_TCP.html#GUID-348AFFE8-78B2-4217-AE73-384F46A1D292) nella documentazione di Oracle.
`UTL_SMTP`
Questo pacchetto fornisce interfacce ai comandi SMTP che consentono a un client di inviare messaggi di posta elettronica a un server SMTP. Per ulteriori informazioni, consulta [UTL\$1SMTP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_SMTP.html#GUID-F0065C52-D618-4F8A-A361-7B742D44C520) nella documentazione di Oracle.
Completando le seguenti attività, puoi configurare `UTL_HTTP.REQUEST` affinché funzioni con siti Web che richiedono certificati di autenticazione client durante l'handshake SSL. Puoi anche configurare l'autenticazione con password affinché `UTL_HTTP` acceda ai siti Web modificando i comandi di generazione del portafoglio Oracle wallet e la procedura `DBMS_NETWORK_ACL_ADMIN.APPEND_WALLET_ACE`. Per ulteriori informazioni, consulta [DBMS\$1NETWORK\$1ACL\$1ADMIN](https://docs.oracle.com/en/database/oracle/oracle-database/21/arpls/DBMS_NETWORK_ACL_ADMIN.html) nella documentazione di Oracle Database.
**Nota**
Puoi adattare le seguenti attività per `UTL_SMTP`, il che consente di inviare e-mail tramite SSL/TLS (incluso [Amazon Simple Email Service](https://aws.amazon.com/ses/)).
**Topics**
+ [Considerazioni sulla configurazione dell’accesso UTL\$1HTTP](#utl_http-considerations)
+ [Passaggio 1: ottieni il certificato root per un sito Web](#website-root-certificate)
+ [Passaggio 2: crea un portafoglio Oracle](#create-oracle-wallet)
+ [Passaggio 3: scarica il tuo portafoglio Oracle nella tua istanza RDS for Oracle](#upload-wallet-to-instance)
+ [Passaggio 4: concedi le autorizzazioni utente per il portafoglio Oracle](#config-oracle-wallet-user)
+ [Passaggio 5: configura l'accesso a un sito Web dall'istanza database](#config-website-access)
+ [Passaggio 6: testa le connessioni dall'istanza database a un sito Web](#test_utl_http)
## Considerazioni sulla configurazione dell’accesso UTL\$1HTTP
Prima di configurare l’accesso, valuta quanto segue:
+ Puoi utilizzare SMTP con l’opzione UTL\$1MAIL. Per ulteriori informazioni, consulta [UTL\$1MAIL di Oracle](Oracle.Options.UTLMAIL.md).
+ Il nome del DNS (Domain Name Server) dell'host remoto può essere uno qualsiasi dei seguenti:
+ Risolvibile pubblicamente.
+ L'endpoint di un'istanza database Amazon RDS.
+ Risolvibile attraverso un server DNS personalizzato. Per ulteriori informazioni, consulta [Impostazione di un server DNS personalizzato](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
+ Il nome DNS privato di un'istanza Amazon EC2 nello stesso VPC o in un VPC in peering. In questo caso, assicurarsi che il nome sia risolvibile attraverso un server DNS personalizzato. In alternativa, per utilizzare il DNS fornito da Amazon, è possibile abilitare l'attributo `enableDnsSupport` nelle impostazioni VPC e abilitare il supporto alla risoluzione DNS per la connessione VPC in peering. Per ulteriori informazioni, consulta la sezione sul [supporto DNS nel tuo VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) e quella sulla [modifica della tua connessione VPC in peering](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#modify-peering-connections).
+ Per connettersi in modo sicuro alle SSL/TLS risorse remote, si consiglia di creare e caricare portafogli Oracle personalizzati. Utilizzando la funzionalità di integrazione di Amazon S3 con Amazon RDS for Oracle, è possibile scaricare un portafoglio da Amazon S3 sulle istanze database Oracle. Per informazioni sull'integrazione di Amazon S3 per Oracle, consultare [Integrazione Amazon S3](oracle-s3-integration.md).
+ Se l'opzione SSL Oracle è configurata per ogni istanza, è possibile stabilire collegamenti di database tra istanze database di Oracle tramite un endpoint SSL/TLS. Non è richiesta alcuna configurazione aggiuntiva. Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
## Passaggio 1: ottieni il certificato root per un sito Web
Affinché l’istanza database RDS per Oracle possa stabilire connessioni sicure a un sito web, aggiungi il certificato CA root. Amazon RDS utilizza il certificato root per firmare il certificato del sito Web al portafoglio Oracle.
È possibile ottenere il certificato root in vari modi. Ad esempio, puoi eseguire le operazioni seguenti:
1. Utilizza un server Web per visitare il sito Web protetto dal certificato.
1. Scarica il certificato root utilizzato per la firma.
Per quanto riguarda AWS i servizi, i certificati root in genere risiedono nell'[archivio Amazon Trust Services](https://www.amazontrust.com/repository/).
## Passaggio 2: crea un portafoglio Oracle
Crea un portafoglio Oracle contenente sia i certificati del server Web che i certificati di autenticazione client. L'istanza Oracle RDS utilizza il certificato del server Web per stabilire una connessione sicura al sito Web. Il sito Web ha bisogno del certificato client per autenticare l'utente del database Oracle.
È possibile configurare connessioni sicure senza utilizzare certificati client per l'autenticazione. In questo caso, puoi ignorare i passaggi del keystore Java nella seguente procedura.
**Per creare un portafoglio Oracle**
1. Posiziona i certificati root e client in un'unica directory, quindi passa a questa directory.
1. Converti il certificato client .p12 nel keystore Java.
**Nota**
Se non utilizzi certificati client per l'autenticazione, puoi ignorare questo passaggio.
L'esempio seguente converte il certificato client denominato *client\$1certificate.p12* nel keystore Java denominato. *client\$1keystore.jks* Il keystore viene quindi incluso nel portafoglio Oracle. La password del keystore è. *P12PASSWORD*
```
orapki wallet pkcs12_to_jks -wallet ./client_certificate.p12 -jksKeyStoreLoc ./client_keystore.jks -jksKeyStorepwd P12PASSWORD
```
1. Crea una directory per il tuo portafoglio Oracle diversa dalla directory dei certificati.
Nell'esempio seguente viene creata la directory `/tmp/wallet`.
```
mkdir -p /tmp/wallet
```
1. Crea un portafoglio Oracle nella directory del portafoglio.
L'esempio seguente imposta la password del wallet Oracle su*P12PASSWORD*, che è la stessa password utilizzata dal keystore Java in un passaggio precedente. L'utilizzo della stessa password è comodo, ma non necessario. Il parametro `-auto_login` attiva la caratteristica di accesso automatico, in modo che non sia necessario specificare una password ogni volta che si desidera accedervi.
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
```
orapki wallet create -wallet /tmp/wallet -pwd P12PASSWORD -auto_login
```
1. Aggiungi il keystore Java al tuo portafoglio Oracle.
**Nota**
Se non utilizzi certificati client per l'autenticazione, puoi ignorare questo passaggio.
L'esempio seguente aggiunge il keystore *client\$1keystore.jks* al wallet Oracle denominato. */tmp/wallet* In questo esempio, si specifica la stessa password del keystore Java e del portafoglio Oracle.
```
orapki wallet jks_to_pkcs12 -wallet /tmp/wallet -pwd P12PASSWORD -keystore ./client_keystore.jks -jkspwd P12PASSWORD
```
1. Aggiungi il certificato root per il tuo sito Web di destinazione al portafoglio Oracle.
L'esempio seguente aggiunge un certificato denominato*Root\$1CA.cer*.
```
orapki wallet add -wallet /tmp/wallet -trusted_cert -cert ./Root_CA.cer -pwd P12PASSWORD
```
1. Aggiungi eventuali certificati intermedi.
L'esempio seguente aggiunge un certificato denominato*Intermediate.cer*. Ripeti questo passaggio tutte le volte necessarie per caricare tutti i certificati intermedi.
```
orapki wallet add -wallet /tmp/wallet -trusted_cert -cert ./Intermediate.cer -pwd P12PASSWORD
```
1. Verifica che il tuo portafoglio Oracle appena creato disponga dei certificati richiesti.
```
orapki wallet display -wallet /tmp/wallet -pwd P12PASSWORD
```
## Passaggio 3: scarica il tuo portafoglio Oracle nella tua istanza RDS for Oracle
In questo passaggio, carichi il tuo portafoglio Oracle su Amazon S3 e poi scarichi il portafoglio da Amazon S3 nella tua istanza RDS for Oracle.
**Per scaricare il tuo portafoglio Oracle nella tua istanza database RDS for Oracle**
1. Completare i prerequisiti per l'integrazione di Amazon S3 con Oracle e aggiungere l'opzione `S3_INTEGRATION` all'istanza database Oracle. Assicurarsi che il ruolo IAM per l'opzione abbia accesso al bucket Amazon S3 che si sta utilizzando.
Per ulteriori informazioni, consulta [Integrazione Amazon S3](oracle-s3-integration.md).
1. Accedei all'istanza database come utente principale e quindi crea una directory Oracle per contenere il portafoglio Oracle.
L'esempio seguente crea una directory Oracle denominata*WALLET\$1DIR*.
```
EXEC rdsadmin.rdsadmin_util.create_directory('WALLET_DIR');
```
Per ulteriori informazioni, consulta [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
1. Carica il portafoglio Oracle sul tuo bucket Amazon S3.
Puoi utilizzare qualsiasi tecnica di caricamento supportata.
1. Se stai ricaricando un portafoglio Oracle, elimina il portafoglio esistente. Altrimenti, passare alla fase successiva.
L'esempio seguente rimuove il wallet esistente, denominato*cwallet.sso*.
```
EXEC UTL_FILE.FREMOVE ('WALLET_DIR','cwallet.sso');
```
1. Scarica il portafoglio Oracle dal bucket Amazon S3 sull'istanza database Oracle.
L'esempio seguente scarica il wallet denominato *cwallet.sso* dal bucket Amazon S3 denominato nella directory dell'istanza DB denominata*my\$1s3\$1bucket*. *WALLET\$1DIR*
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'my_s3_bucket',
p_s3_prefix => 'cwallet.sso',
p_directory_name => 'WALLET_DIR')
AS TASK_ID FROM DUAL;
```
1. (Facoltativo) Scarica un portafoglio Oracle protetto da password.
Scarica questo portafoglio solo se vuoi richiedere una password per ogni utilizzo del portafoglio. L'esempio seguente scarica un portafoglio protetto da password. *ewallet.p12*
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'my_s3_bucket',
p_s3_prefix => 'ewallet.p12',
p_directory_name => 'WALLET_DIR')
AS TASK_ID FROM DUAL;
```
1. Verifica lo stato dell'attività del database.
Sostituisci l'ID dell'attività restituito dai passaggi precedenti con quello riportato nell'esempio *dbtask-1234567890123-4567.log* seguente.
```
SELECT TEXT FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1234567890123-4567.log'));
```
1. Controlla il contenuto della directory che stai utilizzando per memorizzare il portafoglio Oracle.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'WALLET_DIR'));
```
Per ulteriori informazioni, consulta [Generazione di un elenco dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories).
## Passaggio 4: concedi le autorizzazioni utente per il portafoglio Oracle
Puoi creare un nuovo utente database o configurare un utente esistente. In entrambi i casi, è necessario configurare l'utente per accedere al portafoglio Oracle per le connessioni sicure e l'autenticazione client tramite certificati.
**Per concedere autorizzazioni utente per il portafoglio Oracle**
1. Accedi all'istanza database RDS for Oracle come utente principale.
1. Se non desideri configurare un utente del database esistente, creare un nuovo utente. Altrimenti, passare alla fase successiva.
L'esempio seguente crea un utente del database denominato. *my-user*
```
CREATE USER my-user IDENTIFIED BY my-user-pwd;
GRANT CONNECT TO my-user;
```
1. Concedi l'autorizzazione all'utente del database nella directory contenente il portafoglio Oracle.
L'esempio seguente concede l'accesso in lettura all'utente *my-user* sulla directory*WALLET\$1DIR*.
```
GRANT READ ON DIRECTORY WALLET_DIR TO my-user;
```
1. Concedi l'autorizzazione all'utente del database per utilizzare il pacchetto `UTL_HTTP`.
Il seguente PL/SQL programma concede `UTL_HTTP` l'accesso all'utente. *my-user*
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_HTTP', UPPER('my-user'));
END;
/
```
1. Concedi l'autorizzazione all'utente del database per utilizzare il pacchetto `UTL_FILE`.
Il seguente PL/SQL programma concede `UTL_FILE` l'accesso all'utente. *my-user*
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_FILE', UPPER('my-user'));
END;
/
```
## Passaggio 5: configura l'accesso a un sito Web dall'istanza database
In questa fase, configuri l'utente del database Oracle in modo che possa connettersi al sito Web di destinazione utilizzando `UTL_HTTP`, il portafoglio Oracle caricato e il certificato client. Per ulteriori informazioni, consulta [Configuring Access Control to an Oracle Wallet](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-fine-grained-access-in-pl-sql-packages-and-types.html#GUID-0BCB5925-A40F-4507-95F9-5DA4A1919EBD) (Configurazione del controllo dell'accesso a un portafoglio Oracle) nella documentazione di Oracle Database.
**Per configurare l'accesso a un sito Web dall'istanza database RDS for Oracle**
1. Accedi all'istanza database RDS for Oracle come utente principale.
1. Crea una voce di controllo dell'accesso (ACE) host per il tuo utente e il sito Web di destinazione su una porta sicura.
L'esempio seguente configura l'accesso *my-user* alla porta sicura *secret.encrypted-website.com* 443.
```
BEGIN
DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
host => 'secret.encrypted-website.com',
lower_port => 443,
upper_port => 443,
ace => xs$ace_type(privilege_list => xs$name_list('http'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
-- If the program unit results in PLS-00201, set
-- the principal_type parameter to 2 as follows:
-- principal_type => 2));
END;
/
```
**Importante**
L’unità di programma precedente può restituire il seguente errore: `PLS-00201: identifier 'XS_ACL' must be declared`. Se viene restituito questo errore, sostituisci la riga che assegna un valore a `principal_type` con la riga seguente, quindi esegui nuovamente l’unità di programma:
```
principal_type => 2));
```
Per ulteriori informazioni sulle costanti del PL/SQL pacchetto`XS_ACL`, vedere [https://docs.oracle.com/en/database/oracle/oracle-database/19/dbfsg/XS_ACL-package.html#GUID-A157FB28-FE23-4D30-AAEB-8224230517E7](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbfsg/XS_ACL-package.html#GUID-A157FB28-FE23-4D30-AAEB-8224230517E7) nella documentazione di Oracle Database.
Per ulteriori informazioni, consulta [Configuring Access Control for External Network Services](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-fine-grained-access-in-pl-sql-packages-and-types.html#GUID-3D5B66BC-0277-4887-9CD1-97DB44EB5213) (Configurazione del controllo dell'accesso per servizi di rete esterni) nella documentazione di Oracle Database.
1. (Facoltativo) Crea un ACE per il tuo sito Web utente e di destinazione sulla porta standard.
Potrebbe essere necessario utilizzare la porta standard se alcune pagine Web sono servite dalla porta standard del server Web (80) anziché dalla porta sicura (443).
```
BEGIN
DBMS_NETWORK_ACL_ADMIN.APPEND_HOST_ACE(
host => 'secret.encrypted-website.com',
lower_port => 80,
upper_port => 80,
ace => xs$ace_type(privilege_list => xs$name_list('http'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
-- If the program unit results in PLS-00201, set
-- the principal_type parameter to 2 as follows:
-- principal_type => 2));
END;
/
```
1. Verifica che le voci di controllo dell'accesso siano presenti.
```
SET LINESIZE 150
COLUMN HOST FORMAT A40
COLUMN ACL FORMAT A50
SELECT HOST, LOWER_PORT, UPPER_PORT, ACL
FROM DBA_NETWORK_ACLS
ORDER BY HOST;
```
1. Concedi l'autorizzazione all'utente del database per utilizzare il pacchetto `UTL_HTTP`.
Il seguente PL/SQL programma concede `UTL_HTTP` l'accesso all'utente. *my-user*
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('UTL_HTTP', UPPER('my-user'));
END;
/
```
1. Conferma l'esistenza di liste di controllo dell'accesso correlate.
```
SET LINESIZE 150
COLUMN ACL FORMAT A50
COLUMN PRINCIPAL FORMAT A20
COLUMN PRIVILEGE FORMAT A10
SELECT ACL, PRINCIPAL, PRIVILEGE, IS_GRANT,
TO_CHAR(START_DATE, 'DD-MON-YYYY') AS START_DATE,
TO_CHAR(END_DATE, 'DD-MON-YYYY') AS END_DATE
FROM DBA_NETWORK_ACL_PRIVILEGES
ORDER BY ACL, PRINCIPAL, PRIVILEGE;
```
1. Concedi l'autorizzazione all'utente del database di utilizzare i certificati per l'autenticazione client e il portafoglio Oracle per le connessioni.
**Nota**
Se non utilizzi certificati client per l'autenticazione, puoi ignorare questo passaggio.
```
DECLARE
l_wallet_path all_directories.directory_path%type;
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
DBMS_NETWORK_ACL_ADMIN.APPEND_WALLET_ACE(
wallet_path => 'file:/' || l_wallet_path,
ace => xs$ace_type(privilege_list => xs$name_list('use_client_certificates'),
principal_name => 'my-user',
principal_type => xs_acl.ptype_db));
END;
/
```
## Passaggio 6: testa le connessioni dall'istanza database a un sito Web
In questa fase, configuri l'utente del database in modo che possa connettersi al sito Web utilizzando `UTL_HTTP`, il portafoglio Oracle caricato e il certificato client.
**Per configurare l'accesso a un sito Web dall'istanza database RDS for Oracle**
1. Accedi all'istanza database RDS for Oracle come utente del database con autorizzazioni `UTL_HTTP`.
1. Conferma che una connessione al sito Web di destinazione può risolvere l'indirizzo host.
L'esempio seguente ottiene l'indirizzo dell'host da*secret.encrypted-website.com*.
```
SELECT UTL_INADDR.GET_HOST_ADDRESS(host => 'secret.encrypted-website.com')
FROM DUAL;
```
1. Testa una connessione non riuscita.
La seguente query ha esito negativo perché `UTL_HTTP` richiede la posizione del portafoglio Oracle con i certificati.
```
SELECT UTL_HTTP.REQUEST('secret.encrypted-website.com') FROM DUAL;
```
1. Verifica l'accesso al sito web utilizzando `UTL_HTTP.SET_WALLET` e selezionando da `DUAL`.
```
DECLARE
l_wallet_path all_directories.directory_path%type;
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
UTL_HTTP.SET_WALLET('file:/' || l_wallet_path);
END;
/
SELECT UTL_HTTP.REQUEST('secret.encrypted-website.com') FROM DUAL;
```
1. (Facoltativo) Testa l'accesso al sito Web memorizzando la query in una variabile e utilizzando `EXECUTE IMMEDIATE`.
```
DECLARE
l_wallet_path all_directories.directory_path%type;
v_webpage_sql VARCHAR2(1000);
v_results VARCHAR2(32767);
BEGIN
SELECT DIRECTORY_PATH
INTO l_wallet_path
FROM ALL_DIRECTORIES
WHERE UPPER(DIRECTORY_NAME)='WALLET_DIR';
v_webpage_sql := 'SELECT UTL_HTTP.REQUEST(''secret.encrypted-website.com'', '''', ''file:/' ||l_wallet_path||''') FROM DUAL';
DBMS_OUTPUT.PUT_LINE(v_webpage_sql);
EXECUTE IMMEDIATE v_webpage_sql INTO v_results;
DBMS_OUTPUT.PUT_LINE(v_results);
END;
/
```
1. (Facoltativo) Individua la posizione del file system della directory del portafoglio Oracle.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'WALLET_DIR'));
```
Utilizza l'output del comando precedente per effettuare una richiesta HTTP. Ad esempio, se la directory è*rdsdbdata/userdirs/01*, esegui la seguente query.
```
SELECT UTL_HTTP.REQUEST('https://secret.encrypted-website.com/', '', 'file://rdsdbdata/userdirs/01')
FROM DUAL;
```
# Utilizzo di database CDB per RDS per Oracle
Nell'architettura multi-tenant Oracle, un database container (CDB) può includere database pluggable (PDB) creati dal cliente. Per ulteriori informazioni sui database CDB, consulta l'argomento relativo all'[introduzione all'architettura multi-tenant](https://docs.oracle.com/en/database/oracle/oracle-database/19/multi/introduction-to-the-multitenant-architecture.html#GUID-267F7D12-D33F-4AC9-AA45-E9CD671B6F22) nella documentazione di Oracle Database.
**Topics**
+ [Panoramica di RDS per Oracle CDBs](Oracle.Concepts.CDBs.md)
+ [Configurazione di un CDB RDS per Oracle](oracle-cdb.configuring.md)
+ [Backup e ripristino di un CDB](Oracle.Concepts.single-tenant.snapshots.md)
+ [Conversione di un database non CDB RDS per Oracle in un database CDB](oracle-cdb-converting.md)
+ [Conversione della configurazione a tenant singolo in multi-tenant](oracle-single-tenant-converting.md)
+ [Aggiunta di un database del tenant RDS per Oracle all'istanza CDB](oracle-cdb-configuring.adding.pdb.md)
+ [Modifica di un database del tenant RDS per Oracle](oracle-cdb-configuring.modifying.pdb.md)
+ [Eliminazione di un database del tenant RDS per Oracle dal CDB](oracle-cdb-configuring.deleting.pdb.md)
+ [Visualizzazione dei dettagli del database del tenant](oracle-cdb-configuring.describing.pdb.md)
+ [Aggiornamento del CDB](Oracle.Concepts.single-tenant.upgrades.md)
# Panoramica di RDS per Oracle CDBs
È possibile creare un'istanza database RDS per Oracle come database container (CDB) quando si esegue Oracle Database 19c o versione successiva. A partire da Oracle Database 21c, tutti i database lo sono. CDBs Un CDB si differenzia da un non CDB perché può contenere database collegabili (PDBs), denominati database tenant in RDS for Oracle. Un PDB è una raccolta portatile di schemi e oggetti visualizzato in un'applicazione come database distinto.
Il database del tenant iniziale (PDB) viene creato al momento della creazione dell’istanza CDB. In RDS per Oracle, l’applicazione client interagisce con il PDB anziché con il CDB. L'esperienza con un database PDB è per lo più identica all'esperienza con un database non CDB.
**Topics**
+ [Configurazione multi-tenant dell'architettura CDB](#multi-tenant-configuration)
+ [Configurazione a tenant singolo dell'architettura CDB](#Oracle.Concepts.single-tenant)
+ [Opzioni di creazione e conversione per CDBs](#oracle-cdb-creation-conversion)
+ [Account utente e privilegi in un CDB](#Oracle.Concepts.single-tenant.users)
+ [Famiglie di gruppi di parametri in un CDB](#Oracle.Concepts.single-tenant.parameters)
+ [Limitazioni di RDS per Oracle CDBs](#Oracle.Concepts.single-tenant-limitations)
## Configurazione multi-tenant dell'architettura CDB
RDS per Oracle supporta la configurazione multi-tenant dell’architettura multitenant Oracle, detta anche *architettura CDB*. In questa configurazione, l’istanza CDB RDS per Oracle può contenere da 1 a 30 database del tenant, a seconda dell’edizione del database e delle eventuali licenze opzionali richieste. In un database Oracle, un database del tenant è un PDB. L'istanza database deve utilizzare la versione del database Oracle 19.0.0.0.ru-2022-01.rur-2022.r1 o successiva.
**Nota**
La configurazione Amazon RDS è chiamata “multi-tenant” anziché “multitenant” perché è una funzionalità specifica di Amazon RDS, non solo del motore di database Oracle. Allo stesso modo, il termine RDS «tenant» si riferisce a qualsiasi tenant in una configurazione RDS, non solo a Oracle. PDBs Nella documentazione di RDS, il termine “Oracle multitenant” senza trattino si riferisce esclusivamente all’architettura CDB del database Oracle, che è compatibile sia con le implementazioni on-premises sia con quelle RDS.
Ora puoi configurare le impostazioni seguenti:
+ Nome del database tenant
+ Nome utente principale del database tenant
+ Password master del database del tenant (facoltativamente integrata con Secrets Manager)
+ Set di caratteri del database tenant
+ Set di caratteri nazionali del database tenant
Il set di caratteri del database del tenant può essere diverso dal set di caratteri del CDB. Lo stesso vale per il set di caratteri nazionali. Dopo aver creato il database tenant iniziale, è possibile creare, modificare o eliminare i database tenant utilizzando RDS. APIs Per impostazione predefinita, il nome CDB viene impostato su `RDSCDB` e non può essere modificato. Per ulteriori informazioni, consultare [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md) e [Modifica di un database del tenant RDS per Oracle](oracle-cdb-configuring.modifying.pdb.md).
## Configurazione a tenant singolo dell'architettura CDB
RDS per Oracle supporta una configurazione legacy dell'architettura multitenant Oracle chiamata configurazione a tenant singolo. In questa configurazione, un'istanza CDB RDS per Oracle può contenere un solo tenant (PDB). Non è possibile crearne altri in un secondo momento. PDBs
## Opzioni di creazione e conversione per CDBs
Oracle Database 21c supporta solo CDBs, mentre Oracle Database 19c supporta entrambi CDBs e non. CDBs Tutte le istanze CDB RDS per Oracle supportano sia la configurazione multi-tenant che quella a tenant singolo.
### Opzioni di creazione, conversione e aggiornamento per l'architettura del database Oracle
La tabella seguente mostra le diverse opzioni di architettura per la creazione e l'aggiornamento di database RDS per Oracle.
| Versione | Opzioni di creazione del database | Opzioni di conversione dell'architettura | Destinazioni di aggiornamento alla versione principale |
| --- | --- | --- | --- |
| Oracle Database 21c | Solo architettura CDB | N/D | N/D |
| Oracle Database 19c | Architettura CDB o non CDB | Architettura da non CDB a CDB (aggiornamento della versione di aprile 2021 o versione successiva) | CDB Oracle Database 21c |
Come mostrato nella tabella precedente, non è possibile aggiornare direttamente un database non CDB a database CDB in una nuova versione principale del database. Tuttavia, è possibile convertire un database non CDB Oracle Database 19c in database CDB Oracle Database 19c CDB e quindi aggiornarlo a database CDB Oracle Database 21c. Per ulteriori informazioni, consulta [Conversione di un database non CDB RDS per Oracle in un database CDB](oracle-cdb-converting.md).
### Opzioni di conversione per le configurazioni dell'architettura CDB
La tabella seguente mostra le diverse opzioni per la conversione della configurazione dell'architettura di un'istanza database RDS per Oracle.
| Architettura e configurazione correnti | Conversione dell'architettura CDB alla configurazione a tenant singolo | Conversione dell'architettura CDB alla configurazione multi-tenant | Conversione all'architettura non CDB |
| --- | --- | --- | --- |
| Non CDB | Supportata | Supportato\$1 | N/D |
| CDB che utilizza la configurazione a tenant singolo | N/D | Supportata | Non supportata |
| CDB che utilizza la configurazione multi-tenant | Non supportata | N/D | Non supportata |
\$1 Non è possibile convertire un database non CDB in una configurazione multi-tenant in un'unica operazione. Quando si converte un database non CDB in un database CDB, il CDB si trova nella configurazione a tenant singolo. È possibile convertire la configurazione a tenant singolo in quella multi-tenant in un'operazione separata.
## Account utente e privilegi in un CDB
Nell'architettura multi-tenant Oracle, tutti gli account utente sono utenti comuni o utenti locali. Un utente comune CDB è un utente del database la cui identità e password singole sono note nel root CDB e in ogni PDB esistente e futuro. Al contrario, un utente locale esiste solo in un unico PDB.
L'utente master RDS è un account utente locale nel PDB, a cui viene assegnato un nome quando si crea l'istanza database. Se crei nuovi account utente, anche questi utenti saranno utenti locali che risiedono nel PDB. Non è possibile utilizzare alcun account utente per creare nuovi PDBs o modificare lo stato del PDB esistente.
L'utente `rdsadmin` è un account utente comune. È possibile eseguire pacchetti RDS per Oracle presenti in questo account, ma non è possibile accedere come `rdsadmin`. Per ulteriori informazioni, consulta [About Common Users and Local Users (Informazioni sugli utenti comuni e gli utenti locali)](https://docs.oracle.com/en/database/oracle/oracle-database/19/dbseg/managing-security-for-oracle-database-users.html#GUID-BBBD9904-F2F3-442B-9AFC-8ACDD9A588D8) nella documentazione Oracle.
Per gli utenti master nelle configurazioni multi-tenant e single-tenant, è possibile utilizzare credenziali autogestite o gestite da. Gestione dei segreti AWS Nella configurazione a tenant singolo, si utilizzano i comandi della CLI a livello di istanza, ad esempio `create-db-instance` per le password master gestite. Nella configurazione multi-tenant, si utilizzano i comandi di database del tenant, ad esempio `create-tenant-database` per le password master gestite. Per ulteriori informazioni sull’integrazione di Secrets Manager, consulta [Gestione della password dell’utente master per un database del tenant RDS per Oracle con Secrets Manager](rds-secrets-manager.md#rds-secrets-manager-tenant).
## Famiglie di gruppi di parametri in un CDB
CDBs hanno le proprie famiglie di gruppi di parametri e i propri valori di parametro predefiniti. Le famiglie di gruppi di parametri CDB sono le seguenti:
+ oracle-ee-cdb-21
+ oracle-se2-cdb-21
+ oracle-ee-cdb-19
+ oracle-se2-cdb-19
## Limitazioni di RDS per Oracle CDBs
RDS per Oracle supporta un sottoinsieme di funzionalità disponibili in un CDB on-premise.
### Limitazioni dei CDB
Le seguenti limitazioni si applicano a RDS per Oracle a livello di CDB:
+ Non è possibile connettersi a un CDB. Ci si connette sempre al database del tenant (PDB) anziché al CDB. Specifica l'endpoint per il PDB proprio come per un non CDB. L'unica differenza è che si specifica *pdb\$1name* come nome del database, dove *pdb\$1name* è il nome scelto per il PDB.
+ Non è possibile convertire un CDB nella configurazione multi-tenant in un CDB nella conversione a tenant singolo. La conversione alla configurazione multi-tenant è unidirezionale e irreversibile.
+ Non è possibile abilitare o convertire in configurazione multi-tenant se l'istanza database utilizza una versione del database Oracle precedente a 19.0.0.0.ru-2022-01.rur-2022.r1.
+ Non è possibile utilizzare Flussi di attività del database in un CDB.
+ Non è possibile abilitare l’audit dall’interno di `CDB$ROOT`. È necessario abilitare l’audit all’interno di ogni singolo PDB.
### Limitazioni del database del tenant (PDB)
Le seguenti limitazioni si applicano ai database del tenant con la configurazione multi-tenant RDS per Oracle:
+ Non è possibile rimandare le operazioni del database del tenant alla finestra di manutenzione. Tutte le modifiche sono immediatamente effettive.
+ Non è possibile aggiungere un database del tenant a un CDB che utilizza la configurazione a tenant singolo.
+ Non è possibile aggiungere o modificare più database del tenant in un'unica operazione. È possibile aggiungerli o modificarli solo uno alla volta.
+ Non è possibile modificare un database del tenant assegnandogli il nome `CDB$ROOT` o `PDB$SEED`.
+ Non è possibile eliminare un database del tenant se è l'unico tenant nel CDB.
+ Non tutti i tipi di classi di istanze DB dispongono di risorse sufficienti per supportarne più di una PDBs in un'istanza RDS for Oracle CDB. Un numero maggiore di PDB influisce sulle prestazioni e sulla stabilità delle classi di istanza più piccole e aumenta il tempo della maggior parte delle operazioni a livello di istanza, ad esempio gli aggiornamenti del database.
+ Non è possibile rinominare un PDB utilizzando`rdsadmin.rdsadmin_util.rename_global_name`, è necessario utilizzare invece l'API. `modify-tenant-database`
+ Non è possibile utilizzarne più di uno Account AWS per creare PDBs nello stesso CDB. PDBsdevono appartenere allo stesso account dell'istanza DB su cui PDBs sono ospitati.
+ Tutti PDBs in un CDB utilizzano lo stesso endpoint e lo stesso listener del database.
+ Le seguenti operazioni non sono supportate a livello di PDB ma sono supportate a livello di CDB:
+ Backup e ripristino
+ Aggiornamenti del database
+ Operazioni di manutenzione
+ Le seguenti funzionalità non sono supportate a livello di PDB ma sono supportate a livello di CDB:
+ Gruppi di opzioni (le opzioni sono installate PDBs su tutte le istanze CDB)
+ Gruppi di parametri (tutti i parametri derivano dal gruppo di parametri associato all'istanza CDB)
+ Le operazioni a livello di PDB supportate nell'architettura CDB on-premise ma non supportate in un CDB RDS per Oracle sono:
**Nota**
Il seguente elenco non è esaustivo.
+ Applicazione PDBs
+ Proxy PDBs
+ Avvio e arresto di un PDB
+ Scollegare e collegare PDBs
Per spostare i dati dentro o fuori dal CDB, utilizzare le stesse tecniche valide per un database non CDB. Per ulteriori informazioni sulla migrazione dei dati, consulta [Importazione di dati in Oracle in Amazon RDS](Oracle.Procedural.Importing.md).
+ Impostazione delle opzioni a livello di PDB
Il PDB eredita le impostazioni delle opzioni dal gruppo di opzioni del CDB. Per ulteriori informazioni sulle impostazioni delle opzioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md). Per le best practice, consulta [Utilizzo di gruppi di parametri di database](CHAP_BestPractices.md#CHAP_BestPractices.DBParameterGroup).
+ Configurazione dei parametri in un PDB
Il PDB eredita le impostazioni dei parametri dal CDB. Per ulteriori informazioni sull'impostazione dell'opzione, consulta [Aggiunta di opzioni alle istanze database Oracle](Appendix.Oracle.Options.md).
+ Configurazione di diversi listener per lo stesso CDB PDBs
+ Funzionalità di Oracle Flashback
# Configurazione di un CDB RDS per Oracle
La configurazione di un CDB è simile alla configurazione di un database non CDB.
**Topics**
+ [Creazione di un'istanza CDB RDS per Oracle](#Oracle.Concepts.single-tenant.creation)
+ [Connessione a un PDB nel CDB RDS per Oracle](#Oracle.Concepts.connecting.pdb)
## Creazione di un'istanza CDB RDS per Oracle
In RDS per Oracle, la procedura per la creazione di un’istanza CDB è quasi identica alla creazione di un database non CDB. La differenza risiede nella selezione dell'architettura multitenant Oracle quando viene creata l'istanza database e viene scelta anche la configurazione dell'architettura: multi-tenant o tenant singolo. Se si creano i tag quando si crea un CDB nella configurazione multi-tenant, RDS propaga i tag al database del tenant iniziale. Per creare un CDB, usa l' Console di gestione AWS API AWS CLI, the o RDS.
### Console
**Creazione di un'istanza database**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegli l'istanza CDB Regione AWS in cui desideri creare l'istanza CDB.
1. Nel riquadro di navigazione, scegliere **Databases** (Database).
1. Scegliere **Create database (Crea database)**.
1. In **Choose a database creation method (Seleziona metodo di creazione del database)**, scegliere **Standard Create (Creazione standard)**.
1. In **Engine options (Opzioni motore)**, selezionare **Oracle**.
1. In **Tipo di gestione del database**, selezionare **Amazon RDS**.
1. In **Impostazioni dell'architettura**, scegli **Architettura multitenant Oracle**.
1. Per **Configurazione dell'architettura**, effettua una delle seguenti operazioni:
+ Scegli **Configurazione multi-tenant** e procedi con il passaggio successivo.
+ Scegli **Configurazione a tenant singolo** e vai alla fase 11.
1. (Configurazione multi-tenant) Per **Impostazioni globali del tenant**, apporta le seguenti modifiche:
+ Per **Nome del database tenant** immetti il nome del PDB. Il nome del PDB deve essere diverso dal nome del CDB, che per impostazione predefinita è `RDSCDB`.
+ Per **Nome utente principale del database tenant**, specifica il nome dell'utente principale del PDB. Non è possibile utilizzare il nome utente principale del database del tenant per accedere al CDB.
+ Per **Gestione delle credenziali**, scegli una delle seguenti opzioni:
+ **Gestito in Gestione dei segreti AWS**
La password gestita è quella utilizzata per il database del tenant iniziale anziché quella per l’istanza. In **Seleziona la chiave di crittografia**, scegli una chiave KMS creata da Secrets Manager o una chiave creata personalmente.
**Nota**
Consigliamo Gestione dei segreti AWS come tecnica più sicura per la gestione delle credenziali. Si applicano costi aggiuntivi. Per ulteriori informazioni, consulta [Gestione delle password con Amazon RDS e Gestione dei segreti AWS](rds-secrets-manager.md).
+ **Gestione autonoma**
Per specificare una password, deseleziona la casella di controllo **Genera automaticamente una password** se è selezionata. Inserisci la stessa password in **Password master** e **Conferma password**.
+ Per **Set di caratteri del database tenant**, scegli un set di caratteri per il PDB. È possibile scegliere un set di caratteri del database del tenant diverso dal set di caratteri del CDB.
Il set di caratteri PDB predefinito è **AL32UTF8**. Se scegli un set di caratteri del PDB non predefinito, la creazione del CDB potrebbe essere più lenta.
**Nota**
Non è possibile specificare più database del tenant durante l’operazione di creazione. Il CDB ha un solo PDB quando viene creato. È possibile aggiungere PDBs a un CDB esistente in un'operazione separata.
1. (Configurazione a tenant singolo) Scegli le impostazioni desiderate in base alle opzioni elencate in [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md):
1. Nella sezione **Settings (Impostazioni)**, aprire **Credential Settings (Impostazioni credenziali)**. Quindi, esegui queste operazioni:
1. In **Nome utente master**, immettere il nome di un utente locale nel PDB. Non è possibile utilizzare il nome utente master per accedere alla root del CDB.
1. Per **Gestione delle credenziali**, scegli una delle seguenti opzioni:
+ **Gestito in Gestione dei segreti AWS**
In **Seleziona la chiave di crittografia**, scegli una chiave KMS creata da Secrets Manager o una chiave creata personalmente.
**Nota**
Consigliamo Gestione dei segreti AWS come tecnica più sicura per la gestione delle credenziali. Si applicano costi aggiuntivi. Per ulteriori informazioni, consulta [Gestione delle password con Amazon RDS e Gestione dei segreti AWS](rds-secrets-manager.md).
+ **Gestione autonoma**
Per specificare una password, deseleziona la casella di controllo **Genera automaticamente una password** se è selezionata. Inserisci la stessa password in **Password master** e **Conferma password**.
1. Per le restanti sezioni, specifica le impostazioni dell'istanza database. Per informazioni su ciascuna impostazione, consulta [Impostazioni per le istanze database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_CreateDBInstance.Settings.html).
1. Scegliere **Crea database**.
### AWS CLI
Per creare un CDB nella configurazione multi-tenant, utilizzate il [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html)comando con i seguenti parametri:
+ `--db-instance-identifier`
+ `--db-instance-class`
+ `--engine { oracle-ee-cdb | oracle-se2-cdb }`
+ `--master-username`
+ `--master-user-password` o `--manage-master-user-password`
+ `--multi-tenant` (per la configurazione a tenant singolo, non specificare `multi-tenant` o specifica `--no-multi-tenant`)
+ `--allocated-storage`
+ `--backup-retention-period`
Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
L'esempio seguente crea un'istanza DB RDS for Oracle denominata *my-cdb-inst* nella configurazione multi-tenant. Se si specifica `--no-multi-tenant` o non si specifica `--multi-tenant`, la configurazione CDB predefinita è a tenant singolo. Il motore è `oracle-ee-cdb`: un comando che specifica `oracle-ee` e `--multi-tenant` non riesce con un errore. Il database dei tenant iniziali è denominato. *mypdb*
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-db-instance \
2. --engine oracle-ee-cdb \
3. --db-instance-identifier my-cdb-inst \
4. --multi-tenant \
5. --db-name mypdb \
6. --allocated-storage 250 \
7. --db-instance-class db.t3.large \
8. --master-username pdb_admin \
9. --manage-master-user-password \
10. --backup-retention-period 3
```
Per Windows:
```
1. aws rds create-db-instance ^
2. --engine oracle-ee-cdb ^
3. --db-instance-identifier my-cdb-inst ^
4. --multi-tenant ^
5. --db-name mypdb ^
6. --allocated-storage 250 ^
7. --db-instance-class db.t3.large ^
8. --master-username pdb_admin ^
9. --manage-master-user-password \ ^
10. --backup-retention-period 3
```
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Questo comando genera un output simile al seguente. Il nome del database, il set di caratteri, il set di caratteri nazionali, l’utente master e il relativo segreto non sono inclusi nell’output. È possibile visualizzare queste informazioni utilizzando il comando CLI `describe-tenant-databases`.
```
1. {
2. "DBInstance": {
3. "DBInstanceIdentifier": "my-cdb-inst",
4. "DBInstanceClass": "db.t3.large",
5. "MultiTenant": true,
6. "Engine": "oracle-ee-cdb",
7. "DBResourceId": "db-ABCDEFGJIJKLMNOPQRSTUVWXYZ",
8. "DBInstanceStatus": "creating",
9. "AllocatedStorage": 250,
10. "PreferredBackupWindow": "04:59-05:29",
11. "BackupRetentionPeriod": 3,
12. "DBSecurityGroups": [],
13. "VpcSecurityGroups": [
14. {
15. "VpcSecurityGroupId": "sg-0a1bcd2e",
16. "Status": "active"
17. }
18. ],
19. "DBParameterGroups": [
20. {
21. "DBParameterGroupName": "default.oracle-ee-cdb-19",
22. "ParameterApplyStatus": "in-sync"
23. }
24. ],
25. "DBSubnetGroup": {
26. "DBSubnetGroupName": "default",
27. "DBSubnetGroupDescription": "default",
28. "VpcId": "vpc-1234567a",
29. "SubnetGroupStatus": "Complete",
30. ...
```
### API RDS
Per creare un'istanza DB utilizzando l'API Amazon RDS, chiama l'DBInstanceoperazione [Create](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html).
Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
## Connessione a un PDB nel CDB RDS per Oracle
È possibile utilizzare un'utilità come SQL\$1Plus per connettersi a un PDB. Per scaricare Oracle Instant Client, che include una versione autonoma di SQL\$1Plus, consulta [Download di Oracle Instant Client](https://www.oracle.com/database/technologies/instant-client/downloads.html).
Per stabilire la connessione tra SQL\$1Plus e il PDB, è necessario includere le seguenti informazioni:
+ Nome del PDB
+ Nome utente e password del database
+ Endpoint dell'istanza database
+ Numero della porta
Per informazioni su come trovare le informazioni precedenti, consulta [Esito dell'endpoint dell'istanza database RDS per Oracle](USER_Endpoint.md).
**Example Connessione al PDB tramite SQL\$1Plus**
Negli esempi seguenti, sostituisci il tuo utente principale con. *master\$1user\$1name* Sostituire inoltre l'endpoint dell'istanza database e quindi includere il numero di porta e il SID Oracle. Il valore SID è il nome del PDB specificato al momento della creazione dell'istanza database e non l'identificatore dell'istanza database.
Per Linux, macOS o Unix:
```
1. sqlplus 'master_user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=endpoint)(PORT=port))(CONNECT_DATA=(SID=pdb_name)))'
```
Per Windows:
```
1. sqlplus master_user_name@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=endpoint)(PORT=port))(CONNECT_DATA=(SID=pdb_name)))
```
Verrà visualizzato un output simile al seguente.
```
SQL*Plus: Release 19.0.0.0.0 Production on Mon Aug 21 09:42:20 2021
```
Dopo l'immissione della password dell'utente, verrà visualizzato il prompt SQL.
```
SQL>
```
**Nota**
Il formato più breve della stringa di connessione (Easy connect o EZCONNECT), ad esempio `sqlplus username/password@LONGER-THAN-63-CHARS-RDS-ENDPOINT-HERE:1521/database-identifier`, potrebbe comportare un limite relativo al numero massimo di caratteri e non deve pertanto essere utilizzato per la connessione.
# Backup e ripristino di un CDB
È possibile eseguire il backup e il ripristino del CDB utilizzando snapshot di database RDS o Recovery Manager (RMAN).
## Backup e ripristino di un CDB utilizzando snapshot di database
Gli snapshot di database funzionano in modo simile nelle architetture CDB e non CDB. Le differenze principali sono le seguenti:
+ Quando ripristini uno snapshot di database di un CDB, non puoi rinominare il CDB. Per impostazione predefinita, il CDB viene denominato `RDSCDB` e il nome non può essere modificato.
+ Quando ripristini un'istantanea DB di un CDB, non puoi rinominare. PDBs È possibile modificare il nome PDB utilizzando il comando. [modify-tenant-database](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyTenantDatabase.html)
+ [Per trovare i database tenant in un'istantanea, usa il comando CLI -databases. describe-db-snapshot-tenant](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBSnapshotTenantDatabases.html)
+ Non è possibile interagire direttamente con i database del tenant in uno snapshot CDB che utilizza la configurazione dell'architettura multi-tenant. Se ripristini lo snapshot di database, ripristini tutti i relativi database del tenant.
+ RDS per Oracle copia implicitamente i tag di un database del tenant nel database del tenant di uno snapshot di database. Quando si ripristina un database del tenant, i tag vengono visualizzati nel database ripristinato.
+ Se si ripristina uno snapshot di database e si specificano nuovi tag utilizzando il parametro `--tags`, i nuovi tag sovrascrivono tutti i tag esistenti.
+ Se si esegue uno snapshot di database di un'istanza CDB con tag e si specifica `--copy-tags-to-snapshot`, RDS per Oracle copia i tag dai database del tenant ai database del tenant presenti nello snapshot.
Per ulteriori informazioni, consulta [Considerazioni su Oracle Database](USER_RestoreFromSnapshot.md#USER_RestoreFromSnapshot.Oracle).
## Backup e ripristino di un CDB utilizzando RMAN
Per informazioni su come eseguire il backup e il ripristino di un CDB o di un database a tenant singolo utilizzando RMAN, consulta [Esecuzione di attività RMAN comuni per le istanze database Oracle](Appendix.Oracle.CommonDBATasks.RMAN.md).
# Conversione di un database non CDB RDS per Oracle in un database CDB
È possibile modificare l’architettura di un database Oracle e passare da un’architettura non CDB a un’architettura multitenant Oracle, chiamata anche *architettura CDB*, utilizzando il comando `modify-db-instance`. Nella maggior parte dei casi, questa tecnica è preferibile alla creazione di un nuovo CDB e all’importazione dei dati. L’operazione di conversione comporta un tempo di inattività.
Quando si aggiorna la versione del motore di database, non è possibile modificare l'architettura del database durante la stessa operazione. Pertanto, per aggiornare un database non CDB Oracle Database 19c a un database CDB Oracle Database 21c, è necessario prima convertire il database non CDB in un database CDB in un passaggio, quindi aggiornare il CDB 19c risultante a database CDB 21c in un passaggio separato.
I requisiti dell'operazione di conversione non CDB sono elencati di seguito:
+ È necessario specificare `oracle-ee-cdb` o `oracle-se2-cdb` per il tipo di motore di database. Questi sono gli unici valori supportati.
+ Il motore di database deve utilizzare Oracle Database 19c con un aggiornamento della versione di aprile 2021 o successive.
L'operazione presenta le seguenti limitazioni:
+ Non è possibile convertire un database CDB in un database non CDB. È solo possibile convertire un database non CDB in un database CDB.
+ Non è possibile convertire una configurazione non CDB in una configurazione multi-tenant in una singola chiamata `modify-db-instance`. Dopo aver convertito un database non CDB in un database CDB, il CDB è nella configurazione a tenant singolo. Per convertire la configurazione a tenant singolo in quella multi-tenant, esegui nuovamente `modify-db-instance`. Per ulteriori informazioni, consulta [Conversione della configurazione a tenant singolo in multi-tenant](oracle-single-tenant-converting.md).
+ Non è possibile convertire un database primario o di replica con Oracle Data Guard abilitato. Per convertire un non CDB con repliche di lettura, elimina prima tutte le repliche di lettura.
+ Non è possibile aggiornare la versione del motore di database e convertire un database non CDB in un database CDB durante la stessa operazione.
Prima di convertire un’istanza non CDB, considera quanto segue:
+ Le considerazioni relative ai gruppi di opzioni e parametri sono le stesse valide per l'aggiornamento del motore di database. Per ulteriori informazioni, consulta [Considerazioni sugli aggiornamenti per Oracle Database](USER_UpgradeDBInstance.Oracle.OGPG.md).
+ È possibile convertire con un’unica operazione le istanze non CDB esistenti che utilizzano password master gestite in istanze a tenant singolo. Le istanze a tenant singolo ereditano le password gestite.
+ Se per un’istanza database è installata l’opzione `OEMAGENT`, è consigliabile rimuovere questa opzione prima di convertire l’istanza non CDB. Dopo aver convertito l’istanza non CDB in CDB, reinstalla l’opzione. Per ulteriori informazioni, consulta [Oracle Management Agent per Enterprise Manager Cloud Control](Oracle.Options.OEMAgent.md).
+ Durante il processo di conversione, RDS reimposta la dimensione predefinita di 128 MB per i log di redo online.
## Console
**Conversione di un database non CDB in un database CDB**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegliere la Regione AWS in cui si trova l'istanza database.
1. Nel riquadro di navigazione, scegliere **Database** e quindi l'istanza non CDB da convertire in istanza CDB.
1. Scegliere **Modify (Modifica)**.
1. In **Impostazioni dell'architettura**, seleziona **Architettura multitenant Oracle**. Dopo la conversione, il CDB sarà nella configurazione a tenant singolo.
1. (Facoltativo) In **Gruppo di parametri database**, scegliere un nuovo gruppo di parametri per l'istanza CDB. Le stesse considerazioni relative ai gruppi di parametri valgono per la conversione di un'istanza database e per l'aggiornamento di un'istanza database. Per ulteriori informazioni, consulta [Considerazioni sui gruppi di parametri](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.PG).
1. (Facoltativo) In **Gruppo di opzioni**, selezionare un nuovo gruppo di opzioni per l'istanza CDB. Le stesse considerazioni relative ai gruppi di opzioni valgono per la conversione di un'istanza database e per l'aggiornamento di un'istanza database. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
1. (Facoltativo) Per **Gestione delle credenziali**, scegli **Gestione in Gestione dei segreti AWS** o **Gestione autonoma**. Per ulteriori informazioni, consulta [Gestione della password dell'utente master per un'istanza database con Secrets Manager](rds-secrets-manager.md#rds-secrets-manager-db-instance).
1. Quando tutte le modifiche sono come le desideri, seleziona **Continue (Continua)** e controlla il riepilogo delle modifiche.
1. (Facoltativo) Scegliere **Applica immediatamente** per applicare immediatamente le modifiche. In alcuni casi, la chiusura di questa opzione può causare un'interruzione. Per ulteriori informazioni, consulta [Utilizzo dell’impostazione della pianificazione delle modifiche](USER_ModifyInstance.ApplyImmediately.md).
1. Nella pagina di conferma esaminare le modifiche. Se sono corrette, selezionare **Modifica istanza database**.
Oppure scegliere **Back (Indietro)** per cambiare le modifiche o **Cancel (Annulla)** per annullare le modifiche.
## AWS CLI
Per convertire un database non CDB nell'istanza database in un database CDB nella configurazione a tenant singolo, imposta `--engine` su `oracle-ee-cdb` o `oracle-se2-cdb` nel comando AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Per ulteriori informazioni, consulta [Impostazioni per istanze database](USER_ModifyInstance.Settings.md).
L'esempio seguente converte l'istanza database denominata *my-non-cdb* e specifica un gruppo di opzioni e un gruppo di parametri personalizzati. Il comando abilita anche la gestione delle password con Secrets Manager.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my-non-cdb \
--engine oracle-ee-cdb \
--option-group-name custom-option-group \
--db-parameter-group-name custom-parameter-group \
--manage-master-user-password
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my-non-cdb ^
--engine oracle-ee-cdb ^
--option-group-name custom-option-group ^
--db-parameter-group-name custom-parameter-group ^
--manage-master-user-password
```
## API RDS
Per convertire un database non CDB in un database CDB, specificare `Engine` nell'operazione dell'API RDS l'operazione [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html).
# Conversione della configurazione a tenant singolo in multi-tenant
È possibile modificare l'architettura di un CDB RDS per Oracle dalla configurazione a tenant singolo alla configurazione multi-tenant. Prima e dopo la conversione, il CDB contiene un database a tenant singolo (PDB). I tag per l’istanza database si propagano al database del tenant iniziale creato durante la conversione.
Prima di iniziare, è necessario assicurarsi che la policy IAM disponga delle autorizzazioni necessarie per creare un database del tenant. Durante la conversione, RDS per Oracle migra i seguenti metadati nel nuovo database del tenant:
+ Il nome utente principale
+ La password master gestita (se il CDB di origine si integra con Secrets Manager)
+ Il nome del database
+ Il set di caratteri
+ Il set di caratteri nazionali
Prima della conversione, è possibile visualizzare le informazioni precedenti utilizzando il comando `describe-db-instances`. Dopo la conversione, è possibile visualizzare le informazioni utilizzando il comando `describe-tenant-database`.
La conversione da tenant singolo a multi-tenant presenta le seguenti limitazioni:
+ Non è possibile riconvertire la configurazione multi-tenant in configurazione a tenant singolo dopo una conversione in configurazione multi-tenant. La conversione è irreversibile.
+ Non è possibile convertire un database primario o di replica con Oracle Data Guard abilitato.
+ Non è possibile aggiornare la versione del motore di database e convertire nella configurazione multi-tenant durante la stessa operazione.
+ Non è possibile abilitare o disabilitare le password di utente master gestite durante la conversione.
## Console
**Per convertire un CDB con la configurazione a tenant singolo in quella multi-tenant**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegliere la Regione AWS in cui si trova l'istanza database.
1. Nel riquadro di navigazione, scegliere **Database** e quindi l'istanza non CDB da convertire in istanza CDB.
1. Scegli **Modifica**.
1. In **Impostazioni dell'architettura**, seleziona **Architettura multitenant Oracle**.
1. Per **Configurazione dell'architettura** seleziona **Configurazione multi-tenant**.
1. (Facoltativo) In **Gruppo di parametri database**, scegliere un nuovo gruppo di parametri per l'istanza CDB. Le stesse considerazioni relative ai gruppi di parametri valgono per la conversione di un'istanza database e per l'aggiornamento di un'istanza database.
1. (Facoltativo) In **Gruppo di opzioni**, selezionare un nuovo gruppo di opzioni per l'istanza CDB. Le stesse considerazioni relative ai gruppi di opzioni valgono per la conversione di un'istanza database e per l'aggiornamento di un'istanza database.
1. Quando tutte le modifiche sono come le desideri, seleziona **Continue (Continua)** e controlla il riepilogo delle modifiche.
1. Scegliere **Apply immediately** (Applica immediatamente). Questa opzione è necessaria quando si passa a una configurazione multi-tenant. Tieni presente che questa opzione può causare tempi di inattività in alcuni casi.
1. Nella pagina di conferma esaminare le modifiche. Se sono corrette, selezionare **Modifica istanza database**.
Oppure scegliere **Back (Indietro)** per cambiare le modifiche o **Cancel (Annulla)** per annullare le modifiche.
## AWS CLI
Per convertire un CDB utilizzando la configurazione single-tenant in una configurazione multi-tenant, specifica nel comando. `--multi-tenant` AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)
L'esempio seguente converte l'istanza database denominata `my-st-cdb` dalla configurazione a tenant singolo alla configurazione multi-tenant. L'opzione `--apply-immediately` è obbligatoria.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance --region us-east-1\
--db-instance-identifier my-st-cdb \
--multi-tenant \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-instance --region us-east-1 ^
--db-instance-identifier my-st-cdb ^
--multi-tenant ^
--apply-immediately
```
L'output è simile al seguente.
```
{
"DBInstance": {
"DBInstanceIdentifier": "my-st-cdb",
"DBInstanceClass": "db.r5.large",
"MultiTenant": false,
"Engine": "oracle-ee-cdb",
"DBResourceId": "db-AB1CDE2FGHIJK34LMNOPRLXTXU",
"DBInstanceStatus": "modifying",
"MasterUsername": "admin",
"DBName": "ORCL",
...
"EngineVersion": "19.0.0.0.ru-2022-01.rur-2022-01.r1",
"AutoMinorVersionUpgrade": true,
"ReadReplicaDBInstanceIdentifiers": [],
"LicenseModel": "bring-your-own-license",
"OptionGroupMemberships": [
{
"OptionGroupName": "default:oracle-ee-cdb-19",
"Status": "in-sync"
}
],
...
"PendingModifiedValues": {
"MultiTenant": "true"
}
}
}
```
# Aggiunta di un database del tenant RDS per Oracle all'istanza CDB
Nella configurazione multi-tenant RDS per Oracle, un database del tenant è un PDB. Per aggiungere un database del tenant, verifica che siano soddisfatti i seguenti prerequisiti:
+ Il CDB ha la configurazione multi-tenant abilitata. Per ulteriori informazioni, consulta [Configurazione multi-tenant dell'architettura CDB](Oracle.Concepts.CDBs.md#multi-tenant-configuration).
+ Disponi delle necessarie autorizzazioni IAM per creare il database del tenant.
È possibile aggiungere un database tenant utilizzando l' Console di gestione AWS API AWS CLI, the o RDS. Non è possibile aggiungere più database del tenant in un'unica operazione pertanto è necessario aggiungerli uno alla volta. Se il CDB ha la conservazione dei backup abilitata, Amazon RDS esegue il backup dell'istanza database prima e dopo l'aggiunta di un nuovo database del tenant. Se il CDB ha repliche di lettura, puoi solo aggiungere un database tenant all'istanza DB principale; Amazon RDS crea automaticamente il database tenant sulle repliche. Viene inoltre convalidato lo stato della replica, assicurando che tutte le repliche siano disponibili e che il ritardo di replica sia inferiore a 5 minuti prima della creazione del tenant.
## Console
**Per aggiungere un database del tenant all'istanza database**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegli la Regione AWS in cui desideri creare il database del tenant.
1. Nel pannello di navigazione, seleziona **Database**.
1. Scegli l'istanza CDB in cui aggiungere un database del tenant. L'istanza database deve utilizzare la configurazione multi-tenant dell'architettura CDB.
1. Scegli **Operazioni**, quindi **Aggiungi database del tenant**.
1. Per **Impostazioni globali del database** effettua le seguenti operazioni:
+ Per **Nome del database tenant** immetti il nome del nuovo PDB.
+ Per **Nome utente principale del database tenant**, specifica il nome dell'utente principale per il PDB.
+ Scegli una delle seguenti opzioni di gestione delle credenziali:
+ **Gestito in Gestione dei segreti AWS**
In **Seleziona la chiave di crittografia**, scegli una chiave KMS creata da Secrets Manager o una chiave creata personalmente.
**Nota**
Consigliamo Gestione dei segreti AWS come tecnica più sicura per la gestione delle credenziali. Si applicano costi aggiuntivi. Gestione dei segreti AWS non è supportato per le istanze che utilizzano repliche di lettura. Per ulteriori informazioni, consulta [Gestione delle password con Amazon RDS e Gestione dei segreti AWS](rds-secrets-manager.md).
+ **Gestione autonoma**
Per specificare una password, deseleziona la casella di controllo **Genera automaticamente una password** se è selezionata. Inserisci la stessa password in **Password master** e **Conferma password**.
+ In **Configurazione aggiuntiva**, inserisci il nome del tuo PDB per **Nome database iniziale**. Non è possibile assegnare un nome al CDB, che ha `RDSCDB` come nome predefinito.
+ Per **Set di caratteri del database tenant**, scegli un set di caratteri per il PDB. Il valore predefinito è **AL32UTF8**. È possibile scegliere un set di caratteri del PDB diverso dal set di caratteri del CDB. Se l'istanza contiene repliche di lettura, i tenant non possono essere creati con un set di caratteri personalizzato. È possibile creare i tenant con un set di caratteri personalizzato prima di creare una replica di lettura, se necessario.
+ Per **Set di caratteri nazionali del database tenant**, scegli un set di caratteri per il PDB. Il valore predefinito è **AL32UTF8**. Il set di caratteri nazionali specifica la codifica solo per le colonne che utilizzano il tipo di dati `NCHAR` (`NCHAR`, `NVARCHAR2` e `NCLOB`) e non influisce sui metadati del database.
Per ulteriori informazioni sulle impostazioni precedenti, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md).
1. Scegli **Aggiungi tenant**.
## AWS CLI
Per aggiungere un database dei tenant al tuo CDB con AWS CLI, usa il comando [create-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/create-tenant-database.html)con i seguenti parametri richiesti:
+ `--db-instance-identifier`
+ `--tenant-db-name`
+ `--master-username`
+ `--master-user-password`
L'esempio seguente crea un database tenant denominato *mypdb2* nell'istanza CDB RDS for Oracle denominata. *my-cdb-inst* Il set di caratteri del PDB è `UTF-16`.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name mypdb2 \
4. --master-username mypdb2-admin \
5. --master-user-password mypdb2-pwd \
6. --character-set-name UTF-16
```
Per Windows:
```
1. aws rds create-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name mypdb2 ^
4. --master-username mypdb2-admin ^
5. --master-user-password mypdb2-pwd ^
6. --character-set-name UTF-16
```
L'output è simile al seguente.
```
...}
"TenantDatabase" :
{
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:mypdb2",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "mypdb2",
"Status" : "creating",
"MasterUsername" : "mypdb2",
"CharacterSetName" : "UTF-16",
...
}
}...
```
# Modifica di un database del tenant RDS per Oracle
È possibile modificare solo il nome PDB e la password dell'utente principale di un database del tenant nel CDB. Tieni presenti i seguenti requisiti e limitazioni:
+ Per modificare le impostazioni di un database del tenant nell'istanza database, il database del tenant deve esistere.
+ Non è possibile modificare più database del tenant in un'unica operazione. È possibile modificare un solo database del tenant alla volta.
+ Non è possibile modificare il nome di un database del tenant in `CDB$ROOT` o `PDB$SEED`.
+ Se l'istanza DB dispone di repliche di lettura, è possibile modificare solo i tenant sull'istanza DB principale. Viene inoltre convalidato lo stato della replica, assicurando che le repliche siano disponibili e che il ritardo di replica sia inferiore a 5 minuti prima della modifica del tenant.
È possibile modificare PDBs utilizzando Console di gestione AWS, the o l'API RDS. AWS CLI
## Console
**Per modificare il nome PDB o la password principale di un database del tenant**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegli la Regione AWS in cui desideri creare il database del tenant.
1. Nel pannello di navigazione, seleziona **Database**.
1. Scegli il database del tenant di cui desideri modificare il nome del database o la password dell'utente principale.
1. Scegli **Modifica**.
1. Per **Impostazioni globali del database** effettua una delle seguenti operazioni:
+ Per **Nome del database tenant** immetti il nuovo nome del nuovo PDB.
+ Per **Password principale del database tenant**, immetti una nuova password.
1. Scegli **Modifica tenant**.
## AWS CLI
Per modificare un database tenant utilizzando il AWS CLI, chiama il [modify-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-tenant-database.html)comando con i seguenti parametri:
+ `--db-instance-identifier` *value*
+ `--tenant-db-name value`
+ `[--new-tenant-db-name value]`
+ `[--master-user-password value]`
L'esempio seguente rinomina il database del tenant `pdb1` in `pdb-hr` nell'istanza database `my-cdb-inst`.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds modify-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb1 \
4. --new-tenant-db-name pdb-hr
```
Per Windows:
```
1. aws rds modify-tenant-database --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb1 ^
4. --new-tenant-db-name pdb-hr
```
Questo comando genera un output simile al seguente.
```
{
"TenantDatabase" : {
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb1",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb1",
"Status" : "modifying",
"MasterUsername" : "tenant-admin-user"
"Port" : "6555",
"CharacterSetName" : "UTF-16",
"MaxAllocatedStorage" : "1000",
"ParameterGroups": [
{
"ParameterGroupName": "pdb1-params",
"ParameterApplyStatus": "in-sync"
}
],
"OptionGroupMemberships": [
{
"OptionGroupName": "pdb1-options",
"Status": "in-sync"
}
],
"PendingModifiedValues": {
"TenantDBName": "pdb-hr"
}
}
}
```
# Eliminazione di un database del tenant RDS per Oracle dal CDB
È possibile eliminare un database tenant (PDB) utilizzando l'API Console di gestione AWS AWS CLI, the o RDS. Considera i seguenti prerequisiti e limitazioni:
+ Il database del tenant e l'istanza database devono esistere.
+ Affinché l'eliminazione abbia esito positivo, è necessario che si verifichi una delle seguenti situazioni:
+ Il database del tenant e l'istanza database sono disponibili.
**Nota**
È possibile acquisire uno snapshot finale, ma solo se il database del tenant e l'istanza database erano disponibili prima dell'emissione del comando `delete-tenant-database`. Questa istantanea verrà scattata sull'istanza principale solo se l'istanza DB contiene repliche di lettura.
+ Il database del tenant è in fase di creazione.
+ L'istanza database sta modificando il database del tenant.
+ Se l'istanza DB ha repliche di lettura, questi vincoli si applicano a tutte le repliche.
+ Non è possibile eliminare più database del tenant in un'unica operazione.
+ Non è possibile eliminare un database del tenant se è l'unico tenant nel CDB.
+ Non è possibile eliminare un database tenant su una replica di lettura, è possibile eliminare solo un tenant sull'istanza DB principale. Viene inoltre convalidato lo stato della replica, assicurando che il ritardo di replica sia inferiore a 5 minuti prima dell'eliminazione del tenant.
## Console
**Per eliminare un database del tenant**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegli **Database**, quindi scegli il database del tenant che vuoi eliminare.
1. In **Actions (Azioni)**, selezionare **Delete (Elimina)**.
1. Per creare uno snapshot DB finale per l’istanza database, abilitare **Create final snapshot? (Crea snapshot finale?)**.
1. Se si è scelto di creare uno snapshot finale, immettere il **Final snapshot name (Nome dello snapshot finale)**.
1. Immettere **delete me** nella casella.
1. Scegliere **Delete (Elimina)**.
## AWS CLI
Per eliminare un database tenant utilizzando il AWS CLI, chiama il [delete-tenant-database](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-tenant-database.html)comando con i seguenti parametri:
+ `--db-instance-identifier value`
+ `--tenant-db-name value`
+ `[--skip-final-snapshot | --no-skip-final-snapshot]`
+ `[--final-snapshot-identifier value]`
L'esempio seguente elimina il database dei tenant denominato *pdb-test* dal CDB denominato. *my-cdb-inst* Per impostazione predefinita, l'operazione crea uno snapshot finale.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds delete-tenant-database --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb-test \
4. --final-snapshot-identifier final-snap-pdb-test
```
Per Windows:
```
1. aws rds delete-tenant-database --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb-test ^
4. --final-snapshot-identifier final-snap-pdb-test
```
Questo comando genera un output simile al seguente.
```
{
"TenantDatabase" : {
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac456",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb-test",
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb-test",
"Status" : "deleting",
"MasterUsername" : "pdb-test-admin"
"Port" : "6555",
"CharacterSetName" : "UTF-16",
"MaxAllocatedStorage" : "1000",
"ParameterGroups": [
{
"ParameterGroupName": "tenant-1-params",
"ParameterApplyStatus": "in-sync"
}
],
"OptionGroupMemberships": [
{
"OptionGroupName": "tenant-1-options",
"Status": "in-sync"
}
]
}
}
```
# Visualizzazione dei dettagli del database del tenant
È possibile visualizzare i dettagli su un database del tenant nello stesso modo in cui è possibile visualizzare i dettagli su un database non CDB o CDB.
## Console
**Per visualizzare i dettagli su un database del tenant**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nell'angolo in alto a destra della console Amazon RDS, scegliere la Regione AWS in cui si trova l'istanza database.
1. Nel pannello di navigazione, seleziona **Database**.
![\[Visualizzazione dei dettagli su un CDB\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/cdb-list.png)
Nell'immagine precedente, l'unico database del tenant (PDB) appare come figlio dell'istanza database.
1. Scegli il nome di un database del tenant.
![\[Visualizzazione dei dettagli su un PDB\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/pdb-details.png)
## AWS CLI
Per visualizzare i dettagli sul tuo PDBs, usa il AWS CLI comando [describe-tenant-databases](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-tenant-databases.html).
L'esempio seguente descrive tutti i database del tenant nella regione specificata.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds describe-tenant-databases --region us-east-1
```
Per Windows:
```
1. aws rds describe-tenant-databases --region us-east-1
```
Questo comando genera un output simile al seguente.
```
"TenantDatabases" : [
{
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb-test",
"Status" : "available",
"MasterUsername" : "pdb-test-admin",
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac456",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb-test",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": []
},
{
"DBInstanceIdentifier" : "my-cdb-inst2",
"TenantDBName" : "pdb-dev",
"Status" : "modifying",
"MasterUsername" : "masterrdsuser"
"DbiResourceId" : "db-xyz789",
"TenantDatabaseResourceId" : "tdb-ghp890",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst2:pdb-dev",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": []
},
... other truncated data
```
L'esempio seguente descrive i database del tenant sull'istanza database `my-cdb-inst` nella regione specificata.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds describe-tenant-databases --region us-east-1 \
2. --db-instance-identifier my-cdb-inst
```
Per Windows:
```
1. aws rds describe-tenant-databases --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst
```
Questo comando genera un output simile al seguente.
```
{
"TenantDatabase": {
"TenantDatabaseCreateTime": "2023-10-19T23:55:30.046Z",
"DBInstanceIdentifier": "my-cdb-inst",
"TenantDBName": "pdb-hr",
"Status": "creating",
"MasterUsername": "tenant-admin-user",
"DbiResourceId": "db-abc123",
"TenantDatabaseResourceId": "tdb-bac567",
"TenantDatabaseARN": "arn:aws:rds:us-west-2:579508833180:pdb-hr:tdb-abcdefghi1jklmno2p3qrst4uvw5xy6zabc7defghi8jklmn90op",
"CharacterSetName": "AL32UTF8",
"NcharCharacterSetName": "AL16UTF16",
"DeletionProtection": false,
"PendingModifiedValues": {
"MasterUserPassword": "****"
},
"TagList": [
{
"Key": "TEST",
"Value": "testValue"
}
]
}
}
```
L'esempio seguente descrive il database del tenant `pdb1` su un'istanza database `my-cdb-inst` nella Regione Stati Uniti orientali (Virginia settentrionale).
**Example**
Per Linux, macOS o Unix:
```
1. aws rds describe-tenant-databases --region us-east-1 \
2. --db-instance-identifier my-cdb-inst \
3. --tenant-db-name pdb1
```
Per Windows:
```
1. aws rds describe-tenant-databases --region us-east-1 ^
2. --db-instance-identifier my-cdb-inst ^
3. --tenant-db-name pdb1
```
Questo comando genera un output simile al seguente.
```
{
"TenantDatabases" : [
{
"DbiResourceId" : "db-abc123",
"TenantDatabaseResourceId" : "tdb-bac567",
"TenantDatabaseArn" : "arn:aws:rds:us-east-1:123456789012:db:my-cdb-inst:pdb1"
"DBInstanceIdentifier" : "my-cdb-inst",
"TenantDBName" : "pdb1",
"Status" : "ACTIVE",
"MasterUsername" : "masterawsuser"
"Port" : "1234",
"CharacterSetName": "UTF-8",
"ParameterGroups": [
{
"ParameterGroupName": "tenant-custom-pg",
"ParameterApplyStatus": "in-sync"
}
],
{
"OptionGroupMemberships": [
{
"OptionGroupName": "tenant-custom-og",
"Status": "in-sync"
}
]
}
]
}
```
# Aggiornamento del CDB
È possibile aggiornare un CDB a una versione diversa di Oracle Database. Ad esempio, è possibile aggiornare un database CDB da Oracle Database 19c a Oracle Database 21c. Non è possibile modificare l'architettura del database durante un aggiornamento. Pertanto, non è possibile aggiornare un database non CDB a un database CDB oppure aggiornare un database CDB a un database non CDB.
La procedura per aggiornare un database CDB a un database CDB è la stessa valida per l'aggiornamento da un database CDB non CDB a un database non CDB. Per ulteriori informazioni, consulta [Aggiornamento del motore di database RDS per Oracle](USER_UpgradeDBInstance.Oracle.md).
# Amministrazione dell'istanza database RDS per Oracle
Di seguito sono riportate le attività di gestione comuni che si eseguono con una istanza database RDS per Oracle. Alcune attività sono uguali per tutte le istanze database RDS. Altri invece sono specifiche di RDS for Oracle.
Le attività riportate di seguito sono comuni a tutti i database RDS, ma per Oracle Database è necessario effettuare considerazioni particolari. Ad esempio, per connetterti a un database Oracle si utilizzano i client Oracle SQL\$1Plus e SQL Developer.
****
| Area attività | Documentazione di riferimento |
| --- | --- |
| **Classi delle istanze, storage e PIOPS** Se si sta creando un'istanza di produzione, occorre conoscere il funzionamento di classi di istanza, tipi di storage e IOPS con provisioning in Amazon RDS. | [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md) [Tipi di storage Amazon RDS](CHAP_Storage.md#Concepts.Storage) |
| **Implementazioni Multi-AZ** Un'istanza database in produzione deve utilizzare implementazioni Multi-AZ. Le implementazioni Multi-AZ forniscono alle istanze database maggior disponibilità, longevità dei dati e tolleranza ai guasti. | [Configurazione e gestione di un’implementazione Multi-AZ per Amazon RDS](Concepts.MultiAZ.md) |
| **Amazon VPC** Se il tuo AWS account ha un cloud privato virtuale (VPC) predefinito, l'istanza DB viene creata automaticamente all'interno del VPC predefinito. Se l'account non dispone di un VPC predefinito e desideri che l'istanza database sia in un VPC, è necessario creare il VPC e i gruppi di sottoreti prima di creare l'istanza. | [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md) |
| **Gruppi di sicurezza** Per impostazione predefinita, le istanze database utilizzano un firewall che impedisce l'accesso. Per accedere all'istanza database, assicurati di aver creato un gruppo di sicurezza con gli indirizzi IP e la configurazione di rete corretti. | [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md) |
| **Gruppi di parametri** Se l'istanza database richiede parametri database specifici, crea un gruppo di parametri prima di creare l'istanza database. | [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md) |
| **Gruppi di opzioni** Se l'istanza database richiede opzioni database specifiche, crea un gruppo di opzioni prima di creare l'istanza database. | [Aggiunta di opzioni alle istanze database Oracle](Appendix.Oracle.Options.md) |
| **Connessione all'istanza database** Dopo aver creato un gruppo di sicurezza e averlo associato a un'istanza database, è possibile effettuare la connessione all'istanza database mediante un'applicazione cliente SQL standard, come Oracle SQL Plus. | [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md) |
| **Backup e ripristino** È possibile configurare l'istanza database affinché effettui backup automatici o acquisisca snapshot manuali e poi esegua il ripristino istanze da backup o snapshot. | [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md) |
| **Monitoraggio** Puoi monitorare un'istanza DB Oracle utilizzando i parametri, gli eventi e il monitoraggio avanzato di CloudWatch Amazon RDS. | [Visualizzazione dei parametri nella console Amazon RDS](USER_Monitoring.md) [Visualizzazione di eventi Amazon RDS](USER_ListEvents.md) |
| **File di log** È possibile accedere ai file di log per le istanze database Oracle. | [Monitoraggio dei file di log di Amazon RDS](USER_LogAccess.md) |
Di seguito, è riportata una descrizione per implementazioni specifiche di Amazon RDS di attività DBA comuni per RDS Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. RDS limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati. In molte delle attività, è possibile eseguire il pacchetto `rdsadmin`, che è uno strumento specifico di Amazon RDS che consente di amministrare il database.
Seguono alcune attività DBA comuni per le istanze database che eseguono Oracle:
+ [Attività di sistema](Appendix.Oracle.CommonDBATasks.System.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività di database](Appendix.Oracle.CommonDBATasks.Database.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività di log](Appendix.Oracle.CommonDBATasks.Log.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività RMAN](Appendix.Oracle.CommonDBATasks.RMAN.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Attività Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Diagnosi dei problemi](Appendix.Oracle.CommonDBATasks.Diagnostics.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
+ [Altre attività](Appendix.Oracle.CommonDBATasks.Misc.md)
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.html)
Puoi anche utilizzare le procedure di Amazon RDS per l'integrazione di Amazon S3 con Oracle e per l'esecuzione delle attività di database di OEM Management Agent. Per ulteriori informazioni, consultare [Integrazione Amazon S3](oracle-s3-integration.md) e [Esecuzione delle attività di database con Management Agent](Oracle.Options.OEMAgent.md#Oracle.Options.OEMAgent.DBTasks).
# Esecuzione di attività di sistema comuni per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative al sistema nelle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
**Topics**
+ [Disconnessione di una sessione](Appendix.Oracle.CommonDBATasks.DisconnectingSession.md)
+ [Terminazione di una sessione](Appendix.Oracle.CommonDBATasks.KillingSession.md)
+ [Annullamento di una istruzione SQL in una sessione](Appendix.Oracle.CommonDBATasks.CancellingSQL.md)
+ [Abilitazione e disabilitazione delle sessioni limitate](Appendix.Oracle.CommonDBATasks.RestrictedSession.md)
+ [Scaricamento del pool condiviso](Appendix.Oracle.CommonDBATasks.FlushingSharedPool.md)
+ [Concedere privilegi SELECT o EXECUTE agli oggetti SYS](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md)
+ [Revoca del privilegio SELECT o EXECUTE in oggetti SYS](Appendix.Oracle.CommonDBATasks.RevokePrivileges.md)
+ [Gestione delle viste RDS\$1X\$1 per le istanze database Oracle](Appendix.Oracle.CommonDBATasks.X-dollar.md)
+ [Concessione di privilegi a utenti non-master](Appendix.Oracle.CommonDBATasks.PermissionsNonMasters.md)
+ [Creazione delle funzionalità personalizzate per verificare le password](Appendix.Oracle.CommonDBATasks.CustomPassword.md)
+ [Impostazione di un server DNS personalizzato](#Appendix.Oracle.CommonDBATasks.CustomDNS)
+ [Impostazione e annullamento dell'impostazione degli eventi diagnostici di sistema](Appendix.Oracle.CommonDBATasks.SystemEvents.md)
# Disconnessione di una sessione
Puoi usare la procedura in Amazon RDS per disconnettere la sessione corrente terminando il processo server dedicato `rdsadmin.rdsadmin_util.disconnect`. La procedura `disconnect` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `method` | varchar | “IMMEDIATO” | No | I valori validi sono `'IMMEDIATE'` e `'POST_TRANSACTION'`. |
L'esempio seguente disconnette una sessione.
```
begin
rdsadmin.rdsadmin_util.disconnect(
sid => sid,
serial => serial_number);
end;
/
```
Per ottenere l'identificatore di sessione e il numero di serie di sessione, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni per l'utente `AWSUSER`.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Il database deve essere aperto per utilizzare questo metodo. Per ulteriori informazioni sulla disconnessione di una sessione, consulta [ALTER SYSTEM](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2014.htm#SQLRF53166) nella documentazione di Oracle.
# Terminazione di una sessione
Per terminare una sessione, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_util.kill`. La procedura `kill` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `method` | varchar | null | No | I valori validi sono `'IMMEDIATE'` e `'PROCESS'`. Se specifichi `IMMEDIATE`, ottieni lo stesso effetto dell'istruzione riportata di seguito: ALTER SYSTEM KILL SESSION 'sid,serial#' IMMEDIATE
Se specifichi `PROCESS`, vengono terminati i processi associati a una sessione. Specifica `PROCESS` solo se la terminazione della sessione con `IMMEDIATE` non riesce. |
Per ottenere l'identificatore di sessione e il numero di serie di sessione, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni per l'utente *AWSUSER*.
```
SELECT SID, SERIAL#, STATUS FROM V$SESSION WHERE USERNAME = 'AWSUSER';
```
Nell'esempio seguente viene terminata una sessione.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'IMMEDIATE');
END;
/
```
Nell'esempio seguente vengono terminati i processi associati a una sessione.
```
BEGIN
rdsadmin.rdsadmin_util.kill(
sid => sid,
serial => serial_number,
method => 'PROCESS');
END;
/
```
# Annullamento di una istruzione SQL in una sessione
Per annullare un'istruzione SQL in una sessione, puoi utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_util.cancel`.
**Nota**
Questa procedura è supportata per Oracle Database 19c (19.0.0) e per tutte le versioni principali e secondarie di RDS for Oracle.
La procedura `cancel` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `sid` | numero | — | Sì | L'identificatore di sessione. |
| `serial` | numero | — | Sì | Il numero di serie della sessione. |
| `sql_id` | varchar2 | null | No | L'identificatore SQL nell'istruzione SQL. |
L'esempio seguente annulla un'istruzione SQL in una sessione.
```
begin
rdsadmin.rdsadmin_util.cancel(
sid => sid,
serial => serial_number,
sql_id => sql_id);
end;
/
```
Per ottenere l'identificatore di sessione, il numero di serie di sessione e l'identificativo SQL di un'istruzione SQL, eseguire una query sulla visualizzazione `V$SESSION`. L'esempio seguente ottiene tutte le sessioni e gli identificativi SQL per l'utente `AWSUSER`.
```
select SID, SERIAL#, SQL_ID, STATUS from V$SESSION where USERNAME = 'AWSUSER';
```
# Abilitazione e disabilitazione delle sessioni limitate
Puoi usare la procedura in Amazon RDS per abilitare e disabilitare sessioni limitate `rdsadmin.rdsadmin_util.restricted_session`. La procedura `restricted_session` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Sì | Descrizione |
| --- | --- | --- | --- | --- |
| `p_enable` | booleano | true | No | Impostato su `true` per abilitare le sessioni limitate, su `false` per disabilitare le sessioni limitate. |
L'esempio seguente mostra come abilitare e disabilitare le sessioni limitate.
```
/* Verify that the database is currently unrestricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
/* Enable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => true);
/* Verify that the database is now restricted. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
----------
RESTRICTED
/* Disable restricted sessions */
EXEC rdsadmin.rdsadmin_util.restricted_session(p_enable => false);
/* Verify that the database is now unrestricted again. */
SELECT LOGINS FROM V$INSTANCE;
LOGINS
-------
ALLOWED
```
# Scaricamento del pool condiviso
Puoi usare la procedura in Amazon RDS per scaricare il pool condiviso `rdsadmin.rdsadmin_util.flush_shared_pool`. La procedura `flush_shared_pool` non ha parametri.
L'esempio seguente scarica il pool condiviso.
```
EXEC rdsadmin.rdsadmin_util.flush_shared_pool;
```
## Scaricamento della cache del buffer
Puoi usare la procedura in Amazon RDS per scaricare la cache del buffe `rdsadmin.rdsadmin_util.flush_buffer_cache`. La procedura `flush_buffer_cache` non ha parametri.
L'esempio seguente scarica la cache del buffer.
```
EXEC rdsadmin.rdsadmin_util.flush_buffer_cache;
```
## Scaricamento della cache smart flash del database
Per scaricare la cache smart flash del database, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.flush_flash_cache`. La procedura `flush_flash_cache` non ha parametri. Nell'esempio seguente viene scaricata la cache smart flash del database.
```
EXEC rdsadmin.rdsadmin_util.flush_flash_cache;
```
Per ulteriori informazioni sull'utilizzo della cache smart flash del database con RDS per Oracle, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Concedere privilegi SELECT o EXECUTE agli oggetti SYS
Solitamente si trasferiscono i privilegi utilizzando ruoli che possono contenere molti oggetti. Puoi concedere privilegi a un singolo oggetto utilizzando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.grant_sys_object`. La procedura concede solo i privilegi già concessi all'utente master tramite un ruolo o una concessione diretta.
La procedura `grant_sys_object` include i seguenti parametri.
**Importante**
Per tutti i valori dei parametri, utilizzare maiuscole a meno che non sia stato creato l'utente con un identificatore con distinzione tra maiuscole e minuscole. Ad esempio, se esegui `CREATE USER myuser` o `CREATE USER MYUSER`, il dizionario dati memorizza `MYUSER`. Tuttavia, se si utilizzano virgolette doppie in `CREATE USER "MyUser"`, il dizionario dati memorizza `MyUser`.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sì | Il nome dell'oggetto per il quale concedere privilegi. L'oggetto può essere una directory, funzione, pacchetto, procedura, sequenza, tabella o visualizzazione. I nomi degli oggetti devono essere scritti allo stesso modo in cui appaiono in `DBA_OBJECTS`. La maggior parte degli oggetti di sistema è scritta in maiuscolo, quindi consigliamo di provare prima il maiuscolo. |
| `p_grantee` | varchar2 | — | Sì | Il nome dell'oggetto al quale concedere privilegi. L'oggetto può essere uno schema o un ruolo. |
| `p_privilege` | varchar2 | null | Sì | — |
| `p_grant_option` | booleano | false | No | Impostato su `true` per utilizzare l'opzione concessione. |
L'esempio seguente concede certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1`.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
L'esempio seguente concede certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1` con l'opzione concessione.
```
begin
rdsadmin.rdsadmin_util.grant_sys_object(
p_obj_name => 'V_$SESSION',
p_grantee => 'USER1',
p_privilege => 'SELECT',
p_grant_option => true);
end;
/
```
Per poter concedere privilegi per un oggetto, quei privilegi devono essere concessi all'account direttamente con l'opzione concessione o tramite un ruolo concesso utilizzando `with admin option`. Nel caso più comune, potresti voler concedere `SELECT` a una visualizzazione DBA concessa al ruolo `SELECT_CATALOG_ROLE`. Se quel ruolo non è già concesso direttamente all'utente utilizzando `with admin option`, non sarai in grado di trasferire il privilegio. Se disponi del privilegio DBA, puoi concedere il ruolo direttamente a un altro utente.
L'esempio seguente concede `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE` a `USER1`. Siccome `with admin option` viene utilizzato, `USER1` può ora garantire l'accesso agli oggetti SYS che sono stati concessi a `SELECT_CATALOG_ROLE`.
```
GRANT SELECT_CATALOG_ROLE TO USER1 WITH ADMIN OPTION;
GRANT EXECUTE_CATALOG_ROLE to USER1 WITH ADMIN OPTION;
```
Gli oggetti già concessi a `PUBLIC` non devono essere concessi nuovamente. Se utilizzi la procedura `grant_sys_object` per concedere nuovamente l'accesso, la chiamata di procedura va a buon fine.
# Revoca del privilegio SELECT o EXECUTE in oggetti SYS
Puoi revocare privilegi in un singolo oggetto usando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.revoke_sys_object`. La procedura revoca solo i privilegi che l'account master è già stato concesso tramite un ruolo o una concessione diretta.
La procedura `revoke_sys_object` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_obj_name` | varchar2 | — | Sì | Il nome dell'oggetto per il quale revocare privilegi. L'oggetto può essere una directory, funzione, pacchetto, procedura, sequenza, tabella o visualizzazione. I nomi degli oggetti devono essere scritti allo stesso modo in cui appaiono in `DBA_OBJECTS`. LA maggior parte degli oggetti di sistema sono scritti in maiuscolo, quindi consigliamo di provare prima il maiuscolo. |
| `p_revokee` | varchar2 | — | Sì | Il nome dell'oggetto per il quale revocare privilegi. L'oggetto può essere uno schema o un ruolo. |
| `p_privilege` | varchar2 | null | Sì | — |
L'esempio seguente revoca certi privilegi su un oggetto denominato `V_$SESSION` a un utente denominato `USER1`.
```
begin
rdsadmin.rdsadmin_util.revoke_sys_object(
p_obj_name => 'V_$SESSION',
p_revokee => 'USER1',
p_privilege => 'SELECT');
end;
/
```
# Gestione delle viste RDS\$1X\$1 per le istanze database Oracle
Potrebbe essere necessario accedere alle tabelle fisse `SYS.X$`, accessibili solo da `SYS`. Per creare viste `SYS.RDS_X$` sulle tabelle `X$` idonee, utilizza le procedure incluse nel pacchetto `rdsadmin.rdsadmin_util`. All’utente master viene automaticamente concesso il privilegio `SELECT … WITH GRANT OPTION` sulle viste `RDS_X$`.
Le procedure `rdsadmin.rdsadmin_util` sono disponibili nei seguenti casi:
+ Istanze database esistenti che non sono mai state aggiornate e utilizzano le seguenti release:
+ `21.0.0.0.ru-2023-10.rur-2023-10.r1` e versioni successive alla 21c
+ `19.0.0.0.ru-2023-10.rur-2023-10.r1` e versioni successive alla 19c
+ Qualsiasi nuova istanza database che crei
+ Qualsiasi istanza database esistente che hai aggiornato
**Importante**
Internamente, il pacchetto `rdsadmin.rdsadmin_util` crea viste sulle tabelle `X$`. Le tabelle `X$` sono oggetti di sistema interni che non sono descritti nella documentazione di Oracle Database. Si consiglia di testare viste specifici nel database non di produzione e creare viste nel database di produzione solo sotto la guida del supporto Oracle.
## Elenca le tabelle fisse X\$1 idonee per l’uso nelle viste RDS\$1X\$1
Per elencare le tabelle X\$1 idonee all’uso nelle viste `RDS_X$`, utilizza la procedura RDS `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. Questa procedura non accetta parametri. Le seguenti istruzioni elencano tutte le tabelle `X$` idonee (output di esempio incluso).
```
SQL> SET SERVEROUTPUT ON
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_allowed_sys_x$_views);
'X$BH'
'X$K2GTE'
'X$KCBWBPD'
'X$KCBWDS'
'X$KGLLK'
'X$KGLOB'
'X$KGLPN'
'X$KSLHOT'
'X$KSMSP'
'X$KSPPCV'
'X$KSPPI'
'X$KSPPSV'
'X$KSQEQ'
'X$KSQRS'
'X$KTUXE'
'X$KQRFP'
```
L’elenco delle tabelle `X$` idonee può cambiare nel corso del tempo. Per assicurarti che l’elenco delle tabelle fisse `X$` idonee sia aggiornato, esegui di nuovo `list_allowed_sys_x$_views` periodicamente.
## Creazione di viste SYS.RDS\$1X\$1
Per creare una vista `RDS_X$` su una tabella `X$` idonea, utilizza la procedura RDS `rdsadmin.rdsadmin_util.create_sys_x$_view`. Puoi creare viste solo per le tabelle elencate nell’output di `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procedura `create_sys_x$_view` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sì | Un nome tabella `X$` valido. Il valore deve essere una delle tabelle `X$` segnalati da `list_allowed_sys_x$_views`. |
| `p_force_creation` | Boolean | FALSE | No | Un valore che indica se forzare la creazione di una vista `RDS_X$` già esistente per una tabella `X$`. Per impostazione predefinita, RDS non crea una vista se questa esiste già. Per forzare la creazione, imposta questo parametro su `TRUE`. |
Il seguente esempio crea una vista `SYS.RDS_X$KGLOB` sulla tabella `X$KGLOB`. Il formato per il nome della vista è `RDS_X$tablename`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.create_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
La seguente query sul dizionario di dati elenca la vista `SYS.RDS_X$KGLOB` e ne mostra lo stato. All’utente master viene automaticamente concesso il privilegio `SELECT ... WITH GRANT OPTION` su questa vista.
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
OWNER OBJECT_NAME STATUS
------------------------------ ------------------------------ ------------------------------
SYS RDS_X$KGLOB VALID
```
**Importante**
Non è garantito che le tabelle `X$` restino invariate prima e dopo l’esecuzione di un aggiornamento. RDS per Oracle elimina e ricrea le viste `RDS_X$` sulle tabelle `X$` durante un aggiornamento del motore. Quindi concede il privilegio `SELECT ... WITH GRANT OPTION` all’utente master. Dopo un aggiornamento, concedi i privilegi agli utenti del database secondo necessità sulle viste `RDS_X$` corrispondenti.
## Elenco delle viste SYS.RDS\$1X\$1
Per elencare le viste `RDS_X$` esistenti, utilizza la procedura RDS `rdsadmin.rdsadmin_util.list_created_sys_x$_views`. La procedura elenca solo le viste create dalla procedura `create_sys_x$_view`. L’esempio seguente elenca le tabelle `X$` con le viste `RDS_X$` corrispondenti (output di esempio incluso).
```
SQL> SET SERVEROUTPUT ON
SQL> COL XD_TBL_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_util.list_created_sys_x$_views);
XD_TBL_NAME STATUS
------------------------------ ------------------------------
X$BH VALID
X$K2GTE VALID
X$KCBWBPD VALID
3 rows selected.
```
## Eliminazione delle viste RDS\$1X\$1
Per eliminare una vista `SYS.RDS_X$`, utilizza la procedura RDS `rdsadmin.rdsadmin_util.drop_sys_x$_view`. Puoi impostare solo le viste elencate nell’output di `rdsadmin.rdsadmin_util.list_allowed_sys_x$_views`. La procedura `drop_sys_x$_view` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_x$_tbl` | varchar2 | Null | Sì | Un nome della tabella fissa `X$` valido. Il valore deve essere una delle tabelle fisse `X$` riportate da `list_created_sys_x$_views`. |
L’esempio seguente elimina la vista `RDS_X$KGLOB` creata nella tabella `X$KGLOB`.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.drop_sys_x$_view('X$KGLOB');
PL/SQL procedure successfully completed.
```
L’esempio seguente mostra che la vista `SYS.RDS_X$KGLOB` è stata eliminata (incluso l’output di esempio).
```
SQL> SET SERVEROUTPUT ON
SQL> COL OWNER FORMAT A30
SQL> COL OBJECT_NAME FORMAT A30
SQL> COL STATUS FORMAT A30
SQL> SET LINESIZE 200
SQL> SELECT OWNER, OBJECT_NAME, STATUS
FROM DBA_OBJECTS
WHERE OWNER = 'SYS' AND OBJECT_NAME = 'RDS_X$KGLOB';
no rows selected
```
# Concessione di privilegi a utenti non-master
È possibile concedere privilegi per molti oggetti nello schema `SYS` utilizzando il ruolo `SELECT_CATALOG_ROLE`. Il ruolo `SELECT_CATALOG_ROLE` offre agli utenti privilegi `SELECT` per visualizzazioni del dizionario dati. L'esempio seguente concede il ruolo `SELECT_CATALOG_ROLE` a un utente denominato `user1`.
```
GRANT SELECT_CATALOG_ROLE TO user1;
```
È possibile concedere privilegi `EXECUTE` per molti oggetti nello schema `SYS` utilizzando il ruolo `EXECUTE_CATALOG_ROLE`. Il ruolo `EXECUTE_CATALOG_ROLE` offre agli utenti privilegi `EXECUTE` per pacchetti e procedure nel dizionario dati. L'esempio seguente concede il ruolo `EXECUTE_CATALOG_ROLE` a un utente denominato *user1*.
```
GRANT EXECUTE_CATALOG_ROLE TO user1;
```
L'esempio seguente ottiene le autorizzazioni che permettono i ruoli `SELECT_CATALOG_ROLE` e `EXECUTE_CATALOG_ROLE`.
```
SELECT *
FROM ROLE_TAB_PRIVS
WHERE ROLE IN ('SELECT_CATALOG_ROLE','EXECUTE_CATALOG_ROLE')
ORDER BY ROLE, TABLE_NAME ASC;
```
L'esempio seguente crea un utente non-master denominato `user1`, concede il privilegio `CREATE SESSION` e il privilegio `SELECT` in un database denominato *sh.sales*.
```
CREATE USER user1 IDENTIFIED BY PASSWORD;
GRANT CREATE SESSION TO user1;
GRANT SELECT ON sh.sales TO user1;
```
# Creazione delle funzionalità personalizzate per verificare le password
Puoi creare una funzionalità di verifica della password personalizzata in due modi:
+ Se desideri utilizzare la verifica standard e archiviare la funzione nello schema `SYS`, utilizza la procedura `create_verify_function`.
+ Se desideri utilizzare la verifica personalizzata p desideri archiviare la funzione nello schema `SYS`, utilizza la procedura `create_passthrough_verify_fcn`.
# La procedura create\$1verify\$1function
Puoi creare una funzione personalizzata per verificare le password usando la procedura in Amazon RDS `rdsadmin.rdsadmin_password_verify.create_verify_function`. La procedura `create_verify_function` è supportata per tutte le versioni di RDS per Oracle.
La procedura `create_verify_function` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sì | Il nome per la funzionalità personalizzata. La funzionalità viene creata per te nello schema SYS. Assegni questa funzione a profili di utente. |
| `p_min_length` | numero | 8 | No | Il numero minimo di caratteri necessari. |
| `p_max_length` | numero | 256 | No | Il numero massimo di caratteri permessi. |
| `p_min_letters` | numero | 1 | No | Il numero minimo di lettere necessarie. |
| `p_min_uppercase` | numero | 0 | No | Il numero minimo di lettere maiuscole necessarie. |
| `p_min_lowercase` | numero | 0 | No | Il numero minimo di lettere minuscole necessarie. |
| `p_min_digits` | numero | 1 | No | Il numero minimo di cifre necessarie. |
| `p_min_special` | numero | 0 | No | Il numero minimo di caratteri speciali necessari. |
| `p_min_different_chars` | numero | 3 | No | Il numero minimo di caratteri diversi necessari tra la password vecchia e quella nuova. |
| `p_disallow_username` | booleano | true | No | Impostato su `true` per non consentire il nome utente nella password. |
| `p_disallow_reverse` | booleano | true | No | Impostato su `true` per non consentire l'inversione del nome utente nella password. |
| `p_disallow_db_name` | booleano | true | No | Impostato su `true` per non consentire il database o il nome del server nella password. |
| `p_disallow_simple_strings` | booleano | true | No | Impostato su `true` per non consentire stringhe semplici come password. |
| `p_disallow_whitespace` | booleano | false | No | Impostato su `true` per non consentire gli spazi vuoti nella password. |
| `p_disallow_at_sign` | booleano | false | No | Impostare su `true` per non consentire il carattere @ nella password. |
Puoi creare funzionalità multiple di verifica della password.
Ci sono limitazioni riguardo al nome della funzionalità personalizzata. La funzione personalizzata non può avere lo stesso nome di un oggetto di sistema esistente. La lunghezza del nome non può superare i 30 caratteri. Inoltre, il nome deve includere una delle seguenti stringhe: `PASSWORD`, `VERIFY`, `COMPLEXITY`, `ENFORCE` o `STRENGTH`.
L'esempio seguente crea una funzionalità denominata `CUSTOM_PASSWORD_FUNCTION`. La funzionalità richiede una password che includa almeno 12 caratteri, 2 caratteri maiuscoli, 1 cifra, 1 carattere speciale e che non consenta il carattere @.
```
begin
rdsadmin.rdsadmin_password_verify.create_verify_function(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_min_length => 12,
p_min_uppercase => 2,
p_min_digits => 1,
p_min_special => 1,
p_disallow_at_sign => true);
end;
/
```
Per vedere il testo della funzionalità di verifica, eseguire una query a `DBA_SOURCE`. L'esempio seguente ottiene il testo da una funzionalità di password personalizzata denominata `CUSTOM_PASSWORD_FUNCTION`.
```
COL TEXT FORMAT a150
SELECT TEXT
FROM DBA_SOURCE
WHERE OWNER = 'SYS'
AND NAME = 'CUSTOM_PASSWORD_FUNCTION'
ORDER BY LINE;
```
Per associare la funzionalità di verifica con un profilo utente, utilizza `ALTER PROFILE`. L'esempio seguente associa una PL/SQL funzione di verifica `CUSTOM_PASSWORD_FUNCTION` denominata al profilo `DEFAULT` utente. `PASSWORD_VERIFY_FUNCTION`è il nome della risorsa del profilo Oracle.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
Per vedere quali profili utente sono associati a quali funzioni di verifica, interroga`DBA_PROFILES`. L'esempio seguente ottiene i profili che sono associati alla funzionalità di verifica personalizzata denominata `CUSTOM_PASSWORD_FUNCTION`.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION' AND LIMIT = 'CUSTOM_PASSWORD_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
```
L'esempio seguente ottiene tutti i profili e la funzionalità di verifica della password alla quale sono associati.
```
SELECT * FROM DBA_PROFILES WHERE RESOURCE_NAME = 'PASSWORD_VERIFY_FUNCTION';
PROFILE RESOURCE_NAME RESOURCE LIMIT
------------------------- -------------------------------- -------- ------------------------
DEFAULT PASSWORD_VERIFY_FUNCTION PASSWORD CUSTOM_PASSWORD_FUNCTION
RDSADMIN PASSWORD_VERIFY_FUNCTION PASSWORD NULL
```
# La procedura create\$1passthrough\$1verify\$1fcn
La procedura `create_passthrough_verify_fcn` è supportata per tutte le versioni di RDS per Oracle.
Puoi creare una funzione personalizzata per verificare le password usando la procedura in Amazon RDS `rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn`. La procedura `create_passthrough_verify_fcn` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_verify_function_name` | varchar2 | — | Sì | Il nome per la funzionalità di verifica personalizzata. Questa è una funzionalità wrapper creata per te nello schema SYS e non contiene nessuna logica di verifica. Assegni questa funzione a profili di utente. |
| `p_target_owner` | varchar2 | — | Sì | Il proprietario dello schema per la funzionalità di verifica personalizzata. |
| `p_target_function_name` | varchar2 | — | Sì | Il nome della funzionalità personalizzata esistente che contiene una logica di verifica. La funzionalità personalizzata deve restituire un booleano. La funzionalità deve restituire `true` se la password è valida e `false` se la password non è valida. |
L'esempio seguente crea una funzionalità di verifica della password che utilizza la logica dalla funzionalità denominata `PASSWORD_LOGIC_EXTRA_STRONG`.
```
begin
rdsadmin.rdsadmin_password_verify.create_passthrough_verify_fcn(
p_verify_function_name => 'CUSTOM_PASSWORD_FUNCTION',
p_target_owner => 'TEST_USER',
p_target_function_name => 'PASSWORD_LOGIC_EXTRA_STRONG');
end;
/
```
Per associare la funzionalità di verifica con un profilo utente, utilizza `alter profile`. L'esempio seguente associa la funzionalità di verifica con un profilo utente `DEFAULT`.
```
ALTER PROFILE DEFAULT LIMIT PASSWORD_VERIFY_FUNCTION CUSTOM_PASSWORD_FUNCTION;
```
## Impostazione di un server DNS personalizzato
Amazon RDS supporta l'accesso di rete in uscita sull'istanza database che esegue Oracle. Per ulteriori informazioni sull'accesso di rete in uscita, inclusi i prerequisiti, consulta [Configurazione dell'accesso UTL\$1HTTP utilizzando certificati e un portafoglio Oracle](Oracle.Concepts.ONA.md).
Amazon RDS Oracle permette la risoluzione Domain Name Service (DNS) da un server DNS personalizzato di proprietà del cliente. È possibile risolvere solo nomi di dominio completamente qualificati dall'istanza database Amazon RDS tramite il server DNS personalizzato.
Dopo aver impostato il server dei nomi DNS personalizzato, ci vogliono circa 30 minuti per propagare le modifiche all'istanza database. Dopo che le modifiche vengono propagate all'istanza database, tutto il traffico di rete in uscita che richiede una ricerca DNS esegue una query al server DNS tramite la porta 53.
Per impostare un server DNS personalizzato per l'istanza database Amazon RDS for Oracle, procedi come segue:
+ Dal set di opzioni DHCP collegate al Virtual Private Cloud (VPC), imposta l'opzione `domain-name-servers` sull'indirizzo IP del server dei nomi DNS. Per ulteriori informazioni, consulta la pagina relativa ai [Set di opzioni DHCP](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html).
**Nota**
L'opzione `domain-name-servers` accetta fino a quattro valori, ma l'istanza database Amazon RDS usa solo il primo valore.
+ Assicurati che il server DNS possa risolvere tutte le query di ricerca, compresi i nomi DNS pubblici, i nomi DNS privati Amazon EC2 e i nomi DNS specifici per i clienti. Se il traffico di rete in uscita contiene ricerche DNS che il server DNS non può gestire, il server DNS deve avere fornitori DNS upstream appropriati configurati.
+ Configura il server DNS per produrre risposte UDP (User Datagram Protocol) di 512 byte o meno.
+ Configura il server DNS per produrre risposte TCP (Transmission Control Protocol) di 1024 byte o meno.
+ Configura il server DNS per consentire il traffico in entrata dalle istanze database Amazon RDS tramite la porta 53. Se il server DNS si trova in un Amazon VPC, il VPC deve avere un gruppo di sicurezza che contiene regole in entrata che permettono traffico UDP e TCP tramite la porta 53. Se il server DNS non si trova in un Amazon VPC, deve avere una whitelist firewall appropriata per permettere traffico in entrata UDP e TCP tramite la porta 53.
Per ulteriori informazioni, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Aggiunta e rimozione di regole](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Configura il VPC dell'istanza database Amazon RDS per permettere traffico in uscita tramite la porta 53. Il VPC deve avere un gruppo di sicurezza che contiene regole in uscita che permettono traffico UDP e TCP tramite la porta 53.
Per ulteriori informazioni, consulta [Gruppi di sicurezza per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) e [Aggiunta e rimozione di regole](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#AddRemoveRules).
+ Il percorso di routing tra l'istanza database Amazon RDS e il server DNS deve essere configurata correttamente per consentire traffico DNS.
+ Se l'istanza database Amazon RDS e il server DNS non si trovano nello stesso VPC, una connessione peer deve essere configurata tra loro. Per ulteriori informazioni, consulta [Che cos'è il VPC in peering?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html)
# Impostazione e annullamento dell'impostazione degli eventi diagnostici di sistema
Per impostare e annullare l'impostazione degli eventi diagnostici a livello di sessione, è possibile utilizzare l'istruzione Oracle SQL `ALTER SESSION SET EVENTS`. Tuttavia, per impostare gli eventi a livello di sistema non è possibile utilizzare Oracle SQL. Utilizzare invece le procedure evento di sistema nel pacchetto `rdsadmin.rdsadmin_util`. Le procedure evento di sistema sono disponibili nelle seguenti versioni del motore:
+ Tutte le versioni di Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 e versioni successive di Oracle Database 19c
Per ulteriori informazioni, consulta [Versione 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) nelle *Note di rilascio di Amazon RDS per Oracle*.
**Importante**
Internamente, il pacchetto `rdsadmin.rdsadmin_util` imposta gli eventi utilizzando l'istruzione `ALTER SYSTEM SET EVENTS`. Questa istruzione `ALTER SYSTEM` non è documentata nella documentazione di Oracle Database. Alcuni eventi di diagnostica del sistema possono generare grandi quantità di informazioni di traccia, causare contese o influire sulla disponibilità del database. Si consiglia di testare eventi diagnostici specifici nel database non di produzione e impostare gli eventi nel database di produzione solo sotto la guida del supporto Oracle.
## Elenco degli eventi diagnostici di sistema consentiti
Per elencare gli eventi di sistema che è possibile impostare, attenersi alla Amazon RDS procedura `rdsadmin.rdsadmin_util.list_allowed_system_events`. Questa procedura non accetta parametri.
Nell'esempio seguente sono elencati tutti gli eventi di sistema che è possibile impostare.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_allowed_system_events;
```
Nell'output di esempio seguente sono elencati i numeri degli eventi e le relative descrizioni. Utilizzare le Amazon RDS procedure `set_system_event` per impostare questi eventi e `unset_system_event` per disimpostarli.
```
604 - error occurred at recursive SQL level
942 - table or view does not exist
1401 - inserted value too large for column
1403 - no data found
1410 - invalid ROWID
1422 - exact fetch returns more than requested number of rows
1426 - numeric overflow
1427 - single-row subquery returns more than one row
1476 - divisor is equal to zero
1483 - invalid length for DATE or NUMBER bind variable
1489 - result of string concatenation is too long
1652 - unable to extend temp segment by in tablespace
1858 - a non-numeric character was found where a numeric was expected
4031 - unable to allocate bytes of shared memory ("","","","")
6502 - PL/SQL: numeric or value error
10027 - Specify Deadlock Trace Information to be Dumped
10046 - enable SQL statement timing
10053 - CBO Enable optimizer trace
10173 - Dynamic Sampling time-out error
10442 - enable trace of kst for ORA-01555 diagnostics
12008 - error in materialized view refresh path
12012 - error on auto execute of job
12504 - TNS:listener was not given the SERVICE_NAME in CONNECT_DATA
14400 - inserted partition key does not map to any partition
31693 - Table data object failed to load/unload and is being skipped due to error:
```
**Nota**
L'elenco degli eventi di sistema consentiti può cambiare nel tempo. Per assicurarti di avere l'elenco degli eventi idonei più recente, usa `rdsadmin.rdsadmin_util.list_allowed_system_events`.
## Impostazione degli eventi di diagnostica del sistema
Per impostare un evento di sistema, usa la Amazon RDS procedura `rdsadmin.rdsadmin_util.set_system_event`. È possibile impostare solo gli eventi elencati nell'output di `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procedura `set_system_event` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_event` | numero | — | Sì | Il numero dell'evento di sistema. Il valore deve essere uno dei numeri degli eventi segnalati da `list_allowed_system_events`. |
| `p_level` | numero | — | Sì | Il livello dell'evento. Per le descrizioni dei valori di livello diversi, consulta la documentazione di Oracle Database o Oracle Support. |
La procedura `set_system_event` costruisce ed esegue le istruzioni `ALTER SYSTEM SET EVENTS` richieste secondo i seguenti principi:
+ Il tipo di evento (`context` o `errorstack`) viene determinato automaticamente.
+ Un'istruzione nel modulo `ALTER SYSTEM SET EVENTS 'event LEVEL event_level'` imposta gli eventi di contesto. Questa notazione è equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME CONTEXT FOREVER, LEVEL event_level'`.
+ Un'istruzione nel modulo `ALTER SYSTEM SET EVENTS 'event ERRORSTACK (event_level)'` imposta gli eventi stack di errore. Questa notazione è equivalente a `ALTER SYSTEM SET EVENTS 'event TRACE NAME ERRORSTACK LEVEL event_level'`.
Nell'esempio seguente viene impostato l'evento 942 al livello 3 e l'evento 10442 al livello 10. L'output di esempio è incluso.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(942,3);
Setting system event 942 with: alter system set events '942 errorstack (3)'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.set_system_event(10442,10);
Setting system event 10442 with: alter system set events '10442 level 10'
PL/SQL procedure successfully completed.
```
## Elenco degli eventi diagnostici di sistema impostati
Per elencare gli eventi di sistema correntemente impostati, utilizza la Amazon RDS procedura `rdsadmin.rdsadmin_util.list_set_system_events`. Questa procedura segnala solo gli eventi impostati a livello di sistema da `set_system_event`.
Nell'esempio seguente vengono elencati gli eventi di sistema attivi.
```
SET SERVEROUTPUT ON
EXEC rdsadmin.rdsadmin_util.list_set_system_events;
```
Nell'output di esempio seguente viene illustrato l'elenco degli eventi, il tipo di evento, il livello in cui gli eventi sono attualmente impostati e l'ora in cui è stato impostato l'evento.
```
942 errorstack (3) - set at 2020-11-03 11:42:27
10442 level 10 - set at 2020-11-03 11:42:41
PL/SQL procedure successfully completed.
```
## Annullamento dell'impostazione degli eventi diagnostici del sistema
Per annullare l'impostazione di un evento di sistema, attenersi alla Amazon RDS procedura `rdsadmin.rdsadmin_util.unset_system_event`. È possibile annullare solo gli eventi elencati nell'output di `rdsadmin.rdsadmin_util.list_allowed_system_events`. La procedura `unset_system_event` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_event` | numero | — | Sì | Il numero dell'evento di sistema. Il valore deve essere uno dei numeri degli eventi segnalati da `list_allowed_system_events`. |
Nell'esempio seguente vengono disimpostati gli eventi 942 e 10442. L'output di esempio è incluso.
```
SQL> SET SERVEROUTPUT ON
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(942);
Unsetting system event 942 with: alter system set events '942 off'
PL/SQL procedure successfully completed.
SQL> EXEC rdsadmin.rdsadmin_util.unset_system_event(10442);
Unsetting system event 10442 with: alter system set events '10442 off'
PL/SQL procedure successfully completed.
```
# Esecuzione di attività di database comuni per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative ai database nelle istanze database Amazon RDS che eseguono Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Amazon RDS limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati.
**Topics**
+ [Modifica del nome globale di un database](Appendix.Oracle.CommonDBATasks.RenamingGlobalName.md)
+ [Utilizzo delle tablespace in RDS per Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md)
+ [Utilizzo dei file temporanei in RDS per Oracle](Appendix.Oracle.CommonDBATasks.using-tempfiles.md)
+ [Ridimensionamento di tablespace, file di dati e file temporanei in RDS per Oracle](Appendix.Oracle.CommonDBATasks.ResizeTempSpaceReadReplica.md)
+ [Spostamento di dati tra volumi di storage in RDS per Oracle](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md)
+ [Utilizzo di tabelle esterne in RDS per Oracle](Appendix.Oracle.CommonDBATasks.External_Tables.md)
# Modifica del nome globale di un database
Puoi usare la procedura in Amazon RDS per modificare il nome globale di un database `rdsadmin.rdsadmin_util.rename_global_name`. La procedura `rename_global_name` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_new_global_name` | varchar2 | — | Sì | Il nuovo nome globale per il database. |
Il database deve essere aperto affinché la modifica del nome abbia luogo. Per ulteriori informazioni sulla modifica del nome globale di un database, consulta [ALTER DATABASE](http://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1004.htm#SQLRF52547) nella documentazione di Oracle.
L'esempio seguente modifica il nome globale del database in `new_global_name`.
```
EXEC rdsadmin.rdsadmin_util.rename_global_name(p_new_global_name => 'new_global_name');
```
# Utilizzo delle tablespace in RDS per Oracle
È possibile utilizzare i tablespace con RDS for Oracle, un'unità di archiviazione logica che archivia i dati del database.
**Importante**
Se l'istanza DB dispone di repliche, si consiglia di utilizzare le impostazioni dei gruppi di parametri anziché le modifiche a livello di sessione per gestire le posizioni dei file predefinite. Le modifiche a livello di sessione alle posizioni dei file predefinite nell'istanza principale non si riflettono automaticamente nelle repliche. L'utilizzo delle impostazioni dei gruppi di parametri garantisce la coerenza delle posizioni dei file tra le istanze primarie e di replica.
**Topics**
+ [Specificazione delle posizioni dei file di database in RDS for Oracle](#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [Creazione e dimensionamento di tablespace in RDS for Oracle](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [Creazione di tablespace su volumi di archiviazione aggiuntivi in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.CreatingTablespacesWithFileLocations)
+ [Impostazione del tablespace predefinito in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefaultTablespace)
+ [Impostazione del tablespace temporaneo predefinito in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace)
+ [Creazione di un tablespace temporaneo nell’archivio dell’istanza](#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store)
## Specificazione delle posizioni dei file di database in RDS for Oracle
RDS per Oracle utilizza Oracle Managed Files (OMF) per denominare i file di database. Quando si creano file di database, il database ricava l'impostazione in base all'impostazione corrente del parametro di inizializzazione. `DB_CREATE_FILE_DEST`
Il valore predefinito del parametro di `DB_CREATE_FILE_DEST` inizializzazione è `/rdsdbdata/db` per i database autonomi e `/rdsdbdata/db/pdb` per l'architettura containerizzata (CDB/MT). Se l'istanza DB dispone di volumi di storage aggiuntivi, è possibile impostare le posizioni dei volumi. `DB_CREATE_FILE_DEST` Ad esempio, se la tua istanza ha un volume montato`/rdsdbdata/db`, puoi `DB_CREATE_FILE_DEST` impostarlo su questo valore.
È possibile modificare il `DB_CREATE_FILE_DEST` parametro a livello di sessione o a livello di istanza del database Oracle.
### Modifica di DB\$1CREATE\$1FILE\$1SET a livello di istanza
Per modificare il parametro a livello di istanza, aggiorna il parametro nel gruppo di parametri assegnato all'istanza DB e applicalo. Per ulteriori informazioni, consultare [Parametri di inizializzazione di RDS per Oracle](Oracle.Concepts.FeatureSupport.Parameters.md) e [Modifica dei parametri in un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
### Modifica di DB\$1CREATE\$1FILE\$1DEST a livello di sessione
È possibile modificare il parametro a livello di sessione eseguendo un'`ALTER SESSION`istruzione. Questo approccio è utile quando si desidera creare file di database in una posizione specifica per una sessione particolare senza influire sull'intera istanza.
L'esempio seguente mostra come controllare il valore corrente del parametro e modificarlo per la sessione:
```
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata/db
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
SHOW PARAMETER db_create_file_dest
NAME TYPE VALUE
------------------------------------ ----------- ------------------------------
db_create_file_dest string /rdsdbdata2/db
```
## Creazione e dimensionamento di tablespace in RDS for Oracle
Quando si creano tablespace, il database crea i file di dati nel volume di archiviazione specificato dal parametro di inizializzazione al momento della `DB_CREATE_FILE_DEST` creazione. Per impostazione predefinita, se non si specifica una dimensione del file di dati, gli spazi di tabella vengono creati con il valore predefinito di `AUTOEXTEND ON` e nessuna dimensione massima. Nell'esempio seguente, il tablespace è estensibile automaticamente. *users1*
```
CREATE TABLESPACE users1;
```
A causa di queste impostazioni predefinite, i tablespace possono aumentare e occupare tutto lo spazio di archiviazione allocato. Consigliamo di specificare una dimensione massima appropriata per tablespace permanenti e temporanei e che monitori attentamente l’utilizzo di spazio.
L'esempio seguente crea un tablespace denominato *users2* con una dimensione iniziale di 1 gigabyte. Poiché la dimensione di un file di dati è specificata, ma `AUTOEXTEND ON` non è specificato, lo spazio di tabella non è estensibile automaticamente.
```
CREATE TABLESPACE users2 DATAFILE SIZE 1G;
```
L'esempio seguente crea una tablespace denominata *users3* con una dimensione iniziale di 1 gigabyte, estensione automatica attivata e una dimensione massima di 10 gigabyte.
```
CREATE TABLESPACE users3 DATAFILE SIZE 1G AUTOEXTEND ON MAXSIZE 10G;
```
L'esempio seguente crea un tablespace temporaneo denominato. *temp01*
```
CREATE TEMPORARY TABLESPACE temp01;
```
Puoi ridimensionare un tablespace di file di grandi dimensioni utilizzando `ALTER TABLESPACE`. Puoi specificare le dimensioni in kilobyte (K), megabyte (M), gigabyte (G), o terabyte (T). L'esempio seguente ridimensiona uno spazio tabella di un file di grandi dimensioni denominato *users\$1bf* a 200 MB.
```
ALTER TABLESPACE users_bf RESIZE 200M;
```
L'esempio seguente aggiunge un file di dati aggiuntivo a una tablespace di file di piccole dimensioni denominata. *users\$1sf*
```
ALTER TABLESPACE users_sf ADD DATAFILE SIZE 100000M AUTOEXTEND ON NEXT 250m MAXSIZE UNLIMITED;
```
## Creazione di tablespace su volumi di archiviazione aggiuntivi in RDS per Oracle
Per creare un tablespace su un volume di archiviazione aggiuntivo, modificate il `DB_CREATE_FILE_DEST` parametro impostando la posizione del volume. L'esempio seguente imposta la posizione del file su. `/rdsdbdata2/db`
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
```
Nell'esempio seguente, create una tablespace sul volume aggiuntivo. `/rdsdbdata2/db`
```
CREATE TABLESPACE new_tablespace DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'NEW_TABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
NEW_TABLESPACE 7 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_newtable_a123b4c5_.dbf
```
Per creare una tablespace di file di piccole dimensioni e distribuirne i file di dati su diversi volumi di archiviazione, aggiungi i file di dati alla tablespace dopo averla creata. Nell'esempio seguente, crei una tablespace con i file di dati nella posizione predefinita di. `/rdsdbdata/db` Quindi impostate la destinazione predefinita su. `/rdsdbdata/db2` Quando aggiungete un file di dati alla tablespace appena creata, il database memorizza il file in. `/rdsdbdata/db2`
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata/db';
Session altered.
CREATE SMALLFILE TABLESPACE smalltbs DATAFILE SIZE 10G;
Tablespace created.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
Session altered.
ALTER TABLESPACE smalltbs ADD DATAFILE SIZE 10G;
Tablespace altered.
SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'SMALLTBS';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
SMALLTBS 8 /rdsdbdata/db/ORCL_A/datafile/o1_mf_smalltbs_n563yryk_.dbf
SMALLTBS 9 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_smalltbs_n564004g_.dbf
```
## Impostazione del tablespace predefinito in RDS per Oracle
Puoi usare la procedura in Amazon RDS per impostare lo spazio di tabella predefinito `rdsadmin.rdsadmin_util.alter_default_tablespace`. La procedura `alter_default_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sì | Il nome dello spazio tabella predefinito. |
L'esempio seguente imposta il tablespace predefinito su: *users2*
```
EXEC rdsadmin.rdsadmin_util.alter_default_tablespace(tablespace_name => 'users2');
```
## Impostazione del tablespace temporaneo predefinito in RDS per Oracle
Puoi usare la procedura in Amazon RDS per impostare lo spazio di tabella temporaneo predefinito `rdsadmin.rdsadmin_util.alter_default_temp_tablespace`. La procedura `alter_default_temp_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `tablespace_name` | varchar | — | Sì | Il nome dello spazio tabella predefinito temporaneo. |
L'esempio seguente imposta il tablespace temporaneo predefinito su. *temp01*
```
EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace(tablespace_name => 'temp01');
```
## Creazione di un tablespace temporaneo nell’archivio dell’istanza
Per creare un tablespace temporaneo nell’archivio dell’istanza, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace`. La procedura `create_inst_store_tmp_tblspace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo. |
L'esempio seguente crea il tablespace temporaneo *temp01* nell'instance store.
```
EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace(p_tablespace_name => 'temp01');
```
**Importante**
Durante l'esecuzione di `rdsadmin_util.create_inst_store_tmp_tblspace`, lo spazio di tabella temporaneo appena creato non viene impostato automaticamente come spazio di tabella temporaneo predefinito. Per impostarlo come predefinito, consulta [Impostazione del tablespace temporaneo predefinito in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.SettingDefTempTablespace).
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Utilizzo dei file temporanei in RDS per Oracle
## Aggiunta di un file temporaneo all'archivio dell'istanza in una replica di lettura
Quando si crea uno spazio di tabella temporaneo in un'istanza database primaria, la replica di lettura non crea i file temporanei. Supponi che nella replica di lettura esista uno spazio di tabella temporaneo vuoto per uno dei seguenti motivi:
+ Hai eliminato un file temporaneo dallo spazio di tabella temporaneo nella replica di lettura. Per ulteriori informazioni, consulta [Rilascio di file temporanei in una replica di lettura](Appendix.Oracle.CommonDBATasks.dropping-tempfiles-replica.md).
+ Hai creato un nuovo spazio di tabella temporaneo nell'istanza database primaria. In questo caso, RDS per Oracle sincronizza i metadati con la replica di lettura.
Puoi aggiungere un file temporaneo allo spazio di tabella temporaneo vuoto e archiviare il file temporaneo nell'archivio dell'istanza. Per creare un file temporaneo nell'archivio dell'istanza, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.add_inst_store_tempfile`. Puoi utilizzare questa procedura solo in una replica di lettura. La procedura include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo nella replica di lettura. |
Nell'esempio seguente, il tablespace temporaneo vuoto *temp01* esiste nella replica di lettura. Esegui il comando seguente per creare un file temporaneo per la tabella e archiviarlo nell'archivio dell'istanza.
```
EXEC rdsadmin.rdsadmin_util.add_inst_store_tempfile(p_tablespace_name => 'temp01');
```
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Rilascio di file temporanei in una replica di lettura
Non è possibile rilasciare uno spazio di tabella temporaneo esistente in una replica di lettura. Puoi modificare l'archivio dei file temporanei in una replica di lettura da Amazon EBS nell'archivio dell'istanza o dall'archivio dell'istanza ad Amazon EBS. Per raggiungere questi obiettivi, effettua le seguenti operazioni:
1. Rilascia i file temporanei correnti nello spazio di tabella temporaneo nella replica di lettura.
1. Crea nuovi file temporanei in un altro archivio.
Per rilasciare i file temporanei, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util. drop_replica_tempfiles`. Puoi utilizzare questa procedura solo nelle repliche di lettura. La procedura `drop_replica_tempfiles` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar | — | Sì | Il nome dello spazio di tabella temporaneo nella replica di lettura. |
Supponiamo che un tablespace temporaneo denominato *temp01* risieda nell'instance store della replica di lettura. Rilascia tutti i file temporanei in questo spazio di tabella eseguendo il comando seguente.
```
EXEC rdsadmin.rdsadmin_util.drop_replica_tempfiles(p_tablespace_name => 'temp01');
```
Per ulteriori informazioni, consulta [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md).
# Ridimensionamento di tablespace, file di dati e file temporanei in RDS per Oracle
Come impostazione predefinita, gli spazi tabelle Oracle sono creati con l'estensione automatica attivata e nessuna dimensione massima. A causa delle impostazioni predefinite, gli spazi tabella possono a volte diventare troppo grandi. Consigliamo di specificare una dimensione massima appropriata per tablespace permanenti e temporanei e che monitori attentamente l’utilizzo di spazio.
## Ridimensionamento degli spazi di tabella permanenti
Per ridimensionare uno spazio di tabella permanente in un'istanza database RDS per Oracle, utilizza una delle seguenti procedure Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_datafile`
+ `rdsadmin.rdsadmin_util.autoextend_datafile`
La procedura `resize_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | numero | — | Sì | L'identificatore del file di dati da ridimensionare. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file di dati. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `autoextend_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_data_file_id` | numero | — | Sì | L'identificatore del file di dati da ridimensionare. |
| `p_autoextend_state` | varchar2 | — | Sì | Lo stato della funzionalità di estensione automatica. Specifica `ON` per estendere automaticamente il file di dati e `OFF` per disattivare l'estensione automatica. |
| `p_next` | varchar2 | — | No | Le dimensioni del successivo incremento del file di dati. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
| `p_maxsize` | varchar2 | — | No | Lo spazio massimo su disco consentito per l'estensione automatica. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). È possibile specificare `UNLIMITED` per rimuovere il limite di dimensione del file. |
L'esempio seguente ridimensiona il file di dati da 4 a 500 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_datafile(4,'500M');
```
L'esempio seguente disattiva l'estensione automatica per il file di dati 4. Attiva l'estensione automatica per il file di dati 5, con un incremento di 128 MB e nessuna dimensione massima.
```
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(4,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_datafile(5,'ON','128M','UNLIMITED');
```
## Ridimensionamento degli spazi di tabella temporanei
Per ridimensionare uno spazio di tabella temporaneo in un'istanza database RDS per Oracle, inclusa una replica di lettura, utilizza una delle seguenti procedure Amazon RDS:
+ `rdsadmin.rdsadmin_util.resize_temp_tablespace`
+ `rdsadmin.rdsadmin_util.resize_tempfile`
+ `rdsadmin.rdsadmin_util.autoextend_tempfile`
La procedura `resize_temp_tablespace` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_tablespace_name` | varchar2 | — | Sì | Il nome dello spazio tabella temporaneo da ridimensionare. |
| `p_size` | varchar2 | — | Sì | La dimensione dello spazio di tabella. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `resize_tempfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | numero | — | Sì | L'identificatore del file temporaneo da ridimensionare. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file temporaneo. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
La procedura `autoextend_tempfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_temp_file_id` | numero | — | Sì | L'identificatore del file temporaneo da ridimensionare. |
| `p_autoextend_state` | varchar2 | — | Sì | Lo stato della funzionalità di estensione automatica. Specifica `ON` per estendere automaticamente il file temporaneo e `OFF` per disattivare l'estensione automatica. |
| `p_next` | varchar2 | — | No | Le dimensioni del successivo incremento del file temporaneo. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). |
| `p_maxsize` | varchar2 | — | No | Lo spazio massimo su disco consentito per l'estensione automatica. Specifica le dimensioni in byte (impostazione predefinita), kilobyte (K), megabyte (M) o gigabyte (G). È possibile specificare `UNLIMITED` per rimuovere il limite di dimensione del file. |
I seguenti esempi ridimensionano uno spazio di tabella temporaneo denominato `TEMP` alla dimensione di 4 GB.
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4G');
```
```
EXEC rdsadmin.rdsadmin_util.resize_temp_tablespace('TEMP','4096000000');
```
Il seguente esempio ridimensiona uno spazio tabella temporaneo basato sul file temporaneo con l'identificatore file `1` alla dimensione di 2 MB.
```
EXEC rdsadmin.rdsadmin_util.resize_tempfile(1,'2M');
```
L'esempio seguente disattiva l'estensione automatica per il file temporaneo 1. Imposta la dimensione massima dell'estensione automatica del file temporaneo da 2 a 10 GB, con un incremento di 100 MB.
```
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(1,'OFF');
EXEC rdsadmin.rdsadmin_util.autoextend_tempfile(2,'ON','100M','10G');
```
Per maggiori informazioni sulle repliche di lettura per le istanze database Oracle, consulta [Utilizzo di repliche di lettura per Amazon RDS per Oracle](oracle-read-replicas.md).
# Spostamento di dati tra volumi di storage in RDS per Oracle
È possibile spostare file di dati e oggetti di database tra i volumi di storage primari e aggiuntivi. Prima di spostare i dati, considera i seguenti punti:
+ I volumi di origine e di destinazione devono disporre di spazio libero sufficiente.
+ Le operazioni di spostamento dei dati I/O occupano entrambi i volumi.
+ I movimenti di dati di grandi dimensioni possono influire sulle prestazioni del database.
+ Se ripristini un'istantanea, lo spostamento dei dati tra i volumi di storage potrebbe essere lento se è influenzato dal lazy loading di EBS.
**Topics**
+ [Spostamento di file di dati tra volumi in RDS per Oracle](#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
+ [Spostamento dei dati e degli indici delle tabelle tra i volumi in RDS for Oracle](#Appendix.Oracle.CommonDBATasks.MovingTableData)
+ [Gestione dello storage LOB utilizzando volumi aggiuntivi](#Appendix.Oracle.CommonDBATasks.ManagingLargeLOBStorage)
## Spostamento di file di dati tra volumi in RDS per Oracle
Per spostare file di dati tra volumi di storage, utilizza la procedura `rdsadmin.rdsadmin_util.move_datafile` Amazon RDS. Si notino i requisiti seguenti:
+ È necessario utilizzare Oracle Enterprise Edition per eseguire la `move_datafile` procedura.
+ Non è possibile spostare tablespace e`SYSTEM`. `RDSADMIN`
La procedura `move_datafile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Richiesto | Descrizione |
| --- | --- | --- | --- |
| `p_data_file_id` | numero | Sì | L'ID del file di dati da spostare. |
| `p_location` | varchar2 | Sì | Il volume di archiviazione in cui si desidera spostare il file di dati. |
L'esempio seguente sposta una tablespace dal volume predefinito `rdsdbdata` al volume aggiuntivo. `rdsdbdata2`
```
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata/db/ORCL_A/datafile/o1_mf_mynewtab_n123abcd_.dbf
EXECUTE rdsadmin.rdsadmin_util.move_datafile( 6, 'rdsdbdata2');
PL/SQL procedure successfully completed.
SQL> SELECT tablespace_name,file_id,file_name FROM dba_data_files
WHERE tablespace_name = 'MYNEWTABLESPACE';
TABLESPACE_NAME FILE_ID FILE_NAME
------------------------- ---------- --------------------------------------------------------------------------------
MYNEWTABLESPACE 6 /rdsdbdata2/db/ORCL_A/datafile/o1_mf_mynewtab_n356efgh_.dbf
```
## Spostamento dei dati e degli indici delle tabelle tra i volumi in RDS for Oracle
È possibile ottimizzare l'archiviazione del database creando tablespace su volumi di archiviazione aggiuntivi. È quindi possibile spostare oggetti come tabelle, indici e partizioni in questi tablespace utilizzando lo standard Oracle SQL. Questo approccio è utile per ottimizzare le prestazioni quando il database contiene dati con modelli di accesso diversi. Ad esempio, è possibile archiviare i dati operativi a cui si accede di frequente su volumi di storage ad alte prestazioni spostando al contempo i dati storici a cui si accede raramente in volumi di storage a basso costo.
Nell'esempio seguente, si crea una nuova tablespace su un volume ad alte prestazioni. `rdsdbdata2` Quindi sposti una tabella nel volume di archiviazione aggiuntivo mentre la tabella è online. Inoltre, sposti l'indice sullo stesso volume. Lo spostamento delle tabelle e la ricostruzione degli indici online richiedono Oracle Enterprise Edition.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
CREATE TABLESPACE perf_tbs DATAFILE SIZE 10G;
ALTER TABLE employees
MOVE TABLESPACE perf_tbs ONLINE;
ALTER INDEX employees_idx
REBUILD ONLINE TABLESPACE perf_tbs;
```
Nell'esempio seguente, si crea una tablespace su un volume a basso costo. Quindi si sposta una partizione di tabella nel volume di archiviazione a basso costo utilizzando un'operazione online.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE hist_tbs DATAFILE SIZE 10G;
ALTER TABLE orders
MOVE PARTITION orders_2022
TABLESPACE hist_tbs ONLINE;
```
Nell'esempio seguente, si interrogano le sessioni attive su operazioni di lunga durata.
```
SELECT sid,opname,sofar,totalwork,time_remaining,elapsed_seconds
FROM v$session_longops
WHERE time_remaining > 0;
```
È possibile verificare l'utilizzo dei tablespace con la seguente query.
```
SELECT tablespace_name, used_percent
FROM dba_tablespace_usage_metrics
ORDER BY used_percent DESC;
```
## Gestione dello storage LOB utilizzando volumi aggiuntivi
Il database potrebbe contenere tabelle con oggetti BLOB o CLOB che consumano una notevole quantità di spazio di archiviazione ma a cui si accede raramente. Per ottimizzare l'archiviazione, è possibile riposizionare questi segmenti LOB in un tablespace su un volume di archiviazione aggiuntivo.
Nell'esempio seguente, si crea una tablespace per i dati LOB su un volume a basso costo destinato a dati a basso accesso. Quindi si crea una tabella che memorizza i dati su questo volume.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata3/db';
CREATE TABLESPACE lob_data DATAFILE SIZE 5G AUTOEXTEND ON NEXT 1G;
CREATE TABLE documents (
doc_id NUMBER PRIMARY KEY,
doc_date DATE,
doc_content CLOB
) TABLESPACE user_data
LOB(doc_content) STORE AS (TABLESPACE lob_data);
```
# Utilizzo di tabelle esterne in RDS per Oracle
Le *Tabelle esterne Oracle* sono tabelle con dati che non si trovano nel database. Invece, i dati si trovano nei file esterni ai quali il database può accedere. Utilizzando le tabelle esterne, puoi accedere ai dati senza caricarli nel database. Per ulteriori informazioni sulle tabelle esterne, consulta [Gestione delle tabelle esterne](http://docs.oracle.com/database/121/ADMIN/tables.htm#ADMIN01507) nella documentazione Oracle.
Con Amazon RDS, puoi archiviare i file della tabella esterna negli oggetti della directory. Puoi creare un oggetto di directory o puoi utilizzare uno predefinito nel database Oracle, ad esempio la directory DATA\$1PUMP\$1DIR. Per informazioni sulla creazione di oggetti di directory, consulta [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories). Puoi eseguire query sulla visualizzazione ALL\$1DIRECTORIES per elencare gli oggetti di directory per l'istanza database Amazon RDS Oracle.
**Nota**
Gli oggetti directory puntano allo spazio principale dello storage dei dati (volume Amazon EBS) utilizzato dall'istanza. Lo spazio usato—insieme a file di dati, log delle modifiche, audit, traccia e altri file— fa parte dello storage allocato.
Puoi spostare un file di dati esterno da un database Oracle a un altro utilizzando il pacchetto [ DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/database/121/ARPLS/d_ftran.htm#ARPLS095) o [UTL\$1FILE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS069). I file dati esterni si spostano da una directory nel database origine a una directory specificata nel database di destinazione. Per ulteriori informazioni sull'uso di `DBMS_FILE_TRANSFER`, consultare [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
Dopo aver spostato il file dei dati esterno puoi crearci una tabella esterna. L'esempio seguente crea una tabella esterna che utilizza il `emp_xt_file1.txt` file nella directory USER\$1DIR1 .
```
CREATE TABLE emp_xt (
emp_id NUMBER,
first_name VARCHAR2(50),
last_name VARCHAR2(50),
user_name VARCHAR2(20)
)
ORGANIZATION EXTERNAL (
TYPE ORACLE_LOADER
DEFAULT DIRECTORY USER_DIR1
ACCESS PARAMETERS (
RECORDS DELIMITED BY NEWLINE
FIELDS TERMINATED BY ','
MISSING FIELD VALUES ARE NULL
(emp_id,first_name,last_name,user_name)
)
LOCATION ('emp_xt_file1.txt')
)
PARALLEL
REJECT LIMIT UNLIMITED;
```
Immaginiamo che desideri spostare i dati che si trovano nell'istanza database Amazon RDS Oracle nel file di dati esterno. In questo caso, puoi popolare il file di dati esterno creando una tabella esterna e selezionando i dati dalla tabella nel database. Ad esempio, la seguente istruzione SQL crea la tabella esterna `orders_xt` eseguendo la query sulla tabella `orders` nel database.
```
CREATE TABLE orders_xt
ORGANIZATION EXTERNAL
(
TYPE ORACLE_DATAPUMP
DEFAULT DIRECTORY DATA_PUMP_DIR
LOCATION ('orders_xt.dmp')
)
AS SELECT * FROM orders;
```
In questo esempio, i dati sono popolati nel file `orders_xt.dmp` nella directory DATA\$1PUMP\$1DIR.
# Checkpoint di un database
Puoi usare la procedura in Amazon RDS per eseguire il checkpoint del database `rdsadmin.rdsadmin_util.checkpoint`. La procedura `checkpoint` non ha parametri.
L'esempio seguente esegue il checkpoint del database.
```
EXEC rdsadmin.rdsadmin_util.checkpoint;
```
# Impostazione del ripristino distribuito
Puoi usare le procedure `rdsadmin.rdsadmin_util.enable_distr_recovery` e `disable_distr_recovery` in Amazon RDS per impostare il ripristino distribuito. Le procedure non hanno parametri.
L'esempio seguente abilita il ripristino distribuito.
```
EXEC rdsadmin.rdsadmin_util.enable_distr_recovery;
```
L'esempio seguente disabilita il ripristino distribuito.
```
EXEC rdsadmin.rdsadmin_util.disable_distr_recovery;
```
# Impostazione del fuso orario del database
È possibile impostare il fuso orario del database Amazon RDS Oracle nei modi seguenti:
+ L'opzione `Timezone`
L'opzione `Timezone` modifica il fuso orario a livello di host e interessa tutte le colonne e valori data come `SYSDATE`. Per ulteriori informazioni, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md).
+ La procedura Amazon RDS `rdsadmin.rdsadmin_util.alter_db_time_zone`
La procedura `alter_db_time_zone` modifica il fuso orario solo per certi tipi di dati e non modifica `SYSDATE`. Ci sono limitazioni aggiuntive per l'impostazione del fuso orario elencato nella [Documentazione di Oracle](http://docs.oracle.com/cd/B19306_01/server.102/b14225/ch4datetime.htm#i1006705).
**Nota**
È inoltre possibile impostare il fuso orario predefinito per Oracle Scheduler. Per ulteriori informazioni, consulta [Impostazione del fuso orario per i job di Oracle Scheduler](Appendix.Oracle.CommonDBATasks.Scheduler.md#Appendix.Oracle.CommonDBATasks.Scheduler.TimeZone).
La procedura `alter_db_time_zone` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_new_tz` | varchar2 | — | Sì | Il nuovo fuso orario come regione denominata o un offset assoluto da Coordinated Universal Time (UTC). Gli offset validi sono compresi tra -12.00 e \$114.00. |
Il seguente esempio imposta il fuso orario su UTC più tre ore.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => '+3:00');
```
L'esempio seguente modifica il fuso orario in fuso Africa/Algiers orario.
```
EXEC rdsadmin.rdsadmin_util.alter_db_time_zone(p_new_tz => 'Africa/Algiers');
```
Dopo aver modificato il fuso orario utilizzando la procedura `alter_db_time_zone`, devi riavviare l'istanza database per rendere effettive le modifiche. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md). Per informazioni sull'aggiornamento dei fusi orari, consulta [Considerazioni sul fuso orario](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
# Generazione di report sulle prestazioni con AWR (Automatic Workload Repository)
Per raccogliere i dati sulle prestazioni e generare report, Oracle consiglia AWR (Automatic Workload Repository). AWR richiede Oracle Database Enterprise Edition e una licenza per i pacchetti di diagnostica e ottimizzazione. Per abilitare AWR, impostare il parametro di inizializzazione `CONTROL_MANAGEMENT_PACK_ACCESS` su `DIAGNOSTIC` o `DIAGNOSTIC+TUNING`.
## Utilizzo di report AWR in RDS
Per generare report AWR, puoi eseguire script quali `awrrpt.sql`. Questi script vengono installati nel server host del database. In Amazon RDS non è possibile accedere direttamente all'host. Tuttavia, puoi ottenere copie di script SQL da un'altra installazione di Oracle Database.
È inoltre possibile utilizzare AWR eseguendo le procedure nel `SYS.DBMS_WORKLOAD_REPOSITORY` PL/SQL pacchetto. Puoi utilizzare questo pacchetto per gestire baseline e snapshot, nonché visualizzare report ASH e AWR. Ad esempio, per generare un report AWR in formato di testo, esegui la procedura `DBMS_WORKLOAD_REPOSITORY.AWR_REPORT_TEXT`. Tuttavia, non puoi raggiungere questi report AWR da Console di gestione AWS.
Quando utilizzi AWR, ti consigliamo di utilizzare le procedure `rdsadmin.rdsadmin_diagnostic_util`. Puoi utilizzare queste procedure per generare quanto segue:
+ Report AWR
+ Report ASH (Active Session History)
+ Report ADDM (Automatic Database Diagnostic Monitor)
+ File di dump di Export di Oracle Data Pump di dati AWR
Le procedure `rdsadmin_diagnostic_util` salvano i report nel file system dell'istanza database. Puoi accedere a questi report dalla console. Puoi inoltre accedere ai report utilizzando le procedure `rdsadmin.rds_file_util` e accedere ai report copiati in Simple Storage Service (Amazon S3) mediante l'opzione Integrazione S3. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles) e [Integrazione Amazon S3](oracle-s3-integration.md).
Puoi utilizzare le procedure `rdsadmin_diagnostic_util` nelle seguente per versioni del motore database Amazon RDS for Oracle:
+ Tutte le versioni di Oracle Database 21c
+ 19.0.0.0.ru-2020-04.rur-2020-04.r1 e versioni successive di Oracle Database 19c
Per un blog che spiega come utilizzare i report diagnostici in uno scenario di replica, consulta il post relativo alla [generazione di report AWR per le repliche di lettura di Amazon RDS per Oracle](https://aws.amazon.com/blogs/database/generate-awr-reports-for-amazon-rds-for-oracle-read-replicas/).
## Parametri comuni per il pacchetto di utilità di diagnostica
In genere i seguenti parametri vengono utilizzati durante la gestione di AWR e ADDM con il pacchetto `rdsadmin_diagnostic_util`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
In genere i seguenti parametri vengono utilizzati durante la gestione di ASH con il pacchetto rdsadmin\$1diagnostic\$1util.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.AWR.html)
## Generazione di un report AWR
Per generare un report AWR, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.awr_report`.
Nell'esempio seguente viene generato un report AWR per l'intervallo di snapshot da 101 a 106. Il file di testo di output è denominato `awrrpt_101_106.txt`. Puoi accedere a questo report da Console di gestione AWS.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(101,106,'TEXT');
```
Nell'esempio seguente viene generato un report HTML per l'intervallo di snapshot da 63 a 65. Il file HTML di output è denominato `awrrpt_63_65.html`. La procedura scrive il report nella directory di database non predefinita denominata `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_report(63,65,'HTML','AWR_RPT_DUMP');
```
## Estrazione di dati AWR in un file di dump
Per estrarre i dati AWR in un file di dump, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.awr_extract`. È possibile utilizzare questa funzione solo a livello di PDB.
Nell'esempio seguente viene estratto l'intervallo di snapshot da 101 a 106. Il file di dump di output è denominato `awrextract_101_106.dmp`. Puoi accedere a questo file tramite la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(101,106);
```
Nell'esempio seguente viene estratto l'intervallo di snapshot da 63 a 65. Il file di dump di output è denominato `awrextract_63_65.dmp`. Il file viene archiviato nella directory di database non predefinita denominata `AWR_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.awr_extract(63,65,'AWR_RPT_DUMP');
```
## Generazione di un report ADDM
Per generare un report ADDM, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.addm_report`.
Nell'esempio seguente viene generato un report ADDM per l'intervallo di snapshot da 101 a 106. Il file di testo di output è denominato `addmrpt_101_106.txt`. È possibile accedere al report tramite la console.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(101,106);
```
Nell'esempio seguente viene generato un report ADDM per l'intervallo di snapshot da 63 a 65. Il file di testo di output è denominato `addmrpt_63_65.txt`. Il file viene archiviato nella directory di database non predefinita denominata `ADDM_RPT_DUMP`.
```
EXEC rdsadmin.rdsadmin_diagnostic_util.addm_report(63,65,'ADDM_RPT_DUMP');
```
## Generazione di un report ASH
Per generare un report ASH, utilizza la procedura `rdsadmin.rdsadmin_diagnostic_util.ash_report`.
Nell'esempio seguente viene generato un report ASH che include i dati da 14 minuti fa fino all'ora corrente. Il nome del file di output utilizza il formato `ashrptbegin_timeend_time.txt`, dove `begin_time` e `end_time` utilizzano il formato `YYYYMMDDHH24MISS`. Puoi accedere al file tramite la console.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => SYSDATE-14/1440,
end_time => SYSDATE,
report_type => 'TEXT');
END;
/
```
Nell'esempio seguente viene generato un report ASH che include i dati dal 18 novembre 2019 alle 18.07 fino al 18 novembre 2019 alle 18.15. Il nome del report HTML di output è `ashrpt_20190918180700_20190918181500.html`. Il file viene archiviato nella directory di database non predefinita denominata `AWR_RPT_DUMP`.
```
BEGIN
rdsadmin.rdsadmin_diagnostic_util.ash_report(
begin_time => TO_DATE('2019-09-18 18:07:00', 'YYYY-MM-DD HH24:MI:SS'),
end_time => TO_DATE('2019-09-18 18:15:00', 'YYYY-MM-DD HH24:MI:SS'),
report_type => 'html',
dump_directory => 'AWR_RPT_DUMP');
END;
/
```
## Accesso ai report AWR dalla console o da CLI
Per accedere ai report AWR o esportare file di dump, puoi usare o. Console di gestione AWS AWS CLI Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
# Modifica dei collegamenti di database per l'utilizzo con le istanze database in un VPC
Per utilizzare i collegamenti al database Oracle con le istanze DB di Amazon RDS all'interno dello stesso cloud privato virtuale (VPC) o in peering VPCs, le due istanze DB devono avere un percorso valido tra di loro. Verifica l'instradamento valido tra le istanze database utilizzando le tabelle di routing VPC e la lista di controllo accessi della rete (ACL).
Il gruppo di sicurezza di ogni istanza database deve permettere l'ingresso e l'uscita dall'altra istanza database. Le regole in entrata e in uscita possono riferirsi ai gruppi di sicurezza dallo stesso VPC o da un VPC in peering. Per ulteriori informazioni, consulta [Aggiornamento dei gruppi di sicurezza a gruppi di sicurezza VPC in peering di riferimento](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html#vpc-peering-security-groups).
Se hai configurato un server DNS personalizzato utilizzando il set opzioni DHCP nel VPC, il server DNS personalizzato deve essere in grado di risolvere il nome del target del collegamento di database. Per ulteriori informazioni, consulta [Impostazione di un server DNS personalizzato](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
Per ulteriori informazioni sull'utilizzo di collegamenti di database con Oracle Data Pump, consulta [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# Impostazione dell'edizione predefinita per un'istanza database
Puoi ridefinire gli oggetti di database in un ambiente privato che si chiama edizione. Puoi utilizzare una ridefinizione basata sull'edizione per aggiornare gli oggetti di database dell'applicazione con tempo di inattività minimo.
Puoi impostare l'edizione predefinita di un'istanza database Oracle Amazon RDS usando la procedura in Amazon RDS `rdsadmin.rdsadmin_util.alter_default_edition`.
L'esempio seguente imposta l'edizione predefinita per l'istanza database Oracle Amazon RDS su `RELEASE_V1`.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('RELEASE_V1');
```
L'esempio seguente imposta l'edizione predefinita per l'istanza database Amazon RDS Oracle a quella predefinita di Oracle.
```
EXEC rdsadmin.rdsadmin_util.alter_default_edition('ORA$BASE');
```
Per ulteriori informazioni sulla ridefinizione Oracle basata sull'edizione, consulta le [Informazioni sulla edizione e sulla ridefinizione basata sull'edizione](https://docs.oracle.com/database/121/ADMIN/general.htm#ADMIN13167) nella documentazione di Oracle.
# Abilitazione dell'audit per la tabella SYS.AUD\$1
Puoi utilizzare la procedura `SYS.AUD$` in Amazon RDS per abilitare l'audit sulla tabella di trail dell'audit del database `rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table`. L'unica proprietà dell'audit supportata è `ALL`. Non è possibile sottoporre o non sottoporre ad audit singole istruzioni o operazioni.
L'abilitazione dell'audit è supportata per le istanze database Oracle che eseguono le seguenti versioni:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
La procedura `audit_all_sys_aud_table` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_by_access` | booleano | true | No | Impostato su `true` per l'audit di `BY ACCESS`. Impostato su `false` per l'audit di `BY SESSION`. |
La seguente query restituisce l'attuale configurazione dell'audit di `SYS.AUD$` per un database.
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
I seguenti comandi abilitano l'audit di `ALL` su `SYS.AUD$` `BY ACCESS`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table;
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => true);
```
Il seguente comando abilita l'audit di `ALL` su `SYS.AUD$` `BY SESSION`.
```
EXEC rdsadmin.rdsadmin_master_util.audit_all_sys_aud_table(p_by_access => false);
```
Per ulteriori informazioni, consulta la sezione relativa all'[AUDIT (Audit tradizionale)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/AUDIT-Traditional-Auditing.html#GUID-ADF45B07-547A-4096-8144-50241FA2D8DD) nella documentazione Oracle.
# Disabilitazione dell'audit per la tabella SYS.AUD\$1
Puoi utilizzare la procedura `SYS.AUD$` in Amazon RDS per disabilitare l'audit sulla tabella di trail dell'audit del database `rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table`. Questa procedura non richiede parametri.
La seguente query restituisce l'attuale configurazione dell'audit di `SYS.AUD$` per un database:
```
SELECT * FROM DBA_OBJ_AUDIT_OPTS WHERE OWNER='SYS' AND OBJECT_NAME='AUD$';
```
Il seguente comando disabilita l'audit di `ALL` su `SYS.AUD$`.
```
EXEC rdsadmin.rdsadmin_master_util.noaudit_all_sys_aud_table;
```
Per ulteriori informazioni, consulta la sezione relativa a [NOAUDIT (Audit tradizionale)](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/sqlrf/NOAUDIT-Traditional-Auditing.html#GUID-9D8EAF18-4AB3-4C04-8BF7-37BD0E15434D) nella documentazione Oracle.
# Pulizia di compilazioni dell'indice online interrotte
Per pulire compilazioni dell'indice online non riuscite, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_dbms_repair.online_index_clean`.
La procedura `online_index_clean` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `object_id` | binary\$1integer | `ALL_INDEX_ID` | No | L'ID oggetto dell'indice. In genere, puoi utilizzare l'ID oggetto dal testo dell'errore ORA-08104. |
| `wait_for_lock` | binary\$1integer | `rdsadmin.rdsadmin_dbms_repair.lock_wait` | No | Specifica `rdsadmin.rdsadmin_dbms_repair.lock_wait`, l'impostazione predefinita, per cercare di ottenere un blocco sull'oggetto sottostante e riprovare finché non viene raggiunto un limite interno se il blocco non va a buon fine. Specifica `rdsadmin.rdsadmin_dbms_repair.lock_nowait` per cercare di ottenere un blocco sull'oggetto sottostante ma non riprovare se il blocco non va a buon fine. |
L'esempio seguente pulisce una compilazione di indice online non riuscita:
```
declare
is_clean boolean;
begin
is_clean := rdsadmin.rdsadmin_dbms_repair.online_index_clean(
object_id => 1234567890,
wait_for_lock => rdsadmin.rdsadmin_dbms_repair.lock_nowait
);
end;
/
```
Per ulteriori informazioni, consulta [ONLINE\$1INDEX\$1CLEAN Function](https://docs.oracle.com/database/121/ARPLS/d_repair.htm#ARPLS67555) nella documentazione Oracle.
# Ignorare blocchi corrotti
Per ignorare blocchi corrotti durante le scansioni di indici e tabelle, utilizza il pacchetto `rdsadmin.rdsadmin_dbms_repair`.
Le seguenti procedure eseguono il wrapping della funzionalità della procedura `sys.dbms_repair.admin_table` e non accettano parametri:
+ `rdsadmin.rdsadmin_dbms_repair.create_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_repair_table`
+ `rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table`
Le seguenti procedure accettano gli stessi parametri delle loro controparti nel pacchetto `DBMS_REPAIR` per database Oracle:
+ `rdsadmin.rdsadmin_dbms_repair.check_object`
+ `rdsadmin.rdsadmin_dbms_repair.dump_orphan_keys`
+ `rdsadmin.rdsadmin_dbms_repair.fix_corrupt_blocks`
+ `rdsadmin.rdsadmin_dbms_repair.rebuild_freelists`
+ `rdsadmin.rdsadmin_dbms_repair.segment_fix_status`
+ `rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks`
Per ulteriori informazioni sulla gestione del danneggiamento del database, vedere [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948) nella documentazione Oracle.
**Example Risposta a blocchi danneggiati**
Questo esempio mostra il flusso di lavoro di base per rispondere ai blocchi danneggiati. I passaggi dipenderanno dalla posizione e dalla natura del danneggiamento del blocco.
Prima di tentare di riparare i blocchi danneggiati, esaminare attentamente la documentazione di [DBMS\$1REPAIR](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_REPAIR.html#GUID-B8EC4AB3-4D6A-46C9-857F-4ED53CD9C948).
**Per saltare i blocchi danneggiati durante le scansioni di indice e tabella**
1. Esegui le procedure seguenti per creare tabelle di riparazione se non esistono già.
```
EXEC rdsadmin.rdsadmin_dbms_repair.create_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.create_orphan_keys_table;
```
1. Esegui le procedura seguenti per verificare l'esistenza di record e cancellarli se appropriato.
```
SELECT COUNT(*) FROM SYS.REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.ORPHAN_KEY_TABLE;
SELECT COUNT(*) FROM SYS.DBA_REPAIR_TABLE;
SELECT COUNT(*) FROM SYS.DBA_ORPHAN_KEY_TABLE;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.purge_orphan_keys_table;
```
1. Esegui la procedura seguente per verificare la presenza di blocchi corrotti.
```
SET SERVEROUTPUT ON
DECLARE v_num_corrupt INT;
BEGIN
v_num_corrupt := 0;
rdsadmin.rdsadmin_dbms_repair.check_object (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
corrupt_count => v_num_corrupt
);
dbms_output.put_line('number corrupt: '||to_char(v_num_corrupt));
END;
/
COL CORRUPT_DESCRIPTION FORMAT a30
COL REPAIR_DESCRIPTION FORMAT a30
SELECT OBJECT_NAME, BLOCK_ID, CORRUPT_TYPE, MARKED_CORRUPT,
CORRUPT_DESCRIPTION, REPAIR_DESCRIPTION
FROM SYS.REPAIR_TABLE;
SELECT SKIP_CORRUPT
FROM DBA_TABLES
WHERE OWNER = '&corruptionOwner'
AND TABLE_NAME = '&corruptionTable';
```
1. Esegui la procedura `skip_corrupt_blocks` per abilitare o disabilitare l'omissione della corruzione per le tabelle interessate. A seconda della situazione, potrebbe essere necessario estrarre i dati in una nuova tabella e quindi eliminare la tabella contenente il blocco danneggiato.
Esegui la procedura seguente per ignorare la corruzione per le tabelle interessate.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.skip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
Esegui la procedura seguente per non ignorare la corruzione.
```
begin
rdsadmin.rdsadmin_dbms_repair.skip_corrupt_blocks (
schema_name => '&corruptionOwner',
object_name => '&corruptionTable',
object_type => rdsadmin.rdsadmin_dbms_repair.table_object,
flags => rdsadmin.rdsadmin_dbms_repair.noskip_flag);
end;
/
select skip_corrupt from dba_tables where owner = '&corruptionOwner' and table_name = '&corruptionTable';
```
1. Dopo aver completato tutti i lavori di riparazione, eseguire le procedure seguenti per eliminare le tabelle di ripristino.
```
EXEC rdsadmin.rdsadmin_dbms_repair.drop_repair_table;
EXEC rdsadmin.rdsadmin_dbms_repair.drop_orphan_keys_table;
```
## Eliminazione del cestino riciclaggio
Quando si rilascia una tabella, il database Oracle non rimuove immediatamente lo spazio di storage. Il database rinomina la tabella inserendola insieme agli eventuali oggetti associati in un cestino riciclaggio. L'eliminazione del cestino riciclaggio rimuove questi elementi e rilascia il relativo spazio di storage.
Per rimuovere l'intero cestino riciclaggio, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.purge_dba_recyclebin`. Tuttavia, questa procedura non può eliminare dal cestino riciclaggio gli oggetti `SYS` e `RDSADMIN`. Se è necessario eliminare questi oggetti, contatta AWS Support.
Nell'esempio seguente viene eliminato l'intero cestino riciclaggio.
```
EXEC rdsadmin.rdsadmin_util.purge_dba_recyclebin;
```
# Impostazione dei valori di default visualizzati per la redazione completa
Per modificare i valori di default visualizzati per la redazione completa sull'istanza Oracle Amazon RDS, utilizza la procedura `rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val` di Amazon RDS. Si noti che si crea una politica di redazione con il `DBMS_REDACT` PL/SQL pacchetto, come spiegato nella documentazione di Oracle Database. La procedura `dbms_redact_upd_full_rdct_val` specifica i caratteri da visualizzare per i diversi tipi di dati influenzati da una policy esistente.
La procedura `dbms_redact_upd_full_rdct_val` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_number_val` | numero | Null | No | Modifica il valore di default per le colonne del tipo di dati `NUMBER`. |
| `p_binfloat_val` | binary\$1float | Null | No | Modifica il valore di default per le colonne del tipo di dati `BINARY_FLOAT`. |
| `p_bindouble_val` | binary\$1double | Null | No | Modifica il valore di default per le colonne del tipo di dati `BINARY_DOUBLE`. |
| `p_char_val` | char | Null | No | Modifica il valore di default per le colonne del tipo di dati `CHAR`. |
| `p_varchar_val` | varchar2 | Null | No | Modifica il valore di default per le colonne del tipo di dati `VARCHAR2`. |
| `p_nchar_val` | nchar | Null | No | Modifica il valore di default per le colonne del tipo di dati `NCHAR`. |
| `p_nvarchar_val` | nvarchar2 | Null | No | Modifica il valore di default per le colonne del tipo di dati `NVARCHAR2`. |
| `p_date_val` | data | Null | No | Modifica il valore di default per le colonne del tipo di dati `DATE`. |
| `p_ts_val` | timestamp | Null | No | Modifica il valore di default per le colonne del tipo di dati `TIMESTAMP`. |
| `p_tswtz_val` | timestamp with time zone | Null | No | Modifica il valore di default per le colonne del tipo di dati `TIMESTAMP WITH TIME ZONE`. |
| `p_blob_val` | blob | Null | No | Modifica il valore di default per le colonne del tipo di dati `BLOB`. |
| `p_clob_val` | clob | Null | No | Modifica il valore di default per le colonne del tipo di dati `CLOB`. |
| `p_nclob_val` | nclob | Null | No | Modifica il valore di default per le colonne del tipo di dati `NCLOB`. |
L'esempio seguente modifica il valore di default redatto in \$1 per il tipo di dati `CHAR`:
```
EXEC rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(p_char_val => '*');
```
L'esempio seguente modifica i valori di default redatti per i tipi di dati `NUMBER`, `DATE` e `CHAR`:
```
BEGIN
rdsadmin.rdsadmin_util.dbms_redact_upd_full_rdct_val(
p_number_val=>1,
p_date_val=>to_date('1900-01-01','YYYY-MM-DD'),
p_varchar_val=>'X');
END;
/
```
Dopo aver modificato i valori di default per la redazione completa con la procedura `dbms_redact_upd_full_rdct_val`, riavvia l'istanza database per rendere effettiva la modifica. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
# Esecuzione di attività comuni relative ai log per le istanze database Oracle
Di seguito, viene descritto come eseguire determinate attività DBA comuni relative all'accesso alle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
Per ulteriori informazioni, consulta [File di log del database Amazon RDS per Oracle](USER_LogAccess.Concepts.Oracle.md).
**Topics**
+ [Impostazione accesso forzato](#Appendix.Oracle.CommonDBATasks.SettingForceLogging)
+ [Impostazione di accesso supplementare](#Appendix.Oracle.CommonDBATasks.AddingSupplementalLogging)
+ [Cambio dei file di log online](#Appendix.Oracle.CommonDBATasks.SwitchingLogfiles)
+ [Aggiunta di log redo online](#Appendix.Oracle.CommonDBATasks.RedoLogs)
+ [Eliminazione di log redo online](#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs)
+ [Ridimensionamento di log redo online](Appendix.Oracle.CommonDBATasks.ResizingRedoLogs.md)
+ [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md)
+ [Accesso ai log di ripristino online e archiviati](Appendix.Oracle.CommonDBATasks.Log.Download.md)
+ [Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)](Appendix.Oracle.CommonDBATasks.download-redo-logs.md)
## Impostazione accesso forzato
In modalità accesso forzato, Oracle registra tutte le modifiche nel database ad eccezione delle modifiche in spazi tabella temporanei e segmenti temporanei (le clausole `NOLOGGING` vengono ignorate). Per ulteriori informazioni, consulta [Specificare la modalità FORCE LOGGING (ACCESSO FORZATO)](https://docs.oracle.com/cd/E11882_01/server.112/e25494/create.htm#ADMIN11096) nella documentazione Oracle.
Puoi usare la procedura in Amazon RDS per impostare il logging forzato `rdsadmin.rdsadmin_util.force_logging`. La procedura `force_logging` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Sì | Descrizione |
| --- | --- | --- | --- | --- |
| `p_enable` | booleano | true | No | Imposta su `true` per impostare il database nella modalità accesso forzato, `false` per rimuovere il database dalla modalità accesso forzato. |
L'esempio seguente imposta il database in modalità accesso forzato.
```
EXEC rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
## Impostazione di accesso supplementare
Se abiliti la registrazione supplementare, LogMiner dispone delle informazioni necessarie per supportare righe concatenate e tabelle raggruppate. Per ulteriori informazioni, consulta la pagina [Accesso supplementare](https://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm#SUTIL1582) nella documentazione Oracle.
L'Oracle Database non abilita l'accesso supplementare come impostazione predefinita. Puoi usare la procedura in Amazon RDS per abilitare e disabilitare il logging supplementare `rdsadmin.rdsadmin_util.alter_supplemental_logging`. Per ulteriori informazioni sul modo in cui Amazon RDS gestisce la conservazione dei log delle modifiche archiviati per istanze database Oracle, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
La procedura `alter_supplemental_logging` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_action` | varchar2 | — | Sì | `'ADD'` per aggiungere l'accesso supplementare, `'DROP'` per rilasciare l'accesso supplementare. |
| `p_type` | varchar2 | null | No | Tipo di accesso supplementare. I valori validi sono `'ALL'`, `'FOREIGN KEY'`, `'PRIMARY KEY'`, `'UNIQUE'` o `PROCEDURAL`. |
L'esempio seguente abilita l'accesso supplementare.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD');
end;
/
```
L'esempio seguente abilita l'accesso supplementare per tutte le colonne di lunghezza fissa massima.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'ALL');
end;
/
```
L'esempio seguente abilita l'accesso supplementare per le colonne chiave primarie.
```
begin
rdsadmin.rdsadmin_util.alter_supplemental_logging(
p_action => 'ADD',
p_type => 'PRIMARY KEY');
end;
/
```
## Cambio dei file di log online
Puoi usare la procedura in Amazon RDS per cambiare file di lo `rdsadmin.rdsadmin_util.switch_logfile`. La procedura `switch_logfile` non ha parametri.
L'esempio seguente cambia i file di log.
```
EXEC rdsadmin.rdsadmin_util.switch_logfile;
```
## Aggiunta di log redo online
Un'istanza database Amazon RDS che esegue Oracle inizia con quattro log redo online, di 128 MB ciascuno. Puoi usare la procedura in Amazon RDS per aggiungere ulteriori log red `rdsadmin.rdsadmin_util.add_logfile`.
La procedura `add_logfile` include i seguenti parametri.
**Nota**
I parametri sono si escludono a vicenda.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `bytes` | positivo | null | No | Le dimensioni del file di log in byte. Utilizza questo parametro solo se la dimensione del log è inferiore a 2147483648 bytes (2 GiB). In caso contrario, RDS restituisce un errore. Per le dimensioni dei log superiori a questo valore di byte, utilizza invece il parametro `p_size`. |
| `p_size` | varchar2 | — | Sì | Le dimensioni del file di log in kilobyte (K), megabyte (M) o gigabyte (G). |
Il seguente comando aggiunge un file di log di 100 MB.
```
EXEC rdsadmin.rdsadmin_util.add_logfile(p_size => '100M');
```
## Eliminazione di log redo online
Puoi utilizzare la procedura in Amazon RDS per rilasciare i log red `rdsadmin.rdsadmin_util.drop_logfile`. La procedura `drop_logfile` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `grp` | positivo | — | Sì | Il numero di gruppo del log. |
L'esempio seguente rilascia il log con il numero di gruppo 3.
```
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
```
Puoi solo rilasciare log che hanno uno stato di inutilizzato o inattivo. L'esempio seguente ottiene gli stati dei log.
```
SELECT GROUP#, STATUS FROM V$LOG;
GROUP# STATUS
---------- ----------------
1 CURRENT
2 INACTIVE
3 INACTIVE
4 UNUSED
```
# Ridimensionamento di log redo online
Un'istanza database Amazon RDS che esegue Oracle inizia con quattro log redo online, di 128 MB ciascuno. L'esempio seguente visualizza come si possono utilizzare le procedure Amazon RDS per ridimensionare i log da 128 MB ciascuno a 512 MB ciascuno.
```
/* Query V$LOG to see the logs. */
/* You start with 4 logs of 128 MB each. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
/* Add four new logs that are each 512 MB */
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
EXEC rdsadmin.rdsadmin_util.add_logfile(bytes => 536870912);
/* Query V$LOG to see the logs. */
/* Now there are 8 logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
1 134217728 INACTIVE
2 134217728 CURRENT
3 134217728 INACTIVE
4 134217728 INACTIVE
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Drop each inactive log using the group number. */
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 1);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 3);
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 4);
/* Query V$LOG to see the logs. */
/* Now there are 5 logs. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 CURRENT
5 536870912 UNUSED
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* Switch logs so that group 2 is no longer current. */
EXEC rdsadmin.rdsadmin_util.switch_logfile;
/* Query V$LOG to see the logs. */
/* Now one of the new logs is current. */
SQL>SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 ACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
/* If the status of log 2 is still "ACTIVE", issue a checkpoint to clear it to "INACTIVE". */
EXEC rdsadmin.rdsadmin_util.checkpoint;
/* Query V$LOG to see the logs. */
/* Now the final original log is inactive. */
select GROUP#, BYTES, STATUS from V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
2 134217728 INACTIVE
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
# Drop the final inactive log.
EXEC rdsadmin.rdsadmin_util.drop_logfile(grp => 2);
/* Query V$LOG to see the logs. */
/* Now there are four 512 MB logs. */
SELECT GROUP#, BYTES, STATUS FROM V$LOG;
GROUP# BYTES STATUS
---------- ---------- ----------------
5 536870912 CURRENT
6 536870912 UNUSED
7 536870912 UNUSED
8 536870912 UNUSED
```
# Conservazione dei log redo archiviati
È possibile conservare i redo log archiviati localmente sull'istanza DB per utilizzarli con prodotti come Oracle LogMiner (). `DBMS_LOGMNR` Dopo aver conservato i redo log, è possibile utilizzarli per analizzarli. LogMiner Per ulteriori informazioni, vedere [Using LogMiner to analysis redo log file](http://docs.oracle.com/cd/E11882_01/server.112/e22490/logminer.htm) nella documentazione Oracle.
Puoi usare la procedura in Amazon RDS per mantenere i log redo archiviat `rdsadmin.rdsadmin_util.set_configuration`. Se utilizzi questa procedura su un’istanza primaria in Oracle Data Guard, RDS modifica l’impostazione relativa alla conservazione dei log di archivio sull’istanza primaria e apre le repliche di lettura, ma non sulle repliche montate. RDS mantiene i log di redo di archivio più recenti sulle repliche montate per un breve periodo di tempo. RDS elimina automaticamente i log precedenti scaricati nelle repliche montate.
La procedura `set_configuration` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `name` | varchar | — | Sì | Il nome della configurazione da aggiornare. Per modificare gli orari di conservazione dei log di redo archiviati, imposta il nome su `archivelog retention hours`. |
| `value` | varchar | — | Sì | Il valore per la configurazione. Imposta il valore del numero di ore in cui mantenere i log. |
L'esempio seguente conserva 24 ore di log redo.
```
begin
rdsadmin.rdsadmin_util.set_configuration(
name => 'archivelog retention hours',
value => '24');
end;
/
commit;
```
**Nota**
La conferma è necessaria per rendere effettiva la modifica.
Puoi utilizzare la procedura Amazon RDS per visualizzare quanto a lungo i log redo archiviati vengono conservati per l'istanza databas `rdsadmin.rdsadmin_util.show_configuration`.
L'esempio seguente mostra il tempo di conservazione dei log.
```
set serveroutput on
EXEC rdsadmin.rdsadmin_util.show_configuration;
```
L'output indica l'impostazione corrente per `archivelog retention hours`. L'output seguente indica che i log redo vengono mantenuti per 48 ore.
```
NAME:archivelog retention hours
VALUE:48
DESCRIPTION:ArchiveLog expiration specifies the duration in hours before archive/redo log files are automatically deleted.
```
Poiché i log redo archiviati vengono conservati nell'istanza database, assicurati che l'istanza database abbia abbastanza storage allocato per i log conservati. Per determinare quanto spazio l'istanza database ha utilizzato nelle ultime X ore, puoi eseguire la query seguente, sostituendo X con il numero di ore.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) bytes
FROM V$ARCHIVED_LOG
WHERE FIRST_TIME >= SYSDATE-(X/24) AND DEST_ID=1;
```
I log di ripristino archiviati vengono generati solo se il tempo di conservazione del backup dell'istanza database è superiore a zero. Per impostazione predefinita, il tempo di conservazione del backup è maggiore di zero.
Alla scadenza del periodo di conservazione dei log archiviati, RDS per Oracle rimuove i log di ripristino archiviati dall'istanza database. Per supportare il ripristino dell'istanza del DB a un punto temporale specifico, Amazon RDS conserva i log di ripristino archiviati al di fuori dell'istanza database in base al tempo di conservazione del backup. Per modificare il tempo di conservazione del backup, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
**Nota**
In alcuni casi, si potrebbe utilizzare JDBC su Linux per scaricare i log redo archiviati e riscontrare periodi di latenza e ripristini di connessione lunghi. In questi casi i problemi potrebbero dipendere dall'impostazione predefinita del generatore di numeri casuali nel client Java. Consigliamo di impostare i driver JDBC in modo che utilizzino un generatore di numero casuale senza blocchi.
# Accesso ai log di ripristino online e archiviati
Potresti voler accedere ai tuoi redo log file online e archiviati per il mining con strumenti esterni come Attunity GoldenGate, Informatica e altri. Per accedere a questi file, effettuare le operazioni seguenti:
1. Creare oggetti di directory che forniscono l'accesso di sola lettura ai percorsi fisici dei file.
Uso di `rdsadmin.rdsadmin_master_util.create_archivelog_dir` e `rdsadmin.rdsadmin_master_util.create_onlinelog_dir`.
1. Leggere i file utilizzando PL/SQL.
È possibile leggere i file utilizzando PL/SQL. Per ulteriori informazioni sulla lettura di file dagli oggetti di directory, consulta [Generazione di un elenco dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ListDirectories) e [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
L'accesso ai log delle transazioni è supportato per le versioni seguenti:
+ Oracle Database 21c
+ Oracle Database 19c
Il seguente codice crea delle directory che forniscono accesso di sola lettura ai file di log redo online e archiviati:
**Importante**
Questo codice revoca anche il privilegio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.create_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.create_onlinelog_dir;
```
Il seguente codice rilascia directory per i file di log redo online e archiviati.
```
EXEC rdsadmin.rdsadmin_master_util.drop_archivelog_dir;
EXEC rdsadmin.rdsadmin_master_util.drop_onlinelog_dir;
```
Il seguente codice concede e revoca il privilegio `DROP ANY DIRECTORY`.
```
EXEC rdsadmin.rdsadmin_master_util.revoke_drop_any_directory;
EXEC rdsadmin.rdsadmin_master_util.grant_drop_any_directory;
```
# Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)
È possibile scaricare i log di ripristino archiviati nell'istanza database utilizzando il pacchetto `rdsadmin.rdsadmin_archive_log_download`. Se i log di ripristino archiviati non sono più presenti nell'istanza database, sarà possibile scaricarli di nuovo da Simple Storage Service (Amazon S3). Quindi è possibile estrarre i log o utilizzarli per recuperare o replicare il database.
**Nota**
Non è possibile scaricare log redo archiviati sulle istanze di replica di lettura.
## Download dei log di ripristino archiviati: passaggi di base
La disponibilità dei log di ripristino archiviati dipende dalle seguenti policy di conservazione:
+ Policy di conservazione dei backup: i log all'interno di questa politica sono disponibili in Simple Storage Service (Amazon S3). I log esterni a questa policy vengono rimossi.
+ Policy di conservazione dei log archiviati: i log all'interno di questa policy sono disponibili nell'istanza database. I log esterni a questa policy vengono rimossi.
Se i log non sono presenti nell'istanza ma sono protetti dal tempo di conservazione del backup, utilizza `rdsadmin.rdsadmin_archive_log_download` per scaricarli di nuovo. RDS per Oracle salva i log nella directory `/rdsdbdata/log/arch` nell'istanza database.
**Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3)**
1. Configura il periodo di conservazione per assicurarti che i log redo archiviati scaricati vengano mantenuti per la durata necessaria. Assicurati di `COMMIT` la modifica.
RDS mantiene i log scaricati in base alla policy di conservazione dei log archiviati, a partire dal momento in cui i log sono stati scaricati. Per informazioni su come impostare la policy di conservazione, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
1. Attendere fino a 5 minuti per rendere effettiva la modifica della policy di conservazione dei log archiviati.
1. Download dei log di ripristino archiviati da Simple Storage Service (Amazon S3) tramite `rdsadmin.rdsadmin_archive_log_download`.
Per ulteriori informazioni, consulta [Download di un singolo log di ripristino archiviato](#Appendix.Oracle.CommonDBATasks.download-redo-logs.single-log) e [Download di una serie di log di ripristino archiviati](#Appendix.Oracle.CommonDBATasks.download-redo-logs.series).
**Nota**
RDS controlla automaticamente lo spazio di archiviazione disponibile prima del download. Se i log richiesti consumano un'alta percentuale di spazio, viene visualizzato un avviso.
1. Conferma che i log siano stati scaricati correttamente da Simple Storage Service (Amazon S3).
È possibile visualizzare lo stato dell'attività di download in un file bdump. I file bdump hanno il percorso `/rdsdbdata/log/trace/dbtask-task-id.log`. Nel passaggio di download precedente, si esegue una istruzione `SELECT` che restituisce l'ID attività in un tipo di dati `VARCHAR2`. Per maggiori informazioni, consulta gli esempi simili in [Monitoraggio dello stato di un file transfer](oracle-s3-integration.using.md#oracle-s3-integration.using.task-status).
## Download di un singolo log di ripristino archiviato
Per scaricare un singolo log di ripristino archiviato nella directory `/rdsdbdata/log/arch` utilizza `rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum`. Questa procedura include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `seqnum` | numero | — | Sì | Il numero di sequenza del log di ripristino archiviato. |
L'esempio seguente scarica il log con il numero di sequenza 20.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_log_with_seqnum(seqnum => 20)
AS TASK_ID
FROM DUAL;
```
## Download di una serie di log di ripristino archiviati
Per scaricare un singolo log di ripristino archiviato nella directory `/rdsdbdata/log/arch` utilizza `download_logs_in_seqnum_range`. Il download è limitato a 300 registri per richiesta. La procedura `download_logs_in_seqnum_range` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `start_seq` | numero | — | Sì | Il numero di sequenza iniziale per la serie. |
| `end_seq` | numero | — | Sì | Il numero di sequenza finale per la serie. |
L'esempio seguente scarica il log dalla sequenza 50 a 100.
```
SELECT rdsadmin.rdsadmin_archive_log_download.download_logs_in_seqnum_range(start_seq => 50, end_seq => 100)
AS TASK_ID
FROM DUAL;
```
# Esecuzione di attività RMAN comuni per le istanze database Oracle
Nella seguente sezione viene illustrato come eseguire attività DBA Oracle Recovery Manager (RMAN) sulle istanze database Amazon RDS che eseguono Oracle. Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database. Limita anche l'accesso ad alcune procedure di sistema e tabelle che richiedono privilegi avanzati.
Utilizza il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per eseguire backup RMAN del database Amazon RDS per Oracle su disco. Il pacchetto `rdsadmin.rdsadmin_rman_util` supporta backup completi e incrementali dei file di database, backup degli spazi tabella e backup dei log redo archiviati.
Al termine di un backup RMAN, è possibile copiare i file di backup dall'host dell'istanza database Amazon RDS for Oracle. Tale operazione può essere eseguita per il ripristino su un host diverso da RDS o per uno storage a lungo termine dei backup. Ad esempio, i file di backup possono essere copiati in un bucket Simple Storage Service (Amazon S3). Per ulteriori informazioni, consulta l'utilizzo di [Integrazione Amazon S3](oracle-s3-integration.md).
I file di backup dei backup RMAN rimangono nell'host dell'istanza database Amazon RDS fino a quando non vengono rimossi manualmente. Per rimuovere i file da una directory, è possibile utilizzare la procedura Oracle `UTL_FILE.FREMOVE`. Per ulteriori informazioni, consulta la sezione relativa alla [Procedura FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) nella documentazione del database Oracle.
Non puoi utilizzare l'RMAN per ripristinare RDS per le istanze database Oracle. Tuttavia, puoi utilizzare RMAN per ripristinare un backup su un'istanza on-premise o Amazon EC2. Per ulteriori informazioni, consulta l'articolo del blog [Restore an Amazon RDS for Oracle instance to a self-managed instance](https://aws.amazon.com/blogs/database/restore-an-amazon-rds-for-oracle-instance-to-a-self-managed-instance/).
**Nota**
Per il backup e il ripristino su un'altra istanza database Amazon RDS for Oracle, si può continuare a utilizzare le funzionalità di backup e ripristino di Amazon RDS. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
**Topics**
+ [Prerequisiti per i backup RMAN](Appendix.Oracle.CommonDBATasks.RMAN-requirements.md)
+ [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md)
+ [Convalida dei file di database in RDS per Oracle](Appendix.Oracle.CommonDBATasks.ValidateDBFiles.md)
+ [Abilitazione e disabilitazione del monitoraggio delle modifiche dei blocchi.](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md)
+ [Controllo incrociato dei log redo archiviati](Appendix.Oracle.CommonDBATasks.Crosscheck.md)
+ [Backup dei file di log di redo archiviati](Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.md)
+ [Esecuzione di un backup di database completo](Appendix.Oracle.CommonDBATasks.BackupDatabaseFull.md)
+ [Esecuzione di un backup completo di un database del tenant](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseFull.md)
+ [Esecuzione di un backup di database incrementale](Appendix.Oracle.CommonDBATasks.BackupDatabaseIncremental.md)
+ [Esecuzione di un backup incrementale di un database del tenant](Appendix.Oracle.CommonDBATasks.BackupTenantDatabaseIncremental.md)
+ [Backup di uno spazio di tabella](Appendix.Oracle.CommonDBATasks.BackupTablespace.md)
+ [Backup di un file di controllo](Appendix.Oracle.CommonDBATasks.backup-control-file.md)
+ [Esecuzione del ripristino dei supporti a blocchi](Appendix.Oracle.CommonDBATasks.block-media-recovery.md)
# Prerequisiti per i backup RMAN
Prima di eseguire il backup del database utilizzando il pacchetto `rdsadmin.rdsadmin_rman_util`, assicurati di soddisfare i seguenti prerequisiti:
+ Assicurati che il tuo database RDS per Oracle sia in modalità `ARCHIVELOG`. Per abilitare questa modalità, imposta il periodo di conservazione del backup su un valore diverso da zero.
+ Se si esegue il backup di log redo archiviati o un backup completo o incrementale che include log redo archiviati, e quando si esegue il backup del database, accertarsi che la conservazione dei log redo sia impostata su un valore diverso da zero. I log redo archiviati sono necessari per rendere i file del database coerenti durante il ripristino. Per ulteriori informazioni, consulta [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
+ Assicurati che l'istanza database disponga di spazio libero sufficiente per contenere i backup. Quando esegui il backup del database, specifica un oggetto della directory Oracle come un parametro nella chiamata di procedura. RMAN inserisce i file nella directory specificata. Si possono utilizzare directory predefinite, come `DATA_PUMP_DIR`, o crearne di nuove. Per ulteriori informazioni, consulta [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.NewDirectories).
È possibile monitorare lo spazio libero corrente in un'istanza di RDS for Oracle utilizzando la CloudWatch metrica`FreeStorageSpace`. È opportuno che lo spazio libero superi la dimensione corrente del database, sebbene RMAN esegua il backup solo dei blocchi formattati e supporti la compressione.
# Parametri comuni per le procedure RMAN
Per eseguire attività con RMAN, si possono utilizzare le procedure del pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util`. Nelle procedure del pacchetto ci sono diversi parametri comuni. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_directory_name` | varchar2 | Un nome valido della directory del database. | — | Sì | Il nome della directory che conterrà i file di backup. |
| `p_label` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | — | No | Una stringa univoca, inclusa nei nomi dei file di backup. Ha un limite di 30 caratteri. |
| `p_owner` | varchar2 | Un proprietario valido della directory specificata in `p_directory_name`. | — | Sì | Il proprietario della directory che conterrà i file di backup. |
| `p_tag` | varchar2 | `a-z`, `A-Z`, `0-9`, `'_'`, `'-'`, `'.'` | NULL | No | Una stringa che può essere utilizzata per distinguere tra i backup per indicare lo scopo o l'utilizzo dei backup, ad esempio backup a livello giornaliero, settimanale o incrementale. Ha un limite di 30 caratteri. Il tag non rileva la distinzione tra maiuscole e minuscole. I tag sono sempre memorizzati in maiuscolo, indipendentemente dalle maiuscole e minuscole utilizzate durante l'inserimento. I tag non devono essere univoci, quindi più backup possono avere lo stesso tag. Se non si specifica un tag, RMAN assegna automaticamente un tag predefinito utilizzando il formato`TAGYYYYMMDDTHHMMSS`, dove *YYYY* è l'anno, *MM* il mese, *DD* il giorno, *HH* l'ora (nel formato a 24 ore), *MM* i minuti e i *SS* secondi. La data e l'ora si riferiscono a quando RMAN ha avviato il backup. Ad esempio, un backup potrebbe ricevere un tag `TAG20190927T214517` per un backup avviato il 27/09/2019 alle 21:45:17. Il parametro `p_tag` è supportato nelle seguenti versioni del motore database Amazon RDS for Oracle: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.CommonParameters.html) |
| `p_compress` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per abilitare la compressione BASIC del backup. Specificare `FALSE` per disabilitare la compressione BASIC del backup. |
| `p_include_archive_logs` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per includere i log redo archiviati nel backup. Specificare `FALSE` per escludere i log redo archiviati dal backup. Se si includono log redo archiviati nel backup, la retention va impostata su un valore almeno pari a un'ora tramite la procedura `rdsadmin.rdsadmin_util.set_configuration`. Inoltre, occorre chiamare la procedura `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog` subito prima di eseguire il backup. In caso contrario, il backup potrebbe non andare a buon fine perché mancano i file di log redo archiviati che sono stati eliminati dalle procedure di gestione di Amazon RDS. |
| `p_include_controlfile` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Specificare `TRUE` per includere il file di controllo nel backup. Specificare `FALSE` per escludere il file di controllo dal backup. |
| `p_optimize` | booleano | `TRUE`, `FALSE` | `TRUE` | No | Specificare `TRUE` per abilitare l'ottimizzazione del backup e ridurne le dimensioni, se sono inclusi log redo archiviati. Specificare `FALSE` per disabilitare l'ottimizzazione del backup. |
| `p_parallel` | numero | Un intero valido tra `1` e `254` per Oracle Database Enterprise Edition (EE) `1` per altre edizioni Oracle Database | `1` | No | Numero di canali. |
| `p_rman_to_dbms_output` | booleano | `TRUE`, `FALSE` | `FALSE` | No | Quando `TRUE`, l'output RMAN viene inviato al pacchetto `DBMS_OUTPUT` oltre a un file nella directory `BDUMP`. In SQL\$1Plus, utilizza `SET SERVEROUTPUT ON` per visualizzare l'output. Quando `FALSE`, l'output RMAN viene solo inviato a un file nella directory `BDUMP`. |
| `p_section_size_mb` | numero | Intero valido | `NULL` | No | Le dimensioni della sezione in megabyte (MB). Convalida in parallelo dividendo ogni file nelle dimensioni specificate della sezione. Quando `NULL`, il parametro è ignorato. |
| `p_validation_type` | varchar2 | `'PHYSICAL'`, `'PHYSICAL+LOGICAL'` | `'PHYSICAL'` | No | Livello di rilevamento di danneggiamenti. Specifica `'PHYSICAL'` per cercare i danneggiamenti fisici. Un esempio di danneggiamento fisico è un blocco con una mancata corrispondenza nell'intestazione e piè di pagina. Specifica `'PHYSICAL+LOGICAL'` per cercare le incoerenze logiche oltre ai danneggiamenti fisici. Un esempio di danneggiamento logico è un blocco danneggiato. |
# Convalida dei file di database in RDS per Oracle
Puoi utilizzare il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per convalidare i file di database Amazon RDS for Oracle, come file di dati, tablespace, file di controllo e file dei parametri del server (). SPFILEs
Per ulteriori informazioni sulla convalida RMAN, consulta [ Convalida di file di dati e backup di database](https://docs.oracle.com/database/121/BRADV/rcmvalid.htm#BRADV90063) e [VALIDATE](https://docs.oracle.com/database/121/RCMRF/rcmsynta2025.htm#RCMRF162) nella documentazione Oracle.
**Topics**
+ [Convalida di un database](#Appendix.Oracle.CommonDBATasks.ValidateDB)
+ [Convalida di un database del tenant](#Appendix.Oracle.CommonDBATasks.ValidateTenantDB)
+ [Convalida di uno spazio di tabella](#Appendix.Oracle.CommonDBATasks.ValidateTablespace)
+ [Convalida di un file di controllo](#Appendix.Oracle.CommonDBATasks.ValidateControlFile)
+ [Convalida di un file SPFILE](#Appendix.Oracle.CommonDBATasks.ValidateSpfile)
+ [Convalida di un file di dati Oracle](#Appendix.Oracle.CommonDBATasks.ValidateDataFile)
## Convalida di un database
Per convalidare tutti i file pertinenti utilizzati da un database Oracle in RDS per Oracle, utilizza la procedura `rdsadmin.rdsadmin_rman_util.validate_database` in Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Il seguente esempio convalida il database utilizzando i valori predefiniti per i parametri.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_database;
```
Il seguente esempio convalida il database utilizzando i valori predefiniti per i parametri.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_database(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Quando il parametro `p_rman_to_dbms_output` è impostato su `FALSE`, l'output RMAN viene scritto in un file nella directory `BDUMP`.
Per visualizzare i file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Per visualizzare i contenuti di un file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Sostituisci il nome del file con il nome del file che desideri visualizzare.
## Convalida di un database del tenant
Per convalidare i file di dati del database del tenant in un database container (CDB), utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_tenant`.
La procedura si applica solo al database del tenant corrente e utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md). Questa procedura è supportata nelle seguenti versioni del motore di database:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Il seguente esempio convalida il database del tenant corrente utilizzando i valori predefiniti per i parametri.
```
EXEC rdsadmin.rdsadmin_rman_util.validate_tenant;
```
Il seguente esempio convalida il database del tenant corrente utilizzando i valori predefiniti per i parametri.
```
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tenant(
p_validation_type => 'PHYSICAL+LOGICAL',
p_parallel => 4,
p_section_size_mb => 10,
p_rman_to_dbms_output => FALSE);
END;
/
```
Quando il parametro `p_rman_to_dbms_output` è impostato su `FALSE`, l'output RMAN viene scritto in un file nella directory `BDUMP`.
Per visualizzare i file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT * FROM table(rdsadmin.rds_file_util.listdir('BDUMP')) order by mtime;
```
Per visualizzare i contenuti di un file nella directory `BDUMP`, esegui la seguente istruzione `SELECT`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','rds-rman-validate-nnn.txt'));
```
Sostituisci il nome del file con il nome del file che desideri visualizzare.
## Convalida di uno spazio di tabella
Puoi usare la procedura in Amazon RDS per convalidare i file associati a uno spazio tabell `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Un nome spazio tabella valido | — | Sì | Il nome dello spazio tabella. |
## Convalida di un file di controllo
Per convalidare solo il file di controllo usato da un'istanza database Oracle Amazon RDS, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_current_controlfile`.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Convalida di un file SPFILE
Per convalidare solo il file dei parametri server (SPFILE) usato da un'istanza database Oracle Amazon RDS, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.validate_spfile`.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_validation_type`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
## Convalida di un file di dati Oracle
Puoi usare la procedura in Amazon RDS per convalidare un file di dat `rdsadmin.rdsadmin_rman_util.validate_datafile`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_validation_type`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | varchar2 | Un numero ID di file di dati valido o un nome di file di dati valido incluso il percorso completo | — | Sì | Il numero ID di file di dati (da `v$datafile.file#`) o il nome completo di file di dati incluso il percorso (da `v$datafile.name`). |
| `p_from_block` | numero | Intero valido | `NULL` | No | Il numero del blocco dove la convalida inizia con i file di dati. Se questo numero è `NULL`, si utilizza `1`. |
| `p_to_block` | numero | Intero valido | `NULL` | No | Il numero del blocco dove la convalida finisce con i file di dati. Se questo numero è `NULL`, viene utilizzato il blocco massimo nel file di dati. |
# Abilitazione e disabilitazione del monitoraggio delle modifiche dei blocchi.
Il rilevamento delle modifiche di blocco registra i blocchi modificati in un file di monitoraggio. Questa tecnica può migliorare le prestazioni dei backup incrementali RMAN. Per ulteriori informazioni, consulta [Utilizzo del rilevamento delle modifiche di blocco per migliorare le prestazioni di backup incrementali](https://docs.oracle.com/en/database/oracle/oracle-database/19/bradv/backing-up-database.html#GUID-4E1F605A-76A7-48D0-9D9B-7343B4327E2A) nella documentazione di Oracle Database.
Le funzionalità RMAN non sono supportate in una replica di lettura. Tuttavia, come parte della strategia per la disponibilità elevata, puoi scegliere di abilitare il tracciamento dei blocchi in una replica di sola lettura utilizzando la procedura `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Se promuovi questa replica di sola lettura a un'istanza database di origine, il tracciamento delle modifiche dei blocchi viene abilitato per la nuova istanza di origine. Pertanto, la tua istanza può trarre vantaggio da backup incrementali rapidi.
Le procedure di rilevamento delle modifiche di blocco sono supportate in Enterprise Edition solo per le seguenti versioni del motore del database:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Nota**
In un CDB a tenant singolo funzionano le seguenti operazioni, ma nessun meccanismo visibile al cliente può rilevare lo stato corrente delle operazioni. Consulta anche [Limitazioni di RDS per Oracle CDBs](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant-limitations).
Per abilitare il rilevamento delle modifiche di blocco per un'istanza database, consulta la Amazon RDS procedura `rdsadmin.rdsadmin_rman_util.enable_block_change_tracking`. Per disattivare il rilevamento delle modifiche di blocco, utilizza `disable_block_change_tracking`. Queste procedure non hanno parametri.
Per determinare se il monitoraggio delle modifiche dei blocchi è abilitato per l'istanza database, eseguire la seguente query.
```
SELECT STATUS, FILENAME FROM V$BLOCK_CHANGE_TRACKING;
```
Il seguente esempio abilita il monitoraggio delle modifiche dei blocchi per un'istanza database.
```
EXEC rdsadmin.rdsadmin_rman_util.enable_block_change_tracking;
```
Il seguente esempio disabilita il monitoraggio delle modifiche dei blocchi per un'istanza database.
```
EXEC rdsadmin.rdsadmin_rman_util.disable_block_change_tracking;
```
# Controllo incrociato dei log redo archiviati
Si può eseguire il controllo incrociato dei log redo archiviati utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.crosscheck_archivelog`.
Questa procedura serve a eseguire il controllo incrociato dei log redo archiviati registrati nel file di controllo e opzionalmente per eliminare i record di log scaduti. Quando RMAN esegue un backup, crea un record nel file di controllo. Col tempo, questi registri aumentano le dimensioni del file di controllo. Si consiglia di rimuovere periodicamente i record scaduti.
**Nota**
I backup Amazon RDS standard non utilizzano RMAN, quindi non creano registri nel file di controllo.
La procedura utilizza il parametro comune `p_rman_to_dbms_output` per le attività RMAN.
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_delete_expired` | booleano | `TRUE`, `FALSE` | `TRUE` | No | Se `TRUE`, si eliminano dal file di controllo i record di log redo archiviati scaduti. Se `FALSE`, si conservano nel file di controllo i record di log redo archiviati scaduti. |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Nell'esempio seguente i record di log redo archiviati nel file di controllo file vengono contrassegni come scaduti, ma non vengono eliminati.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => FALSE,
p_rman_to_dbms_output => FALSE);
END;
/
```
Il seguente esempio elimina i record di log redo archiviati scaduti dal file di controllo.
```
BEGIN
rdsadmin.rdsadmin_rman_util.crosscheck_archivelog(
p_delete_expired => TRUE,
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup dei file di log di redo archiviati
Si può utilizzare il pacchetto Amazon RDS `rdsadmin.rdsadmin_rman_util` per eseguire il backup dei log redo archiviati per un'istanza database Amazon RDS Oracle.
Le procedure di backup dei log di redo archiviati sono supportate nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [Backup di tutti i log redo archiviati](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.All)
+ [Backup di un log redo archiviato in base a un intervallo di date](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Date)
+ [Backup di un log redo archiviato in base a un intervallo SCN](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.SCN)
+ [Backup di un log redo archiviato in base a un intervallo di numeri di sequenza](#Appendix.Oracle.CommonDBATasks.BackupArchivedLogs.Sequence)
## Backup di tutti i log redo archiviati
Per eseguire il backup di tutti i og redo archiviati per un'istanza database Oracle Amazon RDS, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_all`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Il seguente esempio esegue il backup di tutti i log redo archiviati per l'istanza database.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_all(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Backup di un log redo archiviato in base a un intervallo di date
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un intervallo di date, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_date`. L'intervallo di date specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_date` | date | Una data compresa tra `start_date` e `next_date` di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_date`. | — | Sì | La data di inizio per i backup dei log archiviati. |
| `p_to_date` | date | Una data compresa tra `start_date` e `next_date` di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_date`. | — | Sì | La data di file per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di date per l'istanza database.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_date(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_date => '03/01/2019 00:00:00',
p_to_date => '03/02/2019 00:00:00',
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Backup di un log redo archiviato in base a un intervallo SCN
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un numero di modifica del sistema (SCN), utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_scn`. L'intervallo SCN specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_scn` | numero | Un SCN di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_scn`. | — | Sì | L'SCN di inizio per i backup dei log archiviati. |
| `p_to_scn` | numero | Un SCN di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_scn`. | — | Sì | Il SCN di fine per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di SCN per l'istanza database.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_scn(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_scn => 1533835,
p_to_scn => 1892447,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
## Backup di un log redo archiviato in base a un intervallo di numeri di sequenza
Per eseguire il backup di log redo specifici archiviati per un'istanza database Oracle Amazon RDS specificando un intervallo di numeri in sequenza, utilizzare la procedura in Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence`. L'intervallo di numeri di sequenza specifica i log redo archiviati di cui eseguire il backup.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_from_sequence` | numero | Un numero di sequenza di un log redo archiviato esistente su disco. Il valore deve essere uguale o inferiore al valore specificato per `p_to_sequence`. | — | Sì | Il numero di sequenza iniziale per i backup dei log archiviati. |
| `p_to_sequence` | numero | Un numero di sequenza di un log redo archiviato esistente su disco. Il valore deve essere maggiore o uguale al valore specificato per `p_from_sequence`. | — | Sì | Il numero di sequenza finale per i backup dei log archiviati. |
Il seguente esempio esegue il backup dei log redo archiviati nell'intervallo di numeri di sequenza per l'istanza database.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_archivelog_sequence(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_from_sequence => 11160,
p_to_sequence => 11160,
p_parallel => 4,
p_tag => 'MY_LOG_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Esecuzione di un backup di database completo
Si può eseguire un backup di tutti i blocchi di file di dati inclusi nel backup utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_full`.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup completo dell'istanza database utilizzando i valori specificati per i parametri:
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Esecuzione di un backup completo di un database del tenant
È possibile eseguire un backup di tutti i blocchi di dati inclusi in un database del tenant in un database container (CDB). Usa la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_full`. La procedura si applica solo al backup del database corrente e utilizza i seguenti parametri comuni per le operazioni RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
La procedura `rdsadmin_rman_util.backup_tenant_full` è supportata nelle seguenti versioni del motore di database RDS per Oracle:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Il seguente esempio esegue un backup completo del database del tenant corrente utilizzando i valori specificati per i parametri:
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_full(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'FULL_TENANT_DB_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Esecuzione di un backup di database incrementale
Si può eseguire un backup incrementale dell'istanza database utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_database_incremental`.
Per ulteriori informazioni sui backup incrementali, consulta [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) nella documentazione di Oracle.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS for Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_level` | numero | `0`, `1` | `0` | No | Specificare `0` per abilitare un backup incrementale completo. Specificare `1` per abilitare un backup incrementale non cumulativo. |
Il seguente esempio esegue un backup incrementale dell'istanza database utilizzando i valori specificati per i parametri:
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_database_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Esecuzione di un backup incrementale di un database del tenant
È possibile eseguire un backup incrementale del database del tenant corrente nel tuo CDB. Usa la procedura Amazon RDS `rdsadmin.rdsadmin_rman_util.backup_tenant_incremental`.
Per ulteriori informazioni sui backup incrementali, consulta [Incremental Backups](https://docs.oracle.com/database/121/RCMRF/rcmsynta006.htm#GUID-73642FF2-43C5-48B2-9969-99001C52EB50__BGBHABHH) nella documentazione di Oracle Database.
La procedura si applica solo al database del tenant corrente e utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS for Oracle:
+ Oracle Database 21c (21.0.0) CDB
+ Oracle Database 19c (19.0.0) CDB
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_level` | numero | `0`, `1` | `0` | No | Specificare `0` per abilitare un backup incrementale completo. Specificare `1` per abilitare un backup incrementale non cumulativo. |
Il seguente esempio esegue un backup incrementale del database del tenant corrente utilizzando i valori specificati per i parametri.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tenant_incremental(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_level => 1,
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MY_INCREMENTAL_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup di uno spazio di tabella
Si può eseguire il backup di uno spazio di tabella utilizzando la procedura `rdsadmin.rdsadmin_rman_util.backup_tablespace` di Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_parallel`
+ `p_section_size_mb`
+ `p_include_archive_logs`
+ `p_include_controlfile`
+ `p_optimize`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `p_tablespace_name` | varchar2 | Un nome spazio tabella valido. | — | Sì | Il nome dello spazio tabella di cui eseguire il backup. |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup dello spazio tabella utilizzando i valori specificati per i parametri.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_tablespace(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tablespace_name => 'MYTABLESPACE',
p_parallel => 4,
p_section_size_mb => 10,
p_tag => 'MYTABLESPACE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Backup di un file di controllo
Si può eseguire il backup di un file di controllo utilizzando la procedura `rdsadmin.rdsadmin_rman_util.backup_current_controlfile` di Amazon RDS.
La procedura utilizza i seguenti parametri comuni per le attività RMAN:
+ `p_owner`
+ `p_directory_name`
+ `p_label`
+ `p_compress`
+ `p_rman_to_dbms_output`
+ `p_tag`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
Il seguente esempio esegue un backup di un file di controllo utilizzando i valori specificati per i parametri.
```
BEGIN
rdsadmin.rdsadmin_rman_util.backup_current_controlfile(
p_owner => 'SYS',
p_directory_name => 'MYDIRECTORY',
p_tag => 'CONTROL_FILE_BACKUP',
p_rman_to_dbms_output => FALSE);
END;
/
```
# Esecuzione del ripristino dei supporti a blocchi
Puoi ripristinare singoli blocchi di dati, operazione nota come ripristino dei supporti a blocchi, utilizzando le procedure `rdsadmin.rdsadmin_rman_util.recover_datafile_block` di Amazon RDS. È possibile utilizzare questa procedura di overload per ripristinare un singolo blocco di dati o una serie di blocchi di dati.
La procedura utilizza il seguente parametro comune per le attività RMAN:
+ `p_rman_to_dbms_output`
Per ulteriori informazioni, consulta [Parametri comuni per le procedure RMAN](Appendix.Oracle.CommonDBATasks.CommonParameters.md).
Questa procedura utilizza anche i seguenti parametri aggiuntivi.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Description |
| --- | --- | --- | --- | --- | --- |
| `p_datafile` | `NUMBER` | Un numero ID valido per il file di dati. | — | Sì | Il file di dati contenente i blocchi danneggiati. Specifica il file di dati in uno dei seguenti modi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_block` | `NUMBER` | Intero valido. | — | Sì | Il numero di un singolo blocco da ripristinare. I parametri seguenti si escludono a vicenda: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_from_block` | `NUMBER` | Intero valido. | — | Sì | Il primo numero di blocco in un intervallo di blocchi da ripristinare. I parametri seguenti si escludono a vicenda: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
| `p_to_block` | `NUMBER` | Intero valido. | — | Sì | L’ultimo numero di blocco in un intervallo di blocchi da ripristinare. I parametri seguenti si escludono a vicenda. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.block-media-recovery.html) |
Questa procedura è supportata nelle seguenti versioni del motore database Amazon RDS per Oracle:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
L’esempio seguente ripristina il blocco 100 nel file di dati 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_block => 100,
p_rman_to_dbms_output => TRUE);
END;
/
```
L’esempio seguente ripristina i blocchi da 100 a 150 nel file di dati 5.
```
BEGIN
rdsadmin.rdsadmin_rman_util.recover_datafile_block(
p_datafile => 5,
p_from_block => 100,
p_to_block => 150,
p_rman_to_dbms_output => TRUE);
END;
/
```
# Esecuzione di attività di programmazione comuni per le istanze database Oracle
Alcuni processi Scheduler di proprietà di `SYS` possono interferire con le normali operazioni di database. In questi casi, Oracle Support consiglia di modificare la pianificazione. Se è necessario abilitare o disabilitare i processi `SYS`, testa l’operazione sui processi pianificati in un ambiente di test prima di implementarla in un ambiente di produzione. Puoi utilizzare il pacchetto `rdsadmin.rdsadmin_dbms_scheduler` di Amazon RDS per eseguire le attività dai processi Oracle Scheduler di proprietà di `SYS`.
Le procedure `rdsadmin.rdsadmin_dbms_scheduler` sono supportate nelle versioni del motore di database Amazon RDS per Oracle mostrate nella tabella seguente. Quando utilizzi questo pacchetto, puoi specificare i processi `SYS` elencati nella tabella.
| Versione del database | Processi abilitati per impostazione predefinita | Processi disabilitati per impostazione predefinita |
| --- | --- | --- |
| Oracle Database 19c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
RSE$CLEAN_RECOVERABLE_SCRIPT
SM$CLEAN_AUTO_SPLIT_MERGE
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
XMLDB_NFS_CLEANUP_JOB
|
| Oracle Database 21c | BSLN_MAINTAIN_STATS_JOB
CLEANUP_NON_EXIST_OBJ
CLEANUP_ONLINE_IND_BUILD
CLEANUP_ONLINE_PMO
CLEANUP_TAB_IOT_PMO
CLEANUP_TRANSIENT_PKG
CLEANUP_TRANSIENT_TYPE
DRA_REEVALUATE_OPEN_FAILURES
FILE_SIZE_UPD
ORA$AUTOTASK_CLEAN
PMO_DEFERRED_GIDX_MAINT_JOB
PURGE_LOG
| FGR$AUTOPURGE_JOB
FILE_WATCHER
HM_CREATE_OFFLINE_DICTIONARY
LOAD_OPATCH_INVENTORY
ORA$PREPLUGIN_BACKUP_JOB
ORA$_ATSK_AUTOSTS
XMLDB_NFS_CLEANUP_JOB
|
## Parametri comuni per procedure Oracle Scheduler
Per eseguire attività con Oracle Scheduler, puoi utilizzare le procedure del pacchetto di Amazon RDS `rdsadmin.rdsadmin_dbms_scheduler`. Nelle procedure del pacchetto ci sono diversi parametri comuni. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `name` | varchar2 | Le procedure elencate nella tabella in [Esecuzione di attività di programmazione comuni per le istanze database Oracle](#Appendix.Oracle.CommonDBATasks.Scheduler) | — | Sì | Il nome del processo da modificare. |
| `attribute` | varchar2 | `'REPEAT_INTERVAL'`,`'SCHEDULE_NAME'` | – | Sì | Attributo da modificare Per modificare l'intervallo di ripetizione del lavoro, specificare `'REPEAT_INTERVAL'`. Per modificare il nome della pianificazione del lavoro, specificare `'SCHEDULE_NAME'`. |
| `value` | varchar2 | Un intervallo o un nome di pianificazione valido, a seconda dell'attributo utilizzato. | – | Sì | Il nuovo valore dell'attributo. |
## Modifica dei processi di DBMS\$1SCHEDULER
Puoi utilizzare la procedura Oracle `dbms_scheduler.set_attribute` per modificare determinati componenti di Oracle Scheduler. Per ulteriori informazioni, consulta [DBMS\$1SCHEDULER](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72235) e [Procedura SET\$1ATTRIBUTE](https://docs.oracle.com/database/121/ARPLS/d_sched.htm#ARPLS72399) nella documentazione di Oracle.
Quando usi istanze database Amazon RDS, aggiungi il nome di schema `SYS` come prefisso al nome dell'oggetto. L'esempio seguente imposta l'attributo del piano delle risorse per l'oggetto finestra Lunedì.
```
BEGIN
DBMS_SCHEDULER.SET_ATTRIBUTE(
name => 'SYS.MONDAY_WINDOW',
attribute => 'RESOURCE_PLAN',
value => 'resource_plan_1');
END;
/
```
## Modifica delle finestre di AutoTask manutenzione
Le istanze di Amazon RDS for Oracle vengono create con le impostazioni predefinite per le finestre di manutenzione. Le attività di manutenzione automatizzate come la raccolta delle statistiche dell'ottimizzatore vengono eseguite durante queste finestre. Per impostazione predefinita, le finestre di manutenzione attivano Oracle Database Resource Manager.
Per modificare la finestra, utilizzare il pacchetto `DBMS_SCHEDULER`. Potrebbe essere necessario modificare le impostazioni della finestra di manutenzione per i motivi seguenti:
+ Si desidera che i processi di manutenzione vengano eseguiti in un momento diverso, con impostazioni diverse o non del tutto. Ad esempio, è possibile modificare la durata della finestra o modificare il tempo e l'intervallo di ripetizione.
+ Si desidera evitare l'impatto sulle prestazioni dell'abilitazione di Resource Manager durante la manutenzione. Ad esempio, se viene specificato il piano di manutenzione predefinito e se si apre la finestra di manutenzione mentre il database è sotto carico, è possibile che vengano visualizzati eventi di attesa come `resmgr:cpu quantum`. Questo evento di attesa è correlato a Database Resource Manager. Sono disponibili le seguenti opzioni:
+ Assicurarsi che le finestre di manutenzione siano attive durante i periodi non di punta per l'istanza del database.
+ Disabilitare il piano di manutenzione predefinito impostando l'attributo `resource_plan` ad una stringa vuota.
+ Imposta il parametro `resource_manager_plan` su `FORCE:` nel gruppo di parametri. Se l'istanza utilizza Enterprise Edition, questa impostazione impedisce l'attivazione dei piani di Database Resource Manager.
**Per modificare le impostazioni della finestra di manutenzione**
1. Connettersi al database utilizzando un client Oracle SQL.
1. Eseguire una query sulla configurazione corrente per una finestra di scheduler.
Nell'esempio seguente viene eseguita una query sulla configurazione di `MONDAY_WINDOW`.
```
SELECT ENABLED, RESOURCE_PLAN, DURATION, REPEAT_INTERVAL
FROM DBA_SCHEDULER_WINDOWS
WHERE WINDOW_NAME='MONDAY_WINDOW';
```
Il seguente output mostra che la finestra utilizza i valori di default.
```
ENABLED RESOURCE_PLAN DURATION REPEAT_INTERVAL
--------------- ------------------------------ ---------------- ------------------------------
TRUE DEFAULT_MAINTENANCE_PLAN +000 04:00:00 freq=daily;byday=MON;byhour=22
;byminute=0; bysecond=0
```
1. Modificare la finestra utilizzando il pacchetto `DBMS_SCHEDULER`.
Nell'esempio seguente il piano delle risorse viene impostato su null in modo che il Resource Manager non venga eseguito durante la finestra di manutenzione.
```
BEGIN
-- disable the window to make changes
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
-- specify the empty string to use no plan
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'RESOURCE_PLAN', value=>'');
-- re-enable the window
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
L'esempio seguente imposta la durata massima della finestra su 2 ore.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'DURATION', value=>'0 2:00:00');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
Nell'esempio seguente l'intervallo di ripetizione viene impostato su ogni lunedì alle 10:00.
```
BEGIN
DBMS_SCHEDULER.DISABLE(name=>'"SYS"."MONDAY_WINDOW"',force=>TRUE);
DBMS_SCHEDULER.SET_ATTRIBUTE(name=>'"SYS"."MONDAY_WINDOW"', attribute=>'REPEAT_INTERVAL', value=>'freq=daily;byday=MON;byhour=10;byminute=0;bysecond=0');
DBMS_SCHEDULER.ENABLE(name=>'"SYS"."MONDAY_WINDOW"');
END;
/
```
## Impostazione del fuso orario per i job di Oracle Scheduler
Per modificare il fuso orario per Oracle Scheduler, è possibile utilizzare la procedura Oracle `dbms_scheduler.set_scheduler_attribute`. Per ulteriori informazioni sul pacchetto `dbms_scheduler`, consulta [DBMS\$1SCHEDULER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html) e [SET\$1SCHEDULER\$1ATTRIBUTE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_SCHEDULER.html#GUID-2AB97BF7-7154-4E6C-933F-B2659B18A907) nella documentazione di Oracle.
**Per modificare l'impostazione del fuso orario corrente**
1. Connettersi al database utilizzando un client come SQL Developer. Per ulteriori informazioni, consulta [Connessione all'istanza database tramite Oracle SQL Developer](USER_ConnectToOracleInstance.SQLDeveloper.md).
1. Impostare il fuso orario predefinito come segue, sostituendo il fuso orario per `time_zone_name`.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'time_zone_name'
);
END;
/
```
Nell'esempio seguente, si modifica il fuso orario in Asia/Shanghai.
Iniziare interrogando il fuso orario corrente, come illustrato di seguito.
```
SELECT VALUE FROM DBA_SCHEDULER_GLOBAL_ATTRIBUTE WHERE ATTRIBUTE_NAME='DEFAULT_TIMEZONE';
```
L'output mostra che il fuso orario corrente è ETC/UTC.
```
VALUE
-------
Etc/UTC
```
Quindi si imposta il fuso orario su Asia/Shanghai.
```
BEGIN
DBMS_SCHEDULER.SET_SCHEDULER_ATTRIBUTE(
attribute => 'default_timezone',
value => 'Asia/Shanghai'
);
END;
/
```
Per ulteriori informazioni sulla modifica del fuso orario di sistema, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md).
## Disattivazione dei processi Oracle Scheduler di proprietà di SYS
Per disattivare un processo Oracle Scheduler di proprietà dell'utente SYS, utilizza la procedura `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Questa procedura utilizza il parametro comune `name` per le attività Oracle Scheduler. Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente disabilita il lavoro Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.disable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Attivazione dei processi Oracle Scheduler di proprietà di SYS
Per attivare un processo Oracle Scheduler di proprietà SYS, utilizza la procedura `rdsadmin.rdsadmin_dbms_scheduler.enable`.
Questa procedura utilizza il parametro comune `name` per le attività Oracle Scheduler. Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente abilita il lavoro Oracle Scheduler per `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.enable('SYS.CLEANUP_ONLINE_IND_BUILD');
END;
/
```
## Modifica dell'intervallo di ripetizione di Oracle Scheduler dei processi di tipo CALENDAR
Per modificare l'intervallo di ripetizione per modificare un lavoro Oracle Scheduler di proprietà SYS di tipo `CALENDAR`, utilizzare la procedura `rdsadmin.rdsadmin_dbms_scheduler.disable`.
Questa procedura utilizza i parametri comuni seguenti per le attività Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente modifica l'intervallo di ripetizione del lavoro Oracle Scheduler `SYS.CLEANUP_ONLINE_IND_BUILD`.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute(
name => 'SYS.CLEANUP_ONLINE_IND_BUILD',
attribute => 'repeat_interval',
value => 'freq=daily;byday=FRI,SAT;byhour=20;byminute=0;bysecond=0');
END;
/
```
## Modifica dell'intervallo di ripetizione di Oracle Scheduler dei processi di tipo NAMED
I lavori Oracle Scheduler utilizzano il nome della pianificazione invece dell'intervallo. Per questi tipi di lavori, è necessario creare un nuovo nome di pianificazione nello schema dell'utente principale. Per questo, utilizzare la procedura standard Oracle `sys.dbms_scheduler.create_schedule`. Inoltre, utilizza `rdsadmin.rdsadmin_dbms_scheduler.set_attribute procedure` per assegnare le nuove pianificazioni denominate al processo.
Questa procedura utilizza i parametri comuni seguenti per le attività Oracle Scheduler:
+ `name`
+ `attribute`
+ `value`
Per ulteriori informazioni, consulta [Parametri comuni per procedure Oracle Scheduler](#Appendix.Oracle.CommonDBATasks.Scheduler.CommonParameters).
L'esempio seguente modifica l'intervallo di ripetizione del lavoro Oracle Scheduler `SYS.BSLN_MAINTAIN_STATS_JOB`.
```
BEGIN
DBMS_SCHEDULER.CREATE_SCHEDULE (
schedule_name => 'rds_master_user.new_schedule',
start_date => SYSTIMESTAMP,
repeat_interval => 'freq=daily;byday=MON,TUE,WED,THU,FRI;byhour=0;byminute=0;bysecond=0',
end_date => NULL,
comments => 'Repeats daily forever');
END;
/
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_attribute (
name => 'SYS.BSLN_MAINTAIN_STATS_JOB',
attribute => 'schedule_name',
value => 'rds_master_user.new_schedule');
END;
/
```
## Disattivazione del commit automatico per la creazione di processi in Oracle Scheduler
`DBMS_SCHEDULER.CREATE_JOB` crea i processi Oracle Scheduler immediatamente e conferma le modifiche. Potrebbe essere necessario incorporare la creazione di processi Oracle Scheduler nella transazione utente per:
+ Eseguire il rollback del processo Oracle Schedule quando viene eseguito il rollback della transazione dell'utente.
+ Creare il processo Oracle Scheduler quando viene confermata la transazione dell'utente principale.
Puoi utilizzare la procedura `rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag` per attivare questo comportamento. Questa procedura non richiede parametri. È possibile utilizzare questa procedura nelle seguenti versioni di RDS per Oracle:
+ 21.0.0.0.ru-2022-07.rur-2022-07.r1 versioni successive
+ 19.0.0.0.ru-2022-07.rur-2022-07.r1 versioni successive
L'esempio seguente disattiva il commit automatico per Oracle Scheduler, crea un processo Oracle Scheduler e quindi esegue il rollback della transazione. Poiché il commit automatico è disattivato, il database esegue il rollback anche del processo Oracle Scheduler.
```
BEGIN
rdsadmin.rdsadmin_dbms_scheduler.set_no_commit_flag;
DBMS_SCHEDULER.CREATE_JOB(job_name => 'EMPTY_JOB',
job_type => 'PLSQL_BLOCK',
job_action => 'begin null; end;',
auto_drop => false);
ROLLBACK;
END;
/
PL/SQL procedure successfully completed.
SELECT * FROM DBA_SCHEDULER_JOBS WHERE JOB_NAME='EMPTY_JOB';
no rows selected
```
# Diagnosi dei problemi con le istanze database RDS per Oracle
Oracle Database include un'infrastruttura di diagnosi degli errori che è possibile utilizzare per analizzare i problemi del database. Nella terminologia Oracle, un *problema* è un errore critico, ad esempio un bug di codice o il danneggiamento dei dati. Un *incidente* è il verificarsi di un problema. Se lo stesso errore si verifica tre volte, l'infrastruttura mostra tre incidenti di questo problema. Per ulteriori informazioni, consulta [Diagnostica e risoluzione dei problemi](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/diagnosing-and-resolving-problems.html#GUID-8DEB1BE0-8FB9-4FB2-A19A-17CF6F5791C3) nella documentazione di Oracle Database.
L'utility ADRCI (Automatic Diagnostic Repository Command Interpreter) è uno strumento a riga di comando Oracle utilizzato per gestire i dati di diagnostica. Ad esempio, è possibile utilizzare questo strumento per analizzare i problemi e creare pacchetti di dati diagnostici. Un *pacchetto incidente* include dati diagnostici per un incidente o tutti gli incidenti che fanno riferimento a un problema specifico. È possibile caricare un pacchetto incidente, implementato come file zip, nel supporto Oracle.
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell ad ADRCI. Per eseguire le attività diagnostiche per l’istanza database RDS per Oracle, utilizza il pacchetto `rdsadmin.rdsadmin_adrci_util` Amazon RDS.
Utilizzando le funzioni in `rdsadmin_adrci_util`, è possibile elencare e creare pacchetti di problemi e incidenti, nonché visualizzare i file di traccia. Tutte le funzioni restituiscono un ID attività. Questo ID fa parte del nome del file di registro che contiene l'output ADRCI, come in `dbtask-task_id.log`. Il file di registro si trova nella directory BDUMP. Puoi scaricare il file di log seguendo la procedura descritta in [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
## Parametri comuni per le procedure diagnostiche
Per eseguire attività diagnostiche, utilizzare le funzioni nel pacchetto Amazon RDS `rdsadmin.rdsadmin_adrci_util`. Il pacchetto presenta i seguenti parametri comuni.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `incident_id` | numero | Un ID incidente valido o null | Null | No | Se il valore è null, la funzione mostra tutti gli incidenti. Se il valore non è null e rappresenta un ID incidente valido, la funzione mostra l'incidente specificato. |
| `problem_id` | numero | Un ID di problema valido o null | Null | No | Se il valore è null, la funzione mostra tutti i problemi. Se il valore non è null e rappresenta un ID problema valido, la funzione mostra il problema specificato. |
| `last` | numero | Un numero intero valido maggiore di 0 o null | Null | No | Se il valore è null, la funzione visualizza al massimo 50 elementi. Se il valore non è null, la funzione visualizza il numero specificato. |
## Elenco degli incidenti
Per elencare gli incidenti diagnostici per Oracle, utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents`. È possibile elencare gli incidenti in modalità base o dettagliata. Per impostazione predefinita, la funzione elenca i 50 incidenti più recenti.
Questa funzione utilizza i seguenti parametri comuni:
+ `incident_id`
+ `problem_id`
+ `last`
Se specifichi `incident_id` e `problem_id`, `incident_id` sostituisce `problem_id`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Questa funzione utilizza il seguente parametro aggiuntivo.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `detail` | booleano | TRUE o FALSE | `FALSE` | No | Se `TRUE`, la funzione elenca gli incidenti in modalità dettaglio. Se `FALSE`, la funzione elenca gli incidenti in modalità base. |
Per elencare tutti gli incidenti, esegui una query della funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` senza argomenti. La query restituisce l'ID attività.
```
SQL> SELECT rdsadmin.rdsadmin_adrci_util.list_adrci_incidents AS task_id FROM DUAL;
TASK_ID
------------------
1590786706158-3126
```
Oppure chiama la funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_incidents` senza argomenti e memorizza l'output in una variabile client SQL. Puoi utilizzare la variabile in altre istruzioni.
```
SQL> VAR task_id VARCHAR2(80);
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents;
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare la procedura Amazon RDS `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del file. Il seguente output mostra tre incidenti: 53523, 53522 e 53521.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:11:46.193 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:11:46.256 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
----------- ----------------------------------------------------------- ----------------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
53522 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 2020-05-29 20:15:15.247000 +00:00
53521 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:11:46.256 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:11:46.256 UTC [INFO ] The task finished successfully.
14 rows selected.
```
Per elencare un particolare incidente, specificarne l'ID utilizzando il parametro `incident_id`. Nell'esempio seguente, è possibile eseguire la query del file di registro solo per incidente 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_incidents(incident_id=>53523);
PL/SQL procedure successfully completed.
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------
2020-05-29 21:15:25.358 UTC [INFO ] Listing ADRCI incidents.
2020-05-29 21:15:25.426 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
INCIDENT_ID PROBLEM_KEY CREATE_TIME
-------------------- ----------------------------------------------------------- ---------------------------------
53523 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 2020-05-29 20:15:20.928000 +00:00
1 rows fetched
2020-05-29 21:15:25.427 UTC [INFO ] The ADRCI incidents were successfully listed.
2020-05-29 21:15:25.427 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Elenco dei problemi
Per elencare i problemi di diagnostica per Oracle, utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.list_adrci_problems`.
Per impostazione predefinita, la funzione elenca i 50 problemi più recenti.
Questa funzione utilizza i parametri comuni `problem_id` e `last`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Per ottenere l'ID attività per tutti i problemi, chiamare la funzione `rdsadmin.rdsadmin_adrci_util.list_adrci_problems` senza argomenti e memorizzare l'output in una variabile client SQL.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems;
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare la funzione `rdsadmin.rds_file_util.read_text_file`, fornendo l'ID attività come parte del nome del file. Nell'output seguente, il file di registro mostra tre problemi: 1, 2 e 3.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
----------------------------------------------------------------------------------------------------------------------
2020-05-29 21:18:50.764 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:18:50.829 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
2 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_003 53523 2020-05-29 20:15:20.928000 +00:00
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_001 53521 2020-05-29 20:15:06.047000 +00:00
3 rows fetched
2020-05-29 21:18:50.829 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:18:50.829 UTC [INFO ] The task finished successfully.
14 rows selected.
```
Nell'esempio seguente, è possibile elencare solo il problema 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.list_adrci_problems(problem_id=>3);
PL/SQL procedure successfully completed.
```
Per leggere il file di registro per il problema 3, chiamare `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del file.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
-------------------------------------------------------------------------
2020-05-29 21:19:42.533 UTC [INFO ] Listing ADRCI problems.
2020-05-29 21:19:42.599 UTC [INFO ]
ADR Home = /rdsdbdata/log/diag/rdbms/orcl_a/ORCL:
*************************************************************************
PROBLEM_ID PROBLEM_KEY LAST_INCIDENT LASTINC_TIME
---------- ----------------------------------------------------------- ------------- ---------------------------------
3 ORA 700 [EVENT_CREATED_INCIDENT] [942] [SIMULATED_ERROR_002 53522 2020-05-29 20:15:15.247000 +00:00
1 rows fetched
2020-05-29 21:19:42.599 UTC [INFO ] The ADRCI problems were successfully listed.
2020-05-29 21:19:42.599 UTC [INFO ] The task finished successfully.
12 rows selected.
```
## Creazione di pacchetti incidenti
È possibile creare pacchetti incidenti utilizzando la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.create_adrci_package`. L'output è un file zip che è possibile fornire al supporto Oracle.
Questa funzione utilizza i seguenti parametri comuni:
+ `problem_id`
+ `incident_id`
Assicurarsi di specificare uno dei parametri precedenti. Se si specificano entrambi i parametri, `incident_id` sovrascrive `problem_id`. Per ulteriori informazioni, consulta [Parametri comuni per le procedure diagnostiche](#Appendix.Oracle.CommonDBATasks.CommonDiagParameters).
Per creare un pacchetto per un incidente specifico, chiamare la funzione `rdsadmin.rdsadmin_adrci_util.create_adrci_package` Amazon RDS con il parametro `incident_id`. Nell'esempio seguente viene creato un pacchetto per l'incidente 53523.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(incident_id=>53523);
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare `rdsadmin.rds_file_util.read_text_file`. È possibile fornire l'ID attività come parte del nome del file. L'output mostra che hai generato il pacchetto incidente `ORA700EVE_20200529212043_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
--------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:20:43.031 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:20:47.641 UTC [INFO ] Generated package 1 in file /rdsdbdata/log/trace/ORA700EVE_20200529212043_COM_1.zip, mode complete
2020-05-29 21:20:47.642 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:20:47.642 UTC [INFO ] The task finished successfully.
```
Per creare un pacchetto di dati diagnostici per un particolare problema, specificarne l'ID utilizzando il parametro `problem_id`. Nell'esempio seguente, si impacchettano i dati solo per il problema 3.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.create_adrci_package(problem_id=>3);
PL/SQL procedure successfully completed.
```
Per leggere l'output dell'attività, chiamare `rdsadmin.rds_file_util.read_text_file`, fornendo l'ID attività come parte del nome del file. L'output mostra che hai generato il pacchetto incidente `ORA700EVE_20200529212111_COM_1.zip`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log'));
TEXT
------------------------------------------------------------------------------------------------------------------------------------------------------------
2020-05-29 21:21:11.050 UTC [INFO ] The ADRCI package is being created.
2020-05-29 21:21:15.646 UTC [INFO ] Generated package 2 in file /rdsdbdata/log/trace/ORA700EVE_20200529212111_COM_1.zip, mode complete
2020-05-29 21:21:15.646 UTC [INFO ] The ADRCI package was successfully created.
2020-05-29 21:21:15.646 UTC [INFO ] The task finished successfully.
```
Puoi anche scaricare il file di log. Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
## Visualizzazione di file di traccia
Puoi utilizzare la funzione Amazon RDS `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` per elencare i file di traccia nella directory di traccia e tutte le directory degli incidenti nella home page ADR corrente. È inoltre possibile visualizzare il contenuto dei file di traccia e dei file di traccia degli incidenti.
Questa funzione utilizza il seguente parametro.
****
| Nome del parametro | Tipo di dati | Valori validi | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- | --- |
| `filename` | varchar2 | Un nome di file di traccia valido | Null | No | Se il valore è null, la funzione visualizza tutti i file di traccia. Se non è null, la funzione mostra il file specificato. |
Per visualizzare il file di traccia, chiama la funzione `rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile` Amazon RDS.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile;
PL/SQL procedure successfully completed.
```
Per elencare i nomi dei file di traccia, chiamare la procedura `rdsadmin.rds_file_util.read_text_file` Amazon RDS fornendo l'ID attività come parte del nome file.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE TEXT LIKE '%/alert_%';
TEXT
---------------------------------------------------------------
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-28
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-27
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-26
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-25
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-24
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-23
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-22
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log.2020-05-21
diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log
9 rows selected.
```
Nell’esempio seguente viene generato l’output per `alert_ORCL.log`.
```
SQL> EXEC :task_id := rdsadmin.rdsadmin_adrci_util.show_adrci_tracefile('diag/rdbms/orcl_a/ORCL/trace/alert_ORCL.log');
PL/SQL procedure successfully completed.
```
Per leggere il file di registro, chiamare `rdsadmin.rds_file_util.read_text_file`. Fornire l'ID attività come parte del nome del file. L'output mostra le prime 10 righe di Alert\$1Orcl.log.
```
SQL> SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||:task_id||'.log')) WHERE ROWNUM <= 10;
TEXT
-----------------------------------------------------------------------------------------
2020-05-29 21:24:02.083 UTC [INFO ] The trace files are being displayed.
2020-05-29 21:24:02.128 UTC [INFO ] Thu May 28 23:59:10 2020
Thread 1 advanced to log sequence 2048 (LGWR switch)
Current log# 3 seq# 2048 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_3_hbl2p8xs_.log
Thu May 28 23:59:10 2020
Archived Log entry 2037 added for thread 1 sequence 2047 ID 0x5d62ce43 dest 1:
Fri May 29 00:04:10 2020
Thread 1 advanced to log sequence 2049 (LGWR switch)
Current log# 4 seq# 2049 mem# 0: /rdsdbdata/db/ORCL_A/onlinelog/o1_mf_4_hbl2qgmh_.log
Fri May 29 00:04:10 2020
10 rows selected.
```
Puoi anche scaricare il file di log. Per ulteriori informazioni, consulta [Download di un file di log di database](USER_LogAccess.Procedural.Downloading.md).
# Esecuzione di varie attività per istanze database Oracle
Di seguito viene descritto come eseguire attività DBA varie sulle istanze database Amazon RDS che eseguono Oracle. Per fornire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell alle istanze database e limita l'accesso a certe procedure e tabelle di sistema che richiedono privilegi avanzati.
**Topics**
+ [Creazione ed eliminazione di directory nello spazio di archiviazione dati principale](#Appendix.Oracle.CommonDBATasks.NewDirectories)
+ [Generazione di un elenco dei file in una directory di istanze database](#Appendix.Oracle.CommonDBATasks.ListDirectories)
+ [Lettura dei file in una directory di istanze database](#Appendix.Oracle.CommonDBATasks.ReadingFiles)
+ [Accesso ai file Opatch](#Appendix.Oracle.CommonDBATasks.accessing-opatch-files)
+ [Gestione delle attività degli advisor](#Appendix.Oracle.CommonDBATasks.managing-advisor-tasks)
+ [Trasporto di tablespace](rdsadmin_transport_util.md)
## Creazione ed eliminazione di directory nello spazio di archiviazione dati principale
Puoi usare la procedura in Amazon RDS per creare director `rdsadmin.rdsadmin_util.create_directory`. Puoi creare fino a 10000 directory, tutte posizionate nello spazio principale di storage dei dati. Puoi usare la procedura Amazon RDS in per eliminare le director `rdsadmin.rdsadmin_util.drop_directory`.
Le procedure `create_directory` e `drop_directory` hanno il seguente parametro obbligatorio.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | — | Sì | Il nome della directory. |
L'esempio seguente crea una nuova directory denominata `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.create_directory(p_directory_name => 'product_descriptions');
```
Il dizionario dati memorizza il nome della directory in maiuscolo. Puoi elencare le directory eseguendo query su `DBA_DIRECTORIES`. Il sistema seleziona il percorso host effettivo automaticamente. L'esempio seguente mostra ottiene il percorso di directory per la directory denominata `PRODUCT_DESCRIPTIONS`:
```
SELECT DIRECTORY_PATH
FROM DBA_DIRECTORIES
WHERE DIRECTORY_NAME='PRODUCT_DESCRIPTIONS';
DIRECTORY_PATH
----------------------------------------
/rdsdbdata/userdirs/01
```
Il nome utente master per l'istanza database ha privilegi di lettura e scrittura nella nuova directory e può concedere l'accesso ad altri utenti. I privilegi `EXECUTE` non sono disponibili per le directory su una istanza database. Le directory vengono create nello spazio di archiviazione dati principale e consumano spazio e larghezza di I/O banda.
L'esempio seguente elimina la directory denominata `PRODUCT_DESCRIPTIONS`.
```
EXEC rdsadmin.rdsadmin_util.drop_directory(p_directory_name => 'product_descriptions');
```
**Nota**
È inoltre possibile eliminare una directory utilizzando il comando Oracle SQL `DROP DIRECTORY`.
Il rilascio di una directory non rimuove i suoi contenuti. Poiché il metodo `rdsadmin.rdsadmin_util.create_directory` può riutilizzare percorsi, i file nelle directory eliminate possono apparire in una directory appena creata. Prima di eliminare una directory, si consiglia di utilizzare `UTL_FILE.FREMOVE` per rimuovere i file dalla directory. Per ulteriori informazioni, consulta la sezione relativa alla [Procedura FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) nella documentazione di Oracle.
## Generazione di un elenco dei file in una directory di istanze database
Puoi usare la procedura in Amazon RDS per elencare i file in una director `rdsadmin.rds_file_util.listdir`. Questa procedura non è supportata in una replica Oracle. La procedura `listdir` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sì | Il nome della directory da elencare. |
L'esempio seguente concede all'utente read/write i privilegi sulla directory `PRODUCT_DESCRIPTIONS``rdsadmin`, quindi elenca i file in questa directory.
```
GRANT READ,WRITE ON DIRECTORY PRODUCT_DESCRIPTIONS TO rdsadmin;
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'PRODUCT_DESCRIPTIONS'));
```
## Lettura dei file in una directory di istanze database
Puoi usare la procedura in Amazon RDS per leggere un file di test `rdsadmin.rds_file_util.read_text_file`. La procedura `read_text_file` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory` | varchar2 | — | Sì | Il nome della directory che contiene il file . |
| `p_filename` | varchar2 | — | Sì | Nome del file da leggere. |
Nell'esempio seguente viene creato il file `rice.txt` nella directory `PRODUCT_DESCRIPTIONS`.
```
declare
fh sys.utl_file.file_type;
begin
fh := utl_file.fopen(location=>'PRODUCT_DESCRIPTIONS', filename=>'rice.txt', open_mode=>'w');
utl_file.put(file=>fh, buffer=>'AnyCompany brown rice, 15 lbs');
utl_file.fclose(file=>fh);
end;
/
```
L'esempio seguente legge il file `rice.txt` dalla directory `PRODUCT_DESCRIPTIONS`.
```
SELECT * FROM TABLE
(rdsadmin.rds_file_util.read_text_file(
p_directory => 'PRODUCT_DESCRIPTIONS',
p_filename => 'rice.txt'));
```
## Accesso ai file Opatch
Opatch è una utility Oracle che consente l'applicazione e il rollback delle patch al software Oracle. Il meccanismo Oracle per determinare quali patch sono state applicate a un database è il comando `opatch lsinventory`. Per aprire le richieste di assistenza per i clienti BYOL (Bring Your Own Licence), il supporto Oracle richiede il file `lsinventory` e talvolta il file `lsinventory_detail` generato da Opatch.
Per offrire un'esperienza di servizio gestito, Amazon RDS non fornisce accesso shell a Opatch. Invece, l'`lsinventory-dbv.txt` nella directory BDUMP contiene le informazioni sulla patch relative alla versione corrente del motore. Quando esegui un aggiornamento minore o importante, Amazon RDS aggiorna `lsinventory-dbv.txt` entro un'ora dall'applicazione della patch. Per verificare le patch applicate, leggere `lsinventory-dbv.txt`. Questa operazione è simile all'esecuzione del comando `opatch lsinventory`.
**Nota**
Gli esempi riportati in questa sezione presuppongono che la directory BDUMP sia denominata `BDUMP`. In una replica di lettura il nome della directory BDUMP è diverso. Per informazioni su come ottenere il nome BDUMP eseguendo una query `V$DATABASE.DB_UNIQUE_NAME` su una replica di lettura, consulta [Elenco di file](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles.ViewingBackgroundDumpDest).
I file di inventario utilizzano la convenzione di denominazione di Amazon RDS `lsinventory-dbv.txt` e`lsinventory_detail-dbv.txt`, dove si *dbv* trova il nome completo della versione del database. Il file `lsinventory-dbv.txt` è disponibile in tutte le versioni DB. Il `lsinventory_detail-dbv.txt` corrispondente è disponibile nelle versioni 19.0.0.0, ru-2020-01.rur-2020-01.r1 o nelle versioni successive.
Ad esempio, se la versione del database è 19.0.0.0.ru-2021-07.rur-2021-07.r1, i file di inventario hanno i seguenti nomi.
```
lsinventory-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
lsinventory_detail-19.0.0.0.ru-2021-07.rur-2021-07.r1.txt
```
Assicurarsi di scaricare i file corrispondenti alla versione corrente del motore DB.
### Console
**Per scaricare un modello di inventario utilizzando la console**
1. Aprire la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Databases (Database)**.
1. Scegliere il nome dell'istanza di database che ha il file di log che si desidera visualizzare.
1. Scegliere la scheda **Logs & events (Log ed eventi)**.
1. Scorrere fino alla sezione **Logs (Log)**.
1. Nella sezione **Log** cercare `lsinventory`.
1. Selezionare il file a cui si desidera accedere, quindi scegliere **Scarica**.
### SQL
Per leggere `lsinventory-dbv.txt` in un client SQL, è possibile utilizzare un'istruzione `SELECT`. Per questa tecnica, utilizzare una delle seguenti funzioni `rdsadmin`: `rdsadmin.rds_file_util.read_text_file` o `rdsadmin.tracefile_listing`.
Nella seguente query di esempio, sostituiscila *dbv* con la tua versione di Oracle DB. Ad esempio, la versione del DB potrebbe essere 19.0.0.ru-2020-04.rur-2020-04.r1.
```
SELECT text
FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'lsinventory-dbv.txt'));
```
### PL/SQL
Per leggerla `lsinventory-dbv.txt` in un client SQL, puoi scrivere un PL/SQL programma. Questo programma utilizza `utl_file` per leggere il file e `dbms_output` per stamparlo. Questi sono pacchetti forniti da Oracle.
Nel seguente programma di esempio, sostituiscilo *dbv* con la tua versione di Oracle DB. Ad esempio, la versione del DB potrebbe essere 19.0.0.ru-2020-04.rur-2020-04.r1.
```
SET SERVEROUTPUT ON
DECLARE
v_file SYS.UTL_FILE.FILE_TYPE;
v_line VARCHAR2(1000);
v_oracle_home_type VARCHAR2(1000);
c_directory VARCHAR2(30) := 'BDUMP';
c_output_file VARCHAR2(30) := 'lsinventory-dbv.txt';
BEGIN
v_file := SYS.UTL_FILE.FOPEN(c_directory, c_output_file, 'r');
LOOP
BEGIN
SYS.UTL_FILE.GET_LINE(v_file, v_line,1000);
DBMS_OUTPUT.PUT_LINE(v_line);
EXCEPTION
WHEN no_data_found THEN
EXIT;
END;
END LOOP;
END;
/
```
Oppure interrogare `rdsadmin.tracefile_listing` ed eseguire lo spooling dell'output in un file. Nell'esempio seguente viene eseguito lo spooling dell'output in `/tmp/tracefile.txt`.
```
SPOOL /tmp/tracefile.txt
SELECT *
FROM rdsadmin.tracefile_listing
WHERE FILENAME LIKE 'lsinventory%';
SPOOL OFF;
```
## Gestione delle attività degli advisor
Oracle Database include un certo numero di advisor. Ogni advisor supporta attività automatizzate e manuali. Puoi utilizzare le procedure nel pacchetto `rdsadmin.rdsadmin_util` per gestire alcune attività di advisor.
Le procedure delle attività di advisor sono disponibili nelle seguenti versioni del motore:
+ Oracle Database 21c (21.0.0)
+ Versione 19.0.0.0.ru-2021-01.rur-2021-01.r1 e versioni successive di Oracle Database 19c
Per ulteriori informazioni, consultare [Versione 19.0.0.0.ru-2021-01.rur-2021-01.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2021-01.rur-2021-01.r1) nelle *Note di rilascio di Amazon RDS for Oracle*.
**Topics**
+ [Impostazione dei parametri per le attività di advisor](#Appendix.Oracle.CommonDBATasks.setting-task-parameters)
+ [Disattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.dropping-advisor-task)
+ [Riattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK](#Appendix.Oracle.CommonDBATasks.recreating-advisor-task)
### Impostazione dei parametri per le attività di advisor
Per impostare i parametri per alcune attività di advisor, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_set_parameter`. La procedura `advisor_task_set_parameter` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sì | Il nome dell'attività di advisor di cui si desidera modificare i parametri. I valori seguenti sono validi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Appendix.Oracle.CommonDBATasks.Misc.html) |
| `p_parameter` | varchar2 | — | Sì | Il nome del parametro dell'attività. Per trovare parametri validi per un'attività di advisor, esegui la query riportata. Sostituisci *p\$1task\$1name* con un valore valido`p_task_name`: COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
| `p_value` | varchar2 | — | Sì | Il valore di un parametro di attività. Per trovare valori validi per i parametri delle attività, esegui la query riportata. Sostituire *p\$1task\$1name* con un valore valido: `p_task_name` COL PARAMETER_NAME FORMAT a30
COL PARAMETER_VALUE FORMAT a30
SELECT PARAMETER_NAME, PARAMETER_VALUE
FROM DBA_ADVISOR_PARAMETERS
WHERE TASK_NAME='p_task_name'
AND PARAMETER_VALUE != 'UNUSED'
ORDER BY PARAMETER_NAME;
|
Il seguente PL/SQL programma è impostato `ACCEPT_PLANS` su `FALSE` for`SYS_AUTO_SPM_EVOLVE_TASK`. L'attività automatizzata Gestione piano SQL verifica i piani e genera un report dei risultati, ma non evolve automaticamente i piani. Puoi utilizzare un report per identificare le nuove baseline del piano SQL e accettarle manualmente.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'SYS_AUTO_SPM_EVOLVE_TASK',
p_parameter => 'ACCEPT_PLANS',
p_value => 'FALSE');
END;
```
Il seguente PL/SQL programma è `EXECUTION_DAYS_TO_EXPIRE` impostato su `10` for`AUTO_STATS_ADVISOR_TASK`. L'attività predefinita `AUTO_STATS_ADVISOR_TASK` viene eseguita automaticamente nella finestra di manutenzione una volta al giorno. Nell'esempio viene impostato il periodo di conservazione per l'esecuzione dell'attività su 10 giorni.
```
BEGIN
rdsadmin.rdsadmin_util.advisor_task_set_parameter(
p_task_name => 'AUTO_STATS_ADVISOR_TASK',
p_parameter => 'EXECUTION_DAYS_TO_EXPIRE',
p_value => '10');
END;
```
### Disattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
Per disabilitare `AUTO_STATS_ADVISOR_TASK`, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_util.advisor_task_drop`. La procedura `advisor_task_drop` accetta il seguente parametro.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_task_name` | varchar2 | — | Sì | Il nome dell'attività di advisor da disabilitare. L'unico valore valido è `AUTO_STATS_ADVISOR_TASK`. |
Il seguente comando elimina `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.advisor_task_drop('AUTO_STATS_ADVISOR_TASK')
```
Puoi riabilitare `AUTO_STATS_ADVISOR_TASK` utilizzando `rdsadmin.rdsadmin_util.dbms_stats_init`.
### Riattivazione di AUTO\$1STATS\$1ADVISOR\$1TASK
Per riattivare `AUTO_STATS_ADVISOR_TASK`, utilizzare la procedura Amazon RDS `rdsadmin.rdsadmin_util.dbms_stats_init` . La procedura `dbms_stats_init` non richiede parametri.
Il seguente comando abilita nuovamente `AUTO_STATS_ADVISOR_TASK`.
```
EXEC rdsadmin.rdsadmin_util.dbms_stats_init()
```
# Trasporto di tablespace
Usa il pacchetto Amazon RDS `rdsadmin.rdsadmin_transport_util` per copiare un set di tablespace da un database Oracle on-premise a un'istanza database RDS per Oracle. A livello fisico, questa funzionalità tablespace trasportabile copia in modo incrementale i file di dati e metadati nell'istanza di destinazione. È possibile trasferire i file mediante Amazon EFS o Amazon S3. Per ulteriori informazioni, consulta [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md).
**Topics**
+ [Importazione di tablespace trasportate nell'istanza database](rdsadmin_transport_util_import_xtts_tablespaces.md)
+ [Importazione dei metadati delle tablespace trasportabili nell'istanza database](rdsadmin_transport_util_import_xtts_metadata.md)
+ [Elenco dei file orfani dopo un'importazione della tablespace](rdsadmin_transport_util_list_xtts_orphan_files.md)
+ [Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md)
# Importazione di tablespace trasportate nell'istanza database
Usa la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` per ripristinare le tablespace esportate in precedenza da un'istanza database di origine. In questa fase di trasporto, viene eseguito il backup delle tablespace di sola lettura, vengono esportati i metadati di Data Pump, vengono trasferiti questi file nell'istanza database di destinazione e quindi vengono importate le tablespace. Per ulteriori informazioni, consulta [Fase 4: trasporto delle tablespace](oracle-migrating-tts.md#oracle-migrating-tts.final-br-phase).
## Sintassi
```
FUNCTION import_xtts_tablespaces(
p_tablespace_list IN CLOB,
p_directory_name IN VARCHAR2,
p_platform_id IN NUMBER DEFAULT 13,
p_parallel IN INTEGER DEFAULT 0) RETURN VARCHAR2;
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_tablespace_list` | `CLOB` | — | Sì | L'elenco delle tablespace da importare. |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene i backup del tablespace. |
| `p_platform_id` | `NUMBER` | `13` | No | Fornire un ID piattaforma che corrisponde a quello specificato durante la fase di backup. Per trovare un elenco di piattaforme, esegui una query su `V$TRANSPORTABLE_PLATFORM`. La piattaforma predefinita è Linux x86 a 64 bit, che è in formato little-endian. |
| `p_parallel` | `INTEGER` | `0` | No | Il grado di parallelismo. Il parallelismo è disabilitato per impostazione predefinita. |
## Esempi
L'esempio seguente importa i tablespace *TBS1* e *TBS3* dalla directory. *TBS2* *DATA\$1PUMP\$1DIR* La piattaforma di origine è AIX-Based Systems (64 bit), identificata dall’ID `6`. È possibile trovare la piattaforma IDs eseguendo una query. `V$TRANSPORTABLE_PLATFORM`
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
# Importazione dei metadati delle tablespace trasportabili nell'istanza database
Utilizza la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_metadata` per importare i metadati delle tablespace trasportabili nell'istanza database RDS per Oracle. Durante l'operazione, lo stato dell'importazione dei metadati viene visualizzato nella tabella `rdsadmin.rds_xtts_operation_info`. Per ulteriori informazioni, consulta [Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione](oracle-migrating-tts.md#oracle-migrating-tts.transport.import-dmp).
## Sintassi
```
PROCEDURE import_xtts_metadata(
p_datapump_metadata_file IN SYS.DBA_DATA_FILES.FILE_NAME%TYPE,
p_directory_name IN VARCHAR2,
p_exclude_stats IN BOOLEAN DEFAULT FALSE,
p_remap_tablespace_list IN CLOB DEFAULT NULL,
p_remap_user_list IN CLOB DEFAULT NULL);
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_datapump_metadata_file` | `SYS.DBA_DATA_FILES.FILE_NAME%TYPE` | — | Sì | Il nome del file Oracle Data Pump che contiene i metadati per le tablespace trasportabili. |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene il file Data Pump. |
| `p_exclude_stats` | `BOOLEAN` | `FALSE` | No | Flag che indica se escludere le statistiche. |
| `p_remap_tablespace_list` | `CLOB` | NULL | No | Un elenco delle tablespace che devono essere rimappate durante l'importazione dei metadati. Utilizzare il formato `from_tbs:to_tbs`. Ad esempio, specifica `users:user_data`. |
| `p_remap_user_list` | `CLOB` | NULL | No | Un elenco di schemi utente che devono essere rimappati durante l'importazione dei metadati. Utilizzare il formato `from_schema_name:to_schema_name`. Ad esempio, specifica `hr:human_resources`. |
## Esempi
L'esempio importa i metadati del tablespace dal file*xttdump.dmp*, che si trova nella directory. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
# Elenco dei file orfani dopo un'importazione della tablespace
Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per elencare i file di dati che sono rimasti orfani dopo un'importazione della tablespace. Dopo aver identificato i file di dati, puoi eliminarli chiamando `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
## Sintassi
```
FUNCTION list_xtts_orphan_files RETURN xtts_orphan_files_list_t PIPELINED;
```
## Esempi
L'esempio seguente esegue la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`. L'output mostra due file di dati che sono rimasti orfani.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
# Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace
Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per eliminare i file di dati che sono rimasti orfani dopo un'importazione della tablespace. L'esecuzione di questo comando genera un file di log che utilizza il formato del nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` nella directory `BDUMP`. Usa la procedura `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import` per trovare i file rimasti orfani. Puoi leggere il file di log chiamando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Fase 6: rimozione dei file residui](oracle-migrating-tts.md#oracle-migrating-tts.cleanup).
## Sintassi
```
PROCEDURE cleanup_incomplete_xtts_import(
p_directory_name IN VARCHAR2);
```
## Parameters
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory_name` | `VARCHAR2` | — | Sì | La directory che contiene i file di dati rimasti orfani. |
## Esempi
L'esempio seguente elimina i file di dati orfani in. *DATA\$1PUMP\$1DIR*
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'esempio seguente legge il file di log generato dal comando precedente.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
# Utilizzo dello storage in RDS per Oracle
Ogni istanza RDS for Oracle ha un volume di storage principale. Per aumentare la capacità di storage, puoi collegare fino a tre volumi di storage aggiuntivi all'istanza DB. A seconda dei requisiti del carico di lavoro, scegli tra lo storage gp3 e io2 per ogni volume. Ad esempio, potresti inserire i dati a cui accedi di frequente su un volume io2 e i dati storici su un volume gp3.
Utilizzate volumi di storage aggiuntivi per ottenere i seguenti vantaggi:
+ **Capacità migliorata**: scalate lo storage totale fino a 256 TiB per istanza DB collegando fino a tre volumi di storage aggiuntivi.
+ **Configurazione flessibile dello storage e ottimizzazione delle prestazioni**: combina diversi tipi di storage (gp3 e io2) per ottimizzare sia i costi che le prestazioni in base ai modelli di accesso ai dati. Separa i dati a cui si accede di frequente sullo storage io2 ad alte prestazioni dai dati di archivio sullo storage gp3 a costi contenuti.
+ **Espandi e riduci la capacità di archiviazione in base alle esigenze**: collega un volume quando hai bisogno di spazio di archiviazione aggiuntivo, come durante la migrazione dei dati, e poi elimina il volume. In questo modo, puoi espandere e ridurre lo storage totale delle istanze DB.
+ **Spostamento dei dati online**: utilizza le funzionalità integrate del database Oracle per spostare i dati tra i volumi senza tempi di inattività.
**Nota**
È possibile rimuovere volumi di storage aggiuntivi, ma non è possibile rimuovere il volume principale.
**Topics**
+ [Considerazioni sull'utilizzo di volumi di storage aggiuntivi con RDS per Oracle](#User_Oracle_AdditionalStorage.considerations)
+ [Limitazioni dell'utilizzo di volumi di storage aggiuntivi con RDS per Oracle](#User_Oracle_AdditionalStorage.limitations)
+ [Operazioni di gestione del database con volumi di archiviazione aggiuntivi in RDS per Oracle](#User_Oracle_AdditionalStorage.DBManagement)
+ [Aggiungere, rimuovere o modificare i volumi di storage con RDS per Oracle](User_Oracle_AdditionalStorage.ModifyStorageVolumes.md)
+ [Backup e ripristino dei dati con volumi di storage aggiuntivi in RDS per Oracle](User_Oracle_AdditionalStorage.BackupRestore.md)
+ [Casi d'uso per volumi di storage aggiuntivi in RDS for Oracle](User_Oracle_AdditionalStorage.UseCases.md)
## Considerazioni sull'utilizzo di volumi di storage aggiuntivi con RDS per Oracle
Quando utilizzi volumi di storage aggiuntivi con RDS per Oracle, considera quanto segue:
+ È possibile aggiungere fino a 3 volumi di storage aggiuntivi per istanza.
+ I volumi di archiviazione aggiuntivi devono utilizzare i seguenti nomi di volume:
+ rdsdbdata2
+ rdsdbdata3
+ rdsdbdata4
+ È possibile aggiungere solo tipi di storage General Purpose SSD (gp3) e Provisioned IOPS SSD (io2).
+ È possibile utilizzare le funzionalità di rilocazione online di Oracle per spostare i dati tra i volumi mentre le applicazioni continuano a funzionare.
+ Quando si crea un volume di storage aggiuntivo modificando l'istanza DB, RDS crea immediatamente il volume di storage indipendentemente dall'impostazione delle modifiche pianificate. L'aggiunta di un volume di archiviazione è un'operazione online e non influisce sulle prestazioni del database. Per informazioni, consulta [Utilizzo dell’impostazione della pianificazione delle modifiche](USER_ModifyInstance.ApplyImmediately.md).
Per prestazioni ottimali, controlla quanto segue quando utilizzi volumi di archiviazione aggiuntivi:
+ Pianificazione dello spostamento dei dati
+ Pianifica movimenti di grandi dimensioni durante le ore non di punta
+ Suddividi le operazioni di grandi dimensioni in blocchi più piccoli
+ Monitora le risorse di sistema durante gli spostamenti
+ Gestione delle risorse
+ Mantieni sufficiente spazio libero su entrambi i volumi
+ Monitora I/O i pattern usando AWR o Statspack
+ Presta attenzione agli scenari con spazio di archiviazione completo
+ Best practice
+ Utilizza le operazioni online di trasferimento dei file di dati, ove possibile
+ Mantenete gli indici appropriati
+ Monitora regolarmente l'utilizzo dello spazio
Quando si utilizzano volumi di storage aggiuntivi con repliche:
+ Quando si crea una replica RDS per Oracle per un'istanza DB con volumi di storage aggiuntivi, RDS configura automaticamente volumi di storage aggiuntivi sulla replica. Tuttavia, eventuali modifiche successive apportate ai volumi di archiviazione dell'istanza DB principale non vengono applicate automaticamente alla replica.
+ Quando si gestiscono le posizioni dei file di dati tra i volumi, si consiglia di utilizzare le impostazioni dei gruppi di parametri anziché le modifiche a livello di sessione per garantire un comportamento coerente tra istanze primarie e di replica.
## Limitazioni dell'utilizzo di volumi di storage aggiuntivi con RDS per Oracle
Le seguenti limitazioni si applicano all'utilizzo di volumi di archiviazione aggiuntivi con RDS per Oracle:
+ Non è possibile aggiungere un volume di archiviazione ai tipi di istanze con meno di 64 GiB di memoria perché non dispongono di memoria sufficiente per supportare grandi volumi di archiviazione.
+ La dimensione minima di archiviazione è di 200 GiB per volumi di storage aggiuntivi. Il volume di storage principale dell'istanza DB deve essere uguale o superiore a 200 GiB per collegare volumi di storage aggiuntivi. La dimensione massima di storage per l'istanza DB è di 256 TiB totali su tutti i volumi.
+ Le seguenti funzionalità non sono supportate per le istanze DB con volumi di storage aggiuntivi:
+ Backup automatici in più regioni
+ Scalabilità automatica dello storage (per volumi di storage aggiuntivi)
+ Copia dell'istantanea tra più account
+ Istantanee pubbliche
+ Non è possibile eliminare il volume di archiviazione principale (`rdsdbdata`), ma è possibile eliminare altri volumi di archiviazione aggiuntivi purché siano vuoti.
+ Non è possibile archiviare i redo log online, i redo log archiviati e i control file in volumi di archiviazione aggiuntivi. Questi file possono essere archiviati solo nel volume di archiviazione principale (). `rdsdbdata`
## Operazioni di gestione del database con volumi di archiviazione aggiuntivi in RDS per Oracle
È possibile eseguire operazioni di gestione del database come la creazione di tablespace o lo spostamento di dati tra volumi di archiviazione utilizzando volumi di archiviazione aggiuntivi in RDS for Oracle. Per ulteriori informazioni sulle operazioni di gestione del database con volumi di archiviazione aggiuntivi, vedere le seguenti sezioni:
+ [Specificazione delle posizioni dei file di database in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.DatabaseFileLocations)
+ [Creazione e dimensionamento di tablespace in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles)
+ [Spostamento di file di dati tra volumi in RDS per Oracle](Appendix.Oracle.CommonDBATasks.MovingDataBetweenVolumes.md#Appendix.Oracle.CommonDBATasks.MovingDatafiles)
# Aggiungere, rimuovere o modificare i volumi di storage con RDS per Oracle
È possibile aggiungere, modificare e rimuovere volumi di archiviazione aggiuntivi utilizzando Console di gestione AWS o AWS CLI. Tutte le operazioni utilizzano il `modify-db-instance` comando con il `additional-storage-volumes` parametro.
**Importante**
L'aggiunta o la rimozione di volumi di archiviazione aggiuntivi crea un'azione di backup in sospeso e una finestra di blackout. La finestra di blackout si chiude al termine del flusso di lavoro di backup.
## Aggiungere volumi di archiviazione
È possibile aggiungere fino a tre volumi di archiviazione oltre al volume di archiviazione principale. Per aggiungere un nuovo volume di archiviazione all'istanza DB di RDS for Oracle, utilizza il `modify-db-instance` comando con il `additional-storage-volumes` parametro.
Il seguente frammento di codice aggiunge un nuovo volume SSD generico (gp3) da 5.000 GiB con un nome IOPS di 4000 provisioning. `rdsdbdata3`
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata3",
"StorageType":"gp3",
"AllocatedStorage":5000
"IOPS":4000}
]' \
--apply-immediately
```
## Modifica dei volumi di archiviazione
È possibile modificare il tipo di storage, la dimensione dello storage allocato, gli IOPS e le impostazioni del throughput di archiviazione del volume di archiviazione aggiuntivo. Il seguente frammento di codice modifica l'impostazione IOPS per il volume. `rdsdbdata2`
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"IOPS":8000}
]' \
--apply-immediately
```
**Nota**
Non è possibile ridurre l'allocazione di storage per un volume di archiviazione aggiuntivo dopo averlo aggiunto all'istanza.
## Rimozione dei volumi di archiviazione
È possibile rimuovere volumi di storage aggiuntivi dalle istanze DB di RDS per Oracle quando non sono più necessari. Prima di rimuovere un volume, assicuratevi di aver spostato tutti i file di database dal volume e che nessun oggetto del database vi faccia riferimento. Verificate che lo stato del volume sia`Not-in-use`. È possibile rimuovere volumi di archiviazione aggiuntivi, ma non è possibile rimuovere il volume di archiviazione principale.
**avvertimento**
Prima di rimuovere un volume di archiviazione aggiuntivo, assicurati che nessun file di database sia archiviato nel volume. La rimozione di un volume con file di database attivi causa il danneggiamento del database.
L'esempio seguente rimuove il `rdsdbdata4` volume.
```
aws rds modify-db-instance \
--db-instance-identifier my-oracle-instance \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"SetForDelete":true}
]' \
--apply-immediately
```
# Backup e ripristino dei dati con volumi di storage aggiuntivi in RDS per Oracle
È possibile utilizzare backup automatici e creare uno snapshot DB con l'istanza DB con volumi di storage aggiuntivi. Tutte le operazioni di backup includono sia il volume principale che i volumi di storage aggiuntivi. È inoltre possibile utilizzare point-in-time il ripristino per l'istanza DB con volumi di storage aggiuntivi. Quando ripristini il database, puoi aggiungere volumi di archiviazione. È inoltre possibile modificare le impostazioni di archiviazione dei volumi esistenti. Non è possibile eliminare volumi di archiviazione aggiuntivi quando si ripristina il database da un'istantanea.
**Topics**
+ [Creazione di istantanee manuali](#User_Oracle_AdditionalStorage.BackupRestore.ManualSnapshots)
+ [Ripristino di istantanee manuali](#User_Oracle_AdditionalStorage.BackupRestore.RestoreSnapshots)
+ [Point-in-time ripristino](#User_Oracle_AdditionalStorage.BackupRestore.PitR)
## Creazione di istantanee manuali
L'esempio seguente crea un'istantanea manuale del database con volumi di storage aggiuntivi:
```
aws rds create-db-snapshot \
--db-instance-identifier my-oracle-asv-instance \
--db-snapshot-identifier my-snapshot
```
## Ripristino di istantanee manuali
Quando si esegue il ripristino da un'istantanea, è possibile aggiungere nuovi volumi di storage aggiuntivi o modificare le impostazioni di IOPS o di throughput dei volumi esistenti. L'esempio seguente ripristina un'istanza DB da un'istantanea e modifica l'impostazione IOPS per il volume: `rdsdbdata2`
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier my-restored-instance \
--db-snapshot-identifier my-snapshot \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"IOPS":5000
}
]'
```
## Point-in-time ripristino
Durante il point-in-time ripristino (PITR), è possibile aggiungere nuovi volumi di archiviazione aggiuntivi con configurazioni personalizzate. L'esempio seguente esegue PITR e aggiunge un nuovo SSD General Purpose da 5.000 GiB (gp3) con 5000 IOPS e MB/s 200 velocità di storage per il volume: `rdsdbdata2`
```
aws rds restore-db-instance-to-point-in-time \
--source-db-instance-identifier my-source-instancemy-source-instance \
--target-db-instance my-pitr-instance\
--use-latest-restorable-time \
--region us-east-1 \
--additional-storage-volumes '[
{
"VolumeName":"rdsdbdata2",
"StorageType":"gp3",
"AllocatedStorage":5000,
"IOPS":5000,
"StorageThroughput":200
}
]'
```
# Casi d'uso per volumi di storage aggiuntivi in RDS for Oracle
I volumi di storage aggiuntivi supportano diversi scenari di gestione dei database. Le sezioni seguenti descrivono i casi d'uso e gli approcci di implementazione più comuni.
**Topics**
+ [Estensione della capacità di storage oltre 64 TiB](#User_Oracle_AdditionalStorage.UseCases.Extendingstoragecapacity)
+ [Archiviazione su più livelli dei dati a cui si accede frequentemente e meno frequentemente su volumi separati](#User_Oracle_AdditionalStorage.UseCases.Storagetiering)
+ [Archiviazione temporanea per il caricamento e lo scaricamento dei dati](#User_Oracle_AdditionalStorage.UseCases.Temporarystorage)
+ [Utilizzo di tablespace trasportabili Oracle con un volume di archiviazione aggiuntivo](#User_Oracle_AdditionalStorage.UseCases.TransportableTablespaces)
## Estensione della capacità di storage oltre 64 TiB
È possibile utilizzare volumi di storage aggiuntivi quando il volume di storage principale si avvicina al limite di 64 TiB ma è necessario più spazio di archiviazione nel database. È possibile collegare volumi di storage aggiuntivi all'istanza DB, ciascuno fino a 64 TiB, utilizzando il comando. `modify-db-instance` Dopo aver collegato volumi di archiviazione aggiuntivi, è possibile creare tablespace su volumi di archiviazione aggiuntivi e spostare oggetti come tabelle, indici e partizioni su tali tablespace utilizzando lo standard Oracle SQL. Per ulteriori informazioni, consulta [Operazioni di gestione del database con volumi di archiviazione aggiuntivi in RDS per Oracle](User_Oracle_AdditionalStorage.md#User_Oracle_AdditionalStorage.DBManagement).
## Archiviazione su più livelli dei dati a cui si accede frequentemente e meno frequentemente su volumi separati
È possibile utilizzare volumi di storage aggiuntivi per ottimizzare costi e prestazioni configurando diversi tipi di storage tra i volumi. Ad esempio, è possibile utilizzare volumi di storage Provisioned IOPS SSD (io2) ad alte prestazioni per i dati a cui si accede di frequente, archiviando al contempo i dati storici su volumi di storage General Purpose (gp3) convenienti. È possibile spostare oggetti di database specifici (tabelle, indici e partizioni) in questi tablespace utilizzando comandi Oracle standard. Per ulteriori informazioni, consulta [Operazioni di gestione del database con volumi di archiviazione aggiuntivi in RDS per Oracle](User_Oracle_AdditionalStorage.md#User_Oracle_AdditionalStorage.DBManagement).
## Archiviazione temporanea per il caricamento e lo scaricamento dei dati
È possibile utilizzare volumi di archiviazione aggiuntivi come archiviazione temporanea per carichi o esportazioni di dati di grandi dimensioni con i seguenti passaggi:
+ Crea una directory su un volume di archiviazione aggiuntivo con il seguente comando:
```
BEGIN
rdsadmin.rdsadmin_util.create_directory(
p_directory_name => 'DATA_PUMP_DIR2',
p_database_volume_name => 'rdsdbdata2');
END;
/
```
+ Dopo la creazione della directory, segui i passaggi descritti in [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md) per esportare e importare i dati nella nuova directory.
+ Al termine dell'operazione, rimuovete i file e, facoltativamente, eliminate il volume per risparmiare sui costi di archiviazione. È possibile rimuovere il volume di archiviazione aggiuntivo solo quando il volume è vuoto.
## Utilizzo di tablespace trasportabili Oracle con un volume di archiviazione aggiuntivo
È possibile utilizzare volumi di archiviazione aggiuntivi per spostare i file di dati su un volume di archiviazione aggiuntivo utilizzando tablespace trasportabili Oracle con i seguenti passaggi:
+ Imposta `db_create_file_dest` il parametro a livello di sessione prima di importare tablespace trasportabili nel database di destinazione con un volume di archiviazione aggiuntivo.
```
ALTER SESSION SET db_create_file_dest = '/rdsdbdata2/db';
VAR x CLOB;
BEGIN
:x := rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
p_tablespace_list => 'TBTEST1',
p_directory_name => 'XTTS_DIR_DATA2',
p_platform_id => 13);
END;
/
PRINT :x;
```
+ Controlla lo stato di importazione dei tablespace trasportabili:
```
ALTER SESSION SET nls_date_format = 'DD.MM.YYYY HH24:MI:SS';
COL xtts_operation_start_utc FORMAT A30
COL xtts_operation_end_utc FORMAT A30
COL xtts_operation_state FORMAT A30
COL xtts_operation_type FORMAT A30
SELECT xtts_operation_start_utc, xtts_operation_type, xtts_operation_state
FROM rdsadmin.rds_xtts_operation_info;
```
+ Una volta completata l'importazione delle tablespace trasportabili, importa i metadati delle tablespace trasportabili.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata(
p_datapump_metadata_file => 'xttdump.dmp',
p_directory_name => 'XTTS_DIR_DATA2');
END;
/
```
# Configurazione delle funzionalità avanzate di RDS per Oracle
RDS per Oracle supporta varie funzionalità avanzate, tra cui HugePages, un archivio dell'istanza e i tipi di dati estesi.
**Topics**
+ [Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.md)
+ [Attivazione di HugePages per un'istanza RDS per Oracle](Oracle.Concepts.HugePages.md)
+ [Attivazione dei tipi di dati estesi in RDS per Oracle](Oracle.Concepts.ExtendedDataTypes.md)
# Archiviazione di dati temporanei in un archivio dell'istanza RDS per Oracle
Utilizza un archivio dell'istanza per gli spazi di tabella temporanei e Database Smart Flash Cache (la cache flash) su classi di istanza database RDS per Oracle supportate.
**Topics**
+ [Panoramica dell'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview)
+ [Attivazione di un archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.Enable)
+ [Configurazione di un archivio dell'istanza RDS per Oracle](CHAP_Oracle.advanced-features.instance-store.configuring.md)
+ [Utilizzo di un archivio dell'istanza in una replica di lettura Oracle](CHAP_Oracle.advanced-features.instance-store.replicas.md)
+ [Configurazione di un gruppo di spazi di tabella temporanei in un archivio dell'istanza e in Amazon EBS](CHAP_Oracle.advanced-features.instance-store.temp-ebs.md)
+ [Rimozione di un archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.Disable)
## Panoramica dell'archivio dell'istanza RDS per Oracle
Un *archivio dell'istanza* fornisce uno spazio di archiviazione temporaneo a livello di blocco per un'istanza database RDS per Oracle. È possibile utilizzare un archivio dell'istanza per l'archiviazione temporanea di informazioni che cambiano di frequente.
Un instance store è basato su dispositivi Non-Volatile Memory Express (NVMe) fisicamente collegati al computer host. Lo storage è ottimizzato per bassa latenza, I/O prestazioni casuali e velocità di lettura sequenziale.
La dimensione dell'archivio dell'istanza varia in base al tipo di istanza database. Per ulteriori informazioni sull'archivio dell'istanza, consulta [Instance store Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html) nella *Guida per l'utente di Amazon Elastic Compute Cloud per istanze Linux*.
**Topics**
+ [Tipi di dati nell'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.uses)
+ [Vantaggi dell'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.benefits)
+ [Classi di istanza supportate per l'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.instance-classes)
+ [Versioni del motore supportate per l'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.db-versions)
+ [Supportato Regioni AWS per l'archivio di istanze RDS for Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.regions)
+ [Costo dell'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.cost)
### Tipi di dati nell'archivio dell'istanza RDS per Oracle
In un archivio dell'istanza puoi inserire i seguenti tipi di dati temporanei RDS per Oracle:
Spazio di tabella temporaneo
Oracle Database utilizza gli spazi di tabella temporanei per archiviare i risultati delle query intermedie che non rientrano nella memoria. Le query più grandi possono generare grandi quantità di dati intermedi che devono essere temporaneamente memorizzati nella cache, ma non devono essere persistenti. In particolare, uno spazio di tabella temporaneo è utile per ordinamenti, aggregazioni di hash e join. Se l'istanza database RDS per Oracle utilizza Enterprise Edition o Standard Edition 2, puoi inserire uno spazio di tabella temporaneo in un archivio dell'istanza.
Cache flash
La cache flash migliora le prestazioni delle letture casuali a blocco singolo nel percorso convenzionale. È consigliabile dimensionare la cache per adattarla alla maggior parte dei set di dati attivi. Se l'istanza database RDS per Oracle utilizza Enterprise Edition, è possibile inserire la cache flash in un archivio dell'istanza.
Per impostazione predefinita, un archivio dell'istanza è configurato per uno spazio di tabella temporaneo ma non per la cache flash. Non è possibile inserire i file di dati Oracle e i file di registro del database in un archivio dell'istanza.
### Vantaggi dell'archivio dell'istanza RDS per Oracle
Potresti prendere in considerazione l'utilizzo di un archivio dell'istanza per archiviare file e cache temporanei che puoi perdere. Se desideri migliorare le prestazioni del database o se un carico di lavoro in aumento causa problemi di prestazioni per l'archivio Amazon EBS, valuta la possibilità di dimensionarlo a una classe di istanza che supporti un archivio dell'istanza.
Posizionando lo spazio di tabella temporaneo e la cache flash in un archivio dell'istanza, si ottengono i seguenti vantaggi:
+ Minori latenze di lettura
+ Velocità di trasmissione effettiva più alta
+ Carico ridotto sui volumi Amazon EBS
+ Riduzione dei costi di archivio e snapshot grazie al carico ridotto di Amazon EBS
+ Minore necessità di eseguire il provisioning di IOPS elevati, con conseguente riduzione dei costi complessivi
Posizionando lo spazio di tabella temporaneo nell'archivio dell'istanza, si ottiene un immediato incremento delle prestazioni per le query che utilizzano lo spazio temporaneo. Quando posizioni la cache flash nell'archivio dell'istanza, le letture dei blocchi memorizzati nella cache hanno in genere una latenza molto inferiore rispetto alle letture di Amazon EBS. La cache flash deve essere "riscaldata" prima di offrire vantaggi in termini di prestazioni. La cache si riscalda da sola perché il database scrive i blocchi nella cache flash man mano che escono dalla cache del buffer del database.
**Nota**
In alcuni casi, la cache flash provoca un sovraccarico delle prestazioni a causa della gestione della cache. Prima di attivare la cache flash in un ambiente di produzione, ti consigliamo di analizzare il carico di lavoro e testare la cache in un ambiente di test.
### Classi di istanza supportate per l'archivio dell'istanza RDS per Oracle
Amazon RDS supporta l'archivio dell'istanza per le seguenti classi di istanza database:
+ db.m5d
+ db.m6id
+ db.r5d
+ db.r6id
+ db.x2idn
+ db.x2iedn
RDS per Oracle supporta le classi di istanza database precedenti solo per il modello di licenza BYOL. Per ulteriori informazioni, consultare [Classi di istanza database RDS per Oracle supportate](Oracle.Concepts.InstanceClasses.md#Oracle.Concepts.InstanceClasses.Supported) e [Bring Your Own License (BYOL) per EE e SE2](Oracle.Concepts.Licensing.md#Oracle.Concepts.Licensing.BYOL).
Per visualizzare lo spazio di archiviazione totale delle istanze per i tipi di istanze DB supportati, esegui il seguente comando nella AWS CLI.
**Example**
```
aws ec2 describe-instance-types \
--filters "Name=instance-type,Values=*5d.*large*,*6id.*large*" \
--query "InstanceTypes[?contains(InstanceType,'m5d')||contains(InstanceType,'r5d')||contains(InstanceType,'m6id')||contains(InstanceType,'r6id')][InstanceType, InstanceStorageInfo.TotalSizeInGB]" \
--output table
```
Il comando precedente restituisce la dimensione del dispositivo raw per l'archivio dell'istanza. RDS per Oracle utilizza una piccola parte di questo spazio per la configurazione. Lo spazio nell'archivio dell'istanza disponibile per gli spazi di tabella temporanei o per la cache flash è leggermente inferiore.
### Versioni del motore supportate per l'archivio dell'istanza RDS per Oracle
L'archivio dell'istanza è supportato nelle seguenti versioni del motore RDS per Oracle:
+ 21.0.0.0.ru-2022-01.rur-2022-01.r1 o versioni successive di Oracle Database 21c
+ 19.0.0.0.ru-2020-10.rur-2020-10.r1 o versioni successive di Oracle Database 19c
### Supportato Regioni AWS per l'archivio di istanze RDS for Oracle
L'instance store è disponibile in tutti i paesi in Regioni AWS cui sono supportati uno o più di questi tipi di istanze. Per ulteriori informazioni sulle classi di istanza db.m5d e db.r5d, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md). Per ulteriori informazioni sulle classi di istanza supportate da Amazon RDS per Oracle, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
### Costo dell'archivio dell'istanza RDS per Oracle
Il costo dell'archivio dell'istanza è incluso nel costo delle istanze attivate dall'archivio dell'istanza. L'attivazione di un archivio dell'istanza in un'istanza database RDS per Oracle non comporta costi aggiuntivi. Per ulteriori informazioni sulle istanze attivate dall'archivio dell'istanza, consulta [Classi di istanza supportate per l'archivio dell'istanza RDS per Oracle](#CHAP_Oracle.advanced-features.instance-store.overview.instance-classes).
## Attivazione di un archivio dell'istanza RDS per Oracle
Per attivare l'archivio dell'istanza per i dati temporanei di RDS per Oracle, procedi in uno dei seguenti modi:
+ Crea un'istanza database RDS per Oracle utilizzando una classe di istanza supportata. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza database RDS per Oracle esistente per utilizzare una classe di istanza supportata. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Configurazione di un archivio dell'istanza RDS per Oracle
Per impostazione predefinita, il 100% dello spazio dell'archivio dell'istanza viene allocato allo spazio di tabella temporaneo. Per configurare l'archivio dell'istanza per allocare spazio alla cache flash e allo spazio di tabella temporaneo, imposta i seguenti parametri nel gruppo di parametri per l'istanza:
**db\$1flash\$1cache\$1size=\$1DBInstanceStore\$1\$10,2,4,6,8,10\$1/10\$1**
Questo parametro specifica la quantità di spazio di archiviazione allocata per la cache flash. Questo parametro è valido solo per Oracle Database Enterprise Edition. Il valore predefinito è `{DBInstanceStore*0/10}`. Se imposti un valore diverso da zero per `db_flash_cache_size`, l'istanza RDS per Oracle abilita la cache flash dopo il riavvio dell'istanza.
**rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$1\$10,2,4,6,8,10\$1/10\$1**
Questo parametro specifica la quantità di spazio di archiviazione allocata per lo spazio di tabella temporaneo. Il valore predefinito è `{DBInstanceStore*10/10}`. Questo parametro è modificabile per Oracle Database Enterprise Edition e di sola lettura per Standard Edition 2. Se imposti un valore diverso da zero per `rds.instance_store_temp_size`, Amazon RDS alloca lo spazio nell'archivio dell'istanza per lo spazio di tabella temporaneo.
È possibile impostare i parametri `db_flash_cache_size` e `rds.instance_store_temp_size` per le istanze database che non utilizzano un archivio dell'istanza. In questo caso, entrambe le impostazioni restituiscono il risultato di `0`, che disattiva la caratteristica. In questo caso, puoi utilizzare lo stesso gruppo di parametri per istanze di dimensioni diverse e per istanze che non utilizzano un archivio dell'istanza. Se modifichi questi parametri, assicurati di riavviare le istanze associate in modo che le modifiche abbiano effetto.
Se allochi spazio per uno spazio di tabella temporaneo, Amazon RDS non crea automaticamente lo spazio di tabella temporaneo. Per informazioni su come creare lo spazio di tabella temporaneo nell'archivio dell'istanza, consulta [Creazione di un tablespace temporaneo nell’archivio dell’istanza](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store).
Il valore combinato dei parametri precedenti non deve superare 10/10 o 100%. La tabella seguente illustra le impostazioni valide e non valide dei parametri.
| Impostazione db\$1flash\$1cache\$1size | Impostazione rds.instance\$1store\$1temp\$1size | Spiegazione |
| --- | --- | --- |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$10/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$110/10\$1 | Questa è una configurazione valida per tutte le edizioni di Oracle Database. Amazon RDS alloca il 100% dello spazio dell'archivio dell'istanza allo spazio di tabella temporaneo. Questa è l'impostazione predefinita. |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$110/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$10/10\$1 | Questa configurazione è valida solo per Oracle Database Enterprise Edition. Amazon RDS alloca il 100% dello spazio dell'archivio dell'istanza alla cache flash. |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$12/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$18/10\$1 | Questa configurazione è valida solo per Oracle Database Enterprise Edition. Amazon RDS alloca il 20% dello spazio dell'archivio dell'istanza alla cache flash e l'80% dello spazio dell'archivio dell'istanza allo spazio di tabella temporaneo. |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$16/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$14/10\$1 | Questa configurazione è valida solo per Oracle Database Enterprise Edition. Amazon RDS alloca il 60% dello spazio dell'archivio dell'istanza alla cache flash e il 40% dello spazio dell'archivio dell'istanza allo spazio di tabella temporaneo. |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$12/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$14/10\$1 | Questa configurazione è valida solo per Oracle Database Enterprise Edition. Amazon RDS alloca il 20% dello spazio dell'archivio dell'istanza alla cache flash e il 40% dello spazio dell'archivio dell'istanza allo spazio di tabella temporaneo. |
| db\$1flash\$1cache\$1size=\$1DBInstanceStore\$18/10\$1 | rds.instance\$1store\$1temp\$1size=\$1DBInstanceStore\$18/10\$1 | Questa configurazione non è valida perché la percentuale combinata di spazio dell'archivio dell'istanza supera il 100%. In questi casi, il tentativo di Amazon RDS non riesce. |
## Considerazioni sulla modifica del tipo di istanza database
La modifica del tipo di istanza database può influire sulla configurazione della cache flash o dello spazio di tabella temporaneo nell'archivio dell'istanza. Considera le seguenti modifiche e gli effetti:
**Aumento o riduzione dell'istanza database che supporta l'archivio dell'istanza.**
I seguenti valori aumentano o diminuiscono proporzionalmente alla nuova dimensione dell'archivio dell'istanza:
+ La nuova dimensione della cache flash.
+ Lo spazio allocato agli spazi di tabella temporanei che risiedono nell'archivio dell'istanza.
Ad esempio, l'impostazione `db_flash_cache_size={DBInstanceStore*6/10}` su un'istanza db.m5d.4xlarge fornisce circa 340 GB di spazio nella cache flash. Se aumenti il tipo di istanza a db.m5d.8xlarge, lo spazio della cache flash aumenta fino a circa 680 GB.
**Modifica di un'istanza database che non utilizza un archivio dell'istanza in un'istanza che ne utilizza uno.**
Se `db_flash_cache_size` è impostato su un valore maggiore di `0`, la cache flash è configurata. Se `rds.instance_store_temp_size` è impostato su un valore maggiore di `0`, lo spazio dell'archivio dell'istanza viene allocato per essere utilizzato da una spazio di tabella temporaneo. RDS per Oracle non sposta automaticamente i file temporanei nell'archivio dell'istanza. Per informazioni sull'utilizzo dello spazio allocato, consulta [Creazione di un tablespace temporaneo nell’archivio dell’istanza](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.creating-tts-instance-store) o [Aggiunta di un file temporaneo all'archivio dell'istanza in una replica di lettura](Appendix.Oracle.CommonDBATasks.using-tempfiles.md#Appendix.Oracle.CommonDBATasks.adding-tempfile-replica).
**Modifica di un'istanza database che utilizza un archivio dell'istanza in un'istanza che non ne utilizza uno.**
In questo caso, RDS per Oracle rimuove la cache flash. RDS ricrea il file temporaneo che si trova attualmente nell'archivio dell'istanza su un volume Amazon EBS. La dimensione massima del nuovo file temporaneo è la dimensione precedente del parametro `rds.instance_store_temp_size`.
# Utilizzo di un archivio dell'istanza in una replica di lettura Oracle
Le repliche di lettura supportano la cache flash e gli spazi di tabella temporanei in un archivio dell'istanza. Sebbene la cache flash funzioni allo stesso modo dell'istanza database primaria, nota le seguenti differenze per gli spazi di tabella temporanei:
+ Non è possibile creare uno spazio di tabella temporaneo in una replica di lettura. Se crei un nuovo spazio di tabella temporaneo sull'istanza primaria, RDS per Oracle replica le informazioni nello spazio di tabella senza file temporanei. Per aggiungere un nuovo file temporaneo, utilizza una delle seguenti tecniche:
+ Usa la procedura Amazon RDS `rdsadmin.rdsadmin_util.add_inst_store_tempfile`. RDS per Oracle crea un file temporaneo nell'archivio dell'istanza della replica di lettura e lo aggiunge alla spazio di tabella temporaneo specificato.
+ Esegui il comando `ALTER TABLESPACE … ADD TEMPFILE`. RDS per Oracle inserisce il file temporaneo nell'archivio Amazon EBS.
**Nota**
Le dimensioni dei file temporanei e i tipi di archivio possono essere diversi nell'istanza database primaria e nella replica di lettura.
+ È possibile gestire l'impostazione predefinita della spazio di tabella temporaneo solo nell'istanza database primaria. RDS per Oracle replica l'impostazione in tutte le repliche di lettura.
+ È possibile configurare i gruppi di spazi di tabella temporanei solo nell'istanza database primaria. RDS per Oracle replica l'impostazione in tutte le repliche di lettura.
# Configurazione di un gruppo di spazi di tabella temporanei in un archivio dell'istanza e in Amazon EBS
Puoi configurare un gruppo di spazi di tabella temporanei per includere spazi di tabella temporanei sia in un archivio dell'istanza che in Amazon EBS. Questa tecnica è utile quando si desidera uno spazio di archiviazione temporaneo superiore a quello consentita dall'impostazione massima di `rds.instance_store_temp_size`.
Quando configuri un gruppo di spazi di tabella temporanei in un archivio dell'istanza e in Amazon EBS, i due spazi di tabella hanno caratteristiche prestazionali significativamente diverse. Oracle Database sceglie lo spazio di tabella per servire le query in base a un algoritmo interno. Pertanto, query simili possono variare in termini di prestazioni.
In genere, si crea una spazio di tabella temporaneo nell'archivio dell'istanza come segue:
1. Crea una spazio di tabella temporaneo nell'archivio dell'istanza.
1. Imposta il nuovo spazio di tabella come spazio di tabella temporaneo predefinito del database.
Se la dimensione dello spazio di tabella nell'archivio dell'istanza è insufficiente, puoi creare uno spazio di archiviazione temporaneo aggiuntivo come segue:
1. Assegna lo spazio di tabella temporaneo nell'archivio dell'istanza a un gruppo di spazi di tabella temporanei.
1. Crea un nuovo spazio di tabella temporaneo in Amazon EBS se non ne esiste uno.
1. Assegna lo spazio di tabella temporaneo in Amazon EBS allo stesso gruppo di spazi di tabella che include lo spazio di tabella dell'archivio dell'istanza.
1. Imposta il gruppo di spazi di tabella come spazio di tabella temporaneo predefinito.
L'esempio seguente presuppone che la dimensione della spazio di tabella temporaneo nell'archivio dell'istanza non soddisfi i requisiti dell'applicazione. L'esempio crea lo spazio di tabella temporaneo `temp_in_inst_store` nell'archivio dell'istanza, lo assegna al gruppo di spazi di tabella `temp_group`, aggiunge lo spazio di tabella Amazon EBS esistente denominato `temp_in_ebs` a questo gruppo e imposta il gruppo come spazio di tabella temporaneo predefinito.
```
SQL> EXEC rdsadmin.rdsadmin_util.create_inst_store_tmp_tblspace('temp_in_inst_store');
PL/SQL procedure successfully completed.
SQL> ALTER TABLESPACE temp_in_inst_store TABLESPACE GROUP temp_group;
Tablespace altered.
SQL> ALTER TABLESPACE temp_in_ebs TABLESPACE GROUP temp_group;
Tablespace altered.
SQL> EXEC rdsadmin.rdsadmin_util.alter_default_temp_tablespace('temp_group');
PL/SQL procedure successfully completed.
SQL> SELECT * FROM DBA_TABLESPACE_GROUPS;
GROUP_NAME TABLESPACE_NAME
------------------------------ ------------------------------
TEMP_GROUP TEMP_IN_EBS
TEMP_GROUP TEMP_IN_INST_STORE
SQL> SELECT PROPERTY_VALUE FROM DATABASE_PROPERTIES WHERE PROPERTY_NAME='DEFAULT_TEMP_TABLESPACE';
PROPERTY_VALUE
--------------
TEMP_GROUP
```
## Rimozione di un archivio dell'istanza RDS per Oracle
Per rimuovere l'archivio dell'istanza, modifica l'istanza database RDS per Oracle per utilizzare un tipo di istanza che non supporta l'archivio dell'istanza, ad esempio db.m5 o db.r5.
# Attivazione di HugePages per un'istanza RDS per Oracle
Amazon RDS for Oracle supporta Huge Pages del kernel di Linux per una maggiore scalabilità del database. HugePages restituisce tabelle di pagina più piccole e meno tempo CPU dedicato alla gestione della memoria, migliorando così le prestazioni di istanze database di grosse dimensioni. Per ulteriori informazioni, consulta [Overview of HugePages](https://docs.oracle.com/database/121/UNXAR/appi_vlm.htm#UNXAR400) nella documentazione Oracle.
Puoi utilizzare HugePages con tutte le versioni e le edizioni supportate di RDS per Oracle.
Il parametro `use_large_pages` controlla se HugePages è attivato per un'istanza database. Le impostazioni possibili per questo parametro sono `ONLY`, `FALSE` e `{DBInstanceClassHugePagesDefault}`. Il parametro `use_large_pages` è impostato su `{DBInstanceClassHugePagesDefault}` nel gruppo di parametri database predefinito per Oracle.
Per controllare se HugePages viene attivato automaticamente per un'istanza database, puoi utilizzare la variabile di formula `DBInstanceClassHugePagesDefault` nei gruppi di parametri. Il valore è determinato nel modo seguente:
+ Per le classi di istanza database menzionate nella tabella seguente, `DBInstanceClassHugePagesDefault` restituisce sempre `FALSE` per impostazione predefinita e `use_large_pages` restituisce `FALSE`. Puoi attivare HugePages manualmente per queste classi di istanza database se la classe di istanza database dispone di almeno 14 GB di memoria.
+ Per le classi di istanza database non menzionate nella tabella seguente, se la classe dell'istanza database dispone di meno di 14 GiB di memoria, `DBInstanceClassHugePagesDefault` restituisce sempre `FALSE`. Inoltre, `use_large_pages` restituisce `FALSE`.
+ Per le classi di istanza database non menzionate nella tabella seguente, se la classe dell'istanza dispone di almeno di 14 GB e fino a 100 GB di memoria, `DBInstanceClassHugePagesDefault` restituisce `TRUE` per impostazione predefinita. Inoltre, `use_large_pages` restituisce `ONLY`. Puoi disattivare HugePages manualmente impostando `use_large_pages` su `FALSE`.
+ Per le classi di istanza database non menzionate nella tabella seguente, se la classe dell'istanza dispone di almeno 100 GiB di memoria, `DBInstanceClassHugePagesDefault` restituisce sempre `TRUE`. Inoltre, `use_large_pages` restituisce `ONLY` e HugePages non può essere disabilitato.
Per impostazione predefinita HugePages non è attivato per le seguenti classi di istanza database.
****
| Famiglia di classi di istanza database | Classi di istanza database con HugePages non attivato per impostazione predefinita. |
| --- | --- |
| db.m5 | db.m5.large |
| db.m4 | db.m4.large, db.m4.xlarge, db.m4.2xlarge, db.m4.4xlarge, db.m4.10xlarge |
| db.t3 | db.t3.micro, db.t3.small, db.t3.medium, db.t3.large |
Per altre informazioni sulle classi di istanza database, consulta [Specifiche hardware per le classi di istanze DB ](Concepts.DBInstanceClass.Summary.md).
Per attivare manualmente HugePages per le istanze database nuove o esistenti, imposta il parametro `use_large_pages` su `ONLY`. Non è possibile utilizzare Huge Pages con Automatic Memory Management (AMM) di Oracle. Se viene impostato il parametro `use_large_pages` su `ONLY`, è necessario anche impostare `memory_target` e `memory_max_target` su `0`. Per ulteriori informazioni sull'impostazione dei parametri database per l'istanza database, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
È possibile anche impostare i parametri `sga_target`, `sga_max_size` e `pga_aggregate_target`. Quando imposti i parametri di memoria della SGA (Area globale del sistema) e della PGA (Area globale del programma), aggiungi i valori insieme. Sottrai questo totale dalla memoria di istanza disponibile (`DBInstanceClassMemory`) per determinare la memoria libera al di là dell'allocazione Huge Pages. È necessario lasciare almeno 2 GiB di memoria libera o 10% del totale della memoria di istanza disponibile, scegliendo la più piccola.
Dopo aver configurato i parametri, è necessario riavviare la tua istanza database per rendere effettive le modifiche. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
**Nota**
L'istanza di Oracle DB rinvia le modifiche ai parametri di inizializzazione relativi a SGA fino al riavvio dell'istanza senza failover. Nella console Amazon RDS scegliere **Riavvia** ma *non* scegliere **Riavvia con failover**. In AWS CLI, chiamare il comando `reboot-db-instance` con il parametro `--no-force-failover`. L'istanza database non elabora i parametri relativi a SGA durante il failover o durante altre operazioni di manutenzione che causano il riavvio dell'istanza.
Di seguito trovi una configurazione di esempio di parametri per Huge Pages che abilita manualmente Huge Pages. È necessario impostare i valori per soddisfare le esigenze specifiche.
```
1. memory_target = 0
2. memory_max_target = 0
3. pga_aggregate_target = {DBInstanceClassMemory*1/8}
4. sga_target = {DBInstanceClassMemory*3/4}
5. sga_max_size = {DBInstanceClassMemory*3/4}
6. use_large_pages = ONLY
```
Supponi che i seguenti valori dei parametri siano impostati in un gruppo di parametri.
```
1. memory_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
2. memory_max_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
3. pga_aggregate_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*1/8}, 0)
4. sga_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
5. sga_max_size = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
6. use_large_pages = {DBInstanceClassHugePagesDefault}
```
Il gruppo di parametri viene utilizzato da una classe di istanza database db.r4 con meno di 100 GiB di memoria. Con queste impostazioni di parametri e `use_large_pages` impostato su `{DBInstanceClassHugePagesDefault}`, HugePages viene attivato per l'istanza db.r4.
Valuta un altro esempio con i seguenti valori dei parametri impostati in un gruppo di parametri.
```
1. memory_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
2. memory_max_target = IF({DBInstanceClassHugePagesDefault}, 0, {DBInstanceClassMemory*3/4})
3. pga_aggregate_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*1/8}, 0)
4. sga_target = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
5. sga_max_size = IF({DBInstanceClassHugePagesDefault}, {DBInstanceClassMemory*3/4}, 0)
6. use_large_pages = FALSE
```
Il gruppo di parametri è utilizzato da una classe di istanze database db.r4 e una classe di istanza database db.r5 con meno di 100 GiB di memoria. Con queste impostazioni di parametri, HugePages viene disattivato nelle istanze db.r4 e db.r5.
**Nota**
Se questo gruppo di parametri è utilizzato da una classe di istanza database db.r4 o una classe di istanza database db.r5 con almeno 100 GiB di memoria, l'impostazione `FALSE` per `use_large_pages` è sovrascritta e impostata su `ONLY`. In questo caso, viene inviata una notifica al cliente a proposito della sostituzione.
Dopo che Huge Pages è attivo sull'istanza database, puoi visualizzare l'informazione su Huge Pages abilitando il monitoraggio avanzato. Per ulteriori informazioni, consulta [Monitoraggio dei parametri del sistema operativo con il monitoraggio avanzato](USER_Monitoring.OS.md).
# Attivazione dei tipi di dati estesi in RDS per Oracle
Amazon RDS per Oracle supporta i tipi di dati estesi. Con i tipi di dati estesi, le dimensioni massime per i tipi di dati `VARCHAR2`, `NVARCHAR2` e `RAW` sono di 32.767 byte. Per utilizzare i tipi di dati estesi, imposta il parametro `MAX_STRING_SIZE` su `EXTENDED`. Per ulteriori informazioni, consulta la pagina sui [tipi di dati estesi](https://docs.oracle.com/database/121/SQLRF/sql_elements001.htm#SQLRF55623) nella documentazione Oracle.
Se non desideri utilizzare i tipi di dati estesi, mantieni il parametro `MAX_STRING_SIZE` impostato su `STANDARD` (impostazione predefinita). In questo caso, i limiti di dimensione sono di 4.000 byte per i tipi di dati `VARCHAR2` e `NVARCHAR2` e 2.000 byte per il tipo di dati RAW.
Puoi attivare i tipi di dati estesi nelle istanze database nuove o esistenti. Per le nuove istanze database, il tempo di creazione di un'istanza database è in genere più lungo quando i tipi di dati estesi sono attivati. Per le istanze database esistenti, l'istanza database non può essere utilizzata durante il processo di conversione.
## Considerazioni sui tipi di dati estesi
Considera quanto segue quando abiliti i tipi di dati estesi per la tua istanza database:
+ Quando si attivano i tipi di dati estesi per un’istanza database nuova o esistente, è necessario riavviare l’istanza per rendere effettiva la modifica.
+ Dopo l’attivazione dei tipi di dati estesi, non è possibile ripristinare l’utilizzo delle dimensioni standard per i tipi di dati nell’istanza database. Se si reimposta il parametro `MAX_STRING_SIZE` su `STANDARD`, viene restituito lo stato `incompatible-parameters`.
+ Quando si ripristina un'istanza database che utilizza i tipi di dati estesi, è necessario specificare un gruppo di parametri con il parametro `MAX_STRING_SIZE` impostato su `EXTENDED`. Durante il ripristino, se si specifica il gruppo di parametri predefinito o altri gruppi di parametri con `MAX_STRING_SIZE` impostato su `STANDARD`, viene restituito lo stato `incompatible-parameters`.
+ Quando lo stato dell'istanza database è `incompatible-parameters` a causa dell'impostazione `MAX_STRING_SIZE`, l'istanza database resta non disponibile finché non si imposta il parametro `MAX_STRING_SIZE` su `EXTENDED` e non si riavvia l'istanza.
## Attivazione dei tipi di dati estesi per una nuova istanza database
Quando crei un’istanza database con il parametro `MAX_STRING_SIZE` impostato su `EXTENDED`, l’istanza mostra `MAX_STRING_SIZE` impostato sul valore `STANDARD` predefinito. Riavvia l’istanza per abilitare la modifica.
**Per attivare i tipi di dati estesi per una nuova istanza database**
1. Impostare il parametro `MAX_STRING_SIZE` su `EXTENDED` in un gruppo di parametri.
Per impostare il parametro, creare un nuovo gruppo di parametri o modificarne uno esistente.
Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Crea una nuova istanza database RDS per Oracle
Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
1. Associa il gruppo di parametri con `MAX_STRING_SIZE` impostato su `EXTENDED` all'istanza database.
Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
1. Riavviare l'istanza database per applicare la modifica al parametro.
Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
## Attivazione dei tipi di dati estesi per un'istanza database esistente
Dopo aver modificato un'istanza database in modo da attivare i tipi di dati estesi, RDS converte i dati nel database in modo che vengano utilizzate le dimensioni estese. La conversione e il tempo di inattività si verificano al successivo riavvio del database dopo la modifica del parametro. L'istanza database non è disponibile durante la conversione.
La durata dell'operazione dipende dalla classe di istanza database utilizzata dall'istanza database e dalle dimensioni del database. Per ridurre i tempi di inattività, prendi in considerazione la possibilità di creare un'istantanea immediatamente prima del riavvio. In questo modo si riduce la durata del backup durante il flusso di lavoro di conversione.
**Nota**
Dopo aver attivato i tipi di dati estesi, non puoi eseguire un point-in-time ripristino a un periodo durante la conversione. Questo ripristino può essere effettuato subito prima o dopo la conversione.
**Per attivare i tipi di dati estesi per un'istanza database esistente**
1. Acquisire uno snapshot del database
Se nel database sono presenti oggetti non validi, Amazon RDS prova a ricompilarli. La conversione ai tipi di dati estesi può non riuscire se Amazon RDS non riesce a ricompilare un oggetto non valido. La snapshot consente di ripristinare il database in caso di problemi con la conversione. Controllare sempre la presenza di oggetti non validi prima della conversione e, se ci sono, correggerli o eliminarli. Per i database di produzione, consigliamo di provare il processo di conversione prima su una copia dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
1. Impostare il parametro `MAX_STRING_SIZE` su `EXTENDED` in un gruppo di parametri.
Per impostare il parametro, creare un nuovo gruppo di parametri o modificarne uno esistente.
Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md).
1. Modificare l'istanza database per associarla al gruppo di parametri con `MAX_STRING_SIZE` impostato su `EXTENDED`.
Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
1. Riavviare l'istanza database per applicare la modifica al parametro.
Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
# Importazione di dati in Oracle in Amazon RDS
La modalità di importazione dei dati in un'istanza database Amazon RDS per Oracle dipende da quanto segue:
+ La quantità di dati disponibili
+ Il numero di oggetti di database esistenti nel database
+ La varietà di oggetti di database esistenti nel database
Ad esempio, puoi usare i seguenti strumenti, a seconda delle esigenze:
+ Oracle SQL Developer: importazione di un database semplice da 20 MB.
+ Oracle Data Pump: importazione di database complessi o database con dimensioni di diverse centinaia di megabyte o diversi terabyte. Ad esempio, è possibile trasportare tablespace da un database on-premise all'istanza database RDS per Oracle. È possibile usare Amazon S3 o Amazon EFS per trasferire i file di dati e i metadati. Per ulteriori informazioni, consulta [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md), [Integrazione Amazon EFS](oracle-efs-integration.md) e [Integrazione Amazon S3](oracle-s3-integration.md).
+ AWS Database Migration Service (AWS DMS): migrazione dei database senza tempi di inattività. Per ulteriori informazioni su AWS DMS, consulta [Che cos'è AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) e il post del blog [Migrazione di database Oracle con tempi di inattività quasi zero utilizzando AWS DMS](https://aws.amazon.com/blogs/database/migrating-oracle-databases-with-near-zero-downtime-using-aws-dms/).
**Importante**
Prima di utilizzare le tecniche di migrazione precedentemente descritte, è consigliabile eseguire il backup del database. Dopo avere importato i dati, puoi eseguire il backup delle istanze database RDS per Oracle creando snapshot. Successivamente, è possibile ripristinare gli snapshot. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
Per molti motori di database, la replica continua può continuare fino a quando non si è pronti per passare al database di destinazione. È possibile utilizzare AWS DMS per eseguire la migrazione a RDS per Oracle dallo stesso motore di database o da un motore diverso. Se esegui la migrazione da un motore di database diverso, puoi utilizzare AWS Schema Conversion Tool per la migrazione degli oggetti dello schema non migrati da AWS DMS.
**Topics**
+ [Importazione utilizzando Oracle SQL Developer](Oracle.Procedural.Importing.SQLDeveloper.md)
+ [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md)
+ [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md)
+ [Importazione con le utilità Oracle di esportazione/importazione](Oracle.Procedural.Importing.ExportImport.md)
+ [Importazione utilizzando Oracle SQL\$1Loader](Oracle.Procedural.Importing.SQLLoader.md)
+ [Migrazione con le viste materializzate Oracle](Oracle.Procedural.Importing.Materialized.md)
# Importazione utilizzando Oracle SQL Developer
Oracle SQL Developer è uno strumento Java grafico distribuito gratuitamente da Oracle. SQL Developer fornisce opzioni per la migrazione dei dati tra due database Oracle oppure per la migrazione dei dati da altri database, come MySQL, a Oracle. Questo strumento è ideale per la migrazione di database di piccole dimensioni.
Puoi installare questo strumento nel computer desktop (Windows, Linux o Mac) o in uno dei server. Dopo avere installato SQL Developer, puoi utilizzarlo per connetterti ai database di origine e di destinazione. Utilizza il comando **Database Copy** del menu Tools per copiare i dati nell’istanza database RDS per Oracle.
Per scaricare SQL Developer, vai alla pagina [http://www.oracle.com/technetwork/developer-tools/sql-developer](http://www.oracle.com/technetwork/developer-tools/sql-developer).
Prima di iniziare la migrazione dei dati, è consigliabile leggere la documentazione di Oracle SQL Developer. Oracle fornisce anche la documentazione relativa alla migrazione da altri database, tra cui MySQL e SQL Server. Per ulteriori informazioni, consulta [http://www.oracle.com/technetwork/database/migration](http://www.oracle.com/technetwork/database/migration) nella documentazione di Oracle.
# Migrazione utilizzando le tablespace trasportabili Oracle
È possibile utilizzare la funzionalità Oracle Tablespace trasportabile per copiare un set di tablespace da un database Oracle on-premise a un'istanza RDS per Oracle DB. A livello fisico, trasferisci file di dati e metadati di origine nell’istanza database di destinazione utilizzando Amazon EFS o Amazon S3. La funzionalità relativa ai tablespace trasportabili utilizza il pacchetto `rdsadmin.rdsadmin_transport_util`. Per la sintassi e la semantica di questo pacchetto, consulta [Trasporto di tablespace](rdsadmin_transport_util.md).
Per i post di blog che spiegano come trasportare le tablespace, consulta [Migrare i database Oracle verso l'utilizzo di tablespace trasportabili e [Amazon RDS for Oracle Transportable Tablespaces AWS usando RMAN](https://aws.amazon.com/blogs/database/amazon-rds-for-oracle-transportable-tablespaces-using-rman/)](https://aws.amazon.com/blogs/database/migrate-oracle-databases-to-aws-using-transportable-tablespace/).
**Topics**
+ [Panoramica delle tablespace trasportabili Oracle](#oracle-migrating-tts.overview)
+ [Fase 1: configurazione dell'host di origine](#oracle-migrating-tts.setup-phase)
+ [Fase 2: preparazione del backup completo delle tablespace](#oracle-migrating-tts.initial-br-phase)
+ [Fase 3: creazione e trasferimento dei backup incrementali](#oracle-migrating-tts.roll-forward-phase)
+ [Fase 4: trasporto delle tablespace](#oracle-migrating-tts.final-br-phase)
+ [Fase 5: convalida delle tablespace trasportate](#oracle-migrating-tts.validate)
+ [Fase 6: rimozione dei file residui](#oracle-migrating-tts.cleanup)
## Panoramica delle tablespace trasportabili Oracle
Un set di tablespace trasportabili è composto da file di dati per il set di tablespace da trasportare e da un file di dump di esportazione contenente i metadati delle tablespace. In una soluzione di migrazione fisica come le tablespace trasportabili, si trasferiscono file fisici, ovvero file di dati, file di configurazione e file di dump di Data Pump.
**Topics**
+ [Vantaggi e svantaggi delle tablespace trasportabili](#oracle-migrating-tts.overview.benefits)
+ [Limitazioni relative alle tablespace trasportabili](#oracle-migrating-tts.limitations)
+ [Prerequisiti per le tablespace trasportabili](#oracle-migrating-tts.requirements)
### Vantaggi e svantaggi delle tablespace trasportabili
Si consiglia di utilizzare tablespace trasportabili quando è necessario eseguire la migrazione di una o più tablespace di grandi dimensioni su RDS con tempi di inattività minimi. Rispetto alla migrazione logica, le tablespace trasportabili offrono i seguenti vantaggi:
+ I tempi di inattività sono inferiori rispetto alla maggior parte delle altre soluzioni di migrazione Oracle.
+ Poiché la funzionalità Tablespace trasportabile copia solo i file fisici, vengono evitati gli errori di integrità dei dati e il danneggiamento logico che si possono verificare nella migrazione logica.
+ Non è richiesta alcuna licenza aggiuntiva.
+ È possibile eseguire la migrazione di un set di tablespace su diverse piattaforme e tipi di endianità, ad esempio, da una piattaforma Oracle Solaris a Linux. Tuttavia, il trasporto di tablespace da e verso i server Windows non è supportato.
**Nota**
Linux è completamente testato e supportato. Non tutte le varianti di UNIX sono state testate.
Se vengono utilizzate tablespace trasportabili, è possibile trasportare i dati utilizzando Amazon S3 o Amazon EFS:
+ In caso di utilizzo di EFS, i backup rimangono nel file system EFS per tutta la durata dell'importazione. È possibile rimuovere i file in seguito. Con questa tecnica, non è necessario effettuare il provisioning dello spazio di archiviazione EBS per l'istanza database. Per questo motivo, è consigliabile utilizzare Amazon EFS anziché S3. Per ulteriori informazioni, consulta [Integrazione Amazon EFS](oracle-efs-integration.md).
+ In caso di utilizzo di S3, è sufficiente scaricare i backup RMAN nello spazio di archiviazione EBS associato all'istanza database. I file rimangono nello spazio di archiviazione EBS durante l'importazione. Dopo l'importazione, è possibile liberare questo spazio, che rimane allocato all'istanza database.
Lo svantaggio principale delle tablespace trasportabili è dato dal fatto che è necessaria una conoscenza relativamente avanzata del database Oracle. Per ulteriori informazioni, consulta l'argomento relativo al [trasporto delle tablespace tra database](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-F7B2B591-AA88-4D16-8DCF-712763923FFB) nel manuale *Oracle Database Administrator's Guide* (Guida per gli amministratori di Oracle Database).
### Limitazioni relative alle tablespace trasportabili
Le limitazioni di Oracle Database per le tablespace trasportabili si applicano se si utilizza questa funzionalità in RDS per Oracle. Per ulteriori informazioni, consulta l'argomento relativo alle [limitazioni delle tablespace trasportabili]( https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-DAB51E42-9BBC-4001-B5CB-0ECDBE128787) e alle [limitazioni generali relative al trasporto dei dati](https://docs.oracle.com/en/database/oracle/oracle-database/19/admin/transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) nel manuale *Oracle Database Administrator's Guide*. È opportuno considerare le seguenti limitazioni aggiuntive per le tablespace trasportabili in RDS per Oracle:
+ Né il database di origine né quello di destinazione possono utilizzare Standard Edition 2 (). SE2 È supportata solo la versione Enterprise Edition.
+ Non è possibile utilizzare un database Oracle Database 11g come origine. La funzionalità di tablespace trasportabili multipiattaforma di RMAN si basa sul meccanismo di trasporto RMAN, che non è supportato da Oracle Database 11g.
+ Non è possibile eseguire la migrazione dei dati da un'istanza database RDS per Oracle utilizzando le tablespace trasportabili. È possibile utilizzare solo tablespace trasportabili per eseguire la migrazione dei dati su un'istanza database RDS per Oracle.
+ Il sistema operativo Windows non è supportato.
+ Non è possibile effettuare il trasporto delle tablespace in un database di una versione inferiore. Il database di destinazione deve essere della stessa versione o di una versione successiva rispetto al database di origine. Ad esempio, non è possibile effettuare il trasporto delle tablespace da Oracle Database 21c a Oracle Database 19c.
+ Non è possibile effettuare il trasporto delle tablespace amministrative, ad esempio `SYSTEM` e `SYSAUX`.
+ Non è possibile trasportare oggetti non contenenti dati come PL/SQL pacchetti, classi Java, viste, trigger, sequenze, utenti, ruoli e tabelle temporanee. Per trasportare oggetti non contenenti dati, creali manualmente o utilizza la funzionalità di esportazione e importazione dei metadati di Data Pump. Per ulteriori informazioni, consulta il [documento 1454872.1 di My Oracle Support](https://support.oracle.com/knowledge/Oracle%20Cloud/1454872_1.html).
+ Non è possibile effettuare il trasporto di tablespace crittografate o utilizzare colonne crittografate.
+ In caso di trasferimento di file utilizzando Amazon S3, la dimensione massima supportata è di 5 TiB.
+ Se il database di origine utilizza opzioni Oracle come Spatial (Spaziale), non è possibile effettuare il trasporto delle tablespace a meno che le stesse opzioni non siano configurate anche nel database di destinazione.
+ Non è possibile effettuare il trasporto delle tablespace in un'istanza database RDS per Oracle in una configurazione di replica Oracle. Come soluzione alternativa, è possibile eliminare tutte le repliche, effettuare il trasporto delle tablespace e quindi ricreare le repliche.
### Prerequisiti per le tablespace trasportabili
Prima di iniziare, completa le seguenti attività:
+ Fare riferimento ai requisiti per le tablespace trasportabili descritti nei seguenti documenti in My Oracle Support:
+ [Reduce Transportable Tablespace Downtime using Cross Platform Incremental Backup (Doc ID 2471245.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (Riduzione dei tempi di inattività delle tablespace trasportabili utilizzando il backup incrementale multipiattaforma [ID documento 2471245.1])
+ [Transportable Tablespace (TTS) Restrictions and Limitations: Details, Reference, and Version Where Applicable (Doc ID 1454872.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454872.1) (Restrizioni e limitazioni relative alle tablespace trasportabili (TTS): dettagli, riferimento e versione laddove applicabile [ID documento 1454872.1])
+ [Primary Note for Transportable Tablespaces (TTS) – Common Questions and Issues (Doc ID 1166564.1)](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1166564.1) (Nota principale per le tablespace trasportabili (TTS) – Domande e problemi comuni [ID documento 1166564.1])
+ Piano per la conversione endianness. Se specifichi l'ID della piattaforma di origine, RDS per Oracle converte automaticamente l'endianness. Per informazioni su come trovare la piattaforma IDs, consulta [Data Guard Support per standby primari e fisici eterogenei nella stessa configurazione Data Guard (](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)ID doc 413484.1).
+ Assicurarsi che la funzionalità Tablespace trasportabile sia abilitata nell'istanza database di destinazione. La funzionalità è abilitata solo se non vengono visualizzati errori `ORA-20304` quando si esegue la seguente query:
```
SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
```
Se la funzionalità Tablespace trasportabile non è abilitata, riavviare l'istanza database. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
+ Assicurati che il file di fuso orario corrisponda al database di origine e destinazione.
+ Assicurati che i set di caratteri del database di origine e di quello di destinazione soddisfino uno dei seguenti requisiti:
+ I set di caratteri sono gli stessi.
+ I set di caratteri sono compatibili. Per un elenco dei requisiti di compatibilità, consulta [General Limitations on Transporting Data](https://docs.oracle.com/en/database/oracle/oracle-database/19/spmdu/general-limitations-on-transporting-data.html#GUID-28800719-6CB9-4A71-95DD-4B61AA603173) nella documentazione di Oracle Database.
+ Se si prevede di trasferire file utilizzando Amazon S3, procedere come segue:
+ Assicurati che sia disponibile un bucket Amazon S3 per i trasferimenti di file e che il bucket Amazon S3 si trovi nella stessa AWS regione dell'istanza DB. Per istruzioni, consultare [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella *Guida introduttiva di Amazon Simple Storage Service*.
+ Preparare il bucket Amazon S3 per l'integrazione con Amazon RDS seguendo le istruzioni in [Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3](oracle-s3-integration.preparing.md).
+ Se si prevede di trasferire file utilizzando Amazon EFS, assicurarsi di aver configurato EFS secondo le istruzioni riportate in [Integrazione Amazon EFS](oracle-efs-integration.md).
+ È vivamente consigliabile di attivare i backup automatici nell'istanza database di destinazione. Poiché la [fase di importazione dei metadati](#oracle-migrating-tts.transport.import-dmp) può potenzialmente non riuscire, è importante poter ripristinare lo stato dell'istanza database precedente all'importazione, evitando così la necessità di eseguire nuovamente il backup, il trasferimento e l'importazione delle tablespace.
## Fase 1: configurazione dell'host di origine
In questo passaggio, si copiano gli script delle tablespace di trasporto forniti da My Oracle Support e si impostano i file di configurazione necessari. Nei passaggi seguenti, l'*host di origine* esegue il database contenente le tablespace da trasportare nell'*istanza di destinazione*.
**Configurazione dell'host di origine**
1. Accedere all'host di origine come proprietario della Oracle home.
1. Assicurarsi che le variabili di ambiente `ORACLE_HOME` e `ORACLE_SID` puntino al database di origine.
1. Accedere al database come amministratore e verificare che la versione del fuso orario, il set di caratteri del database e il set di caratteri nazionali siano gli stessi del database di destinazione.
```
SELECT * FROM V$TIMEZONE_FILE;
SELECT * FROM NLS_DATABASE_PARAMETERS
WHERE PARAMETER IN ('NLS_CHARACTERSET','NLS_NCHAR_CHARACTERSET');
```
1. Configurare l'utilità Tablespace trasportabile come descritto in [Oracle Support note 2471245.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2471245.1) (Nota del Supporto Oracle 2471245.1).
La configurazione include la modifica del file `xtt.properties` sull'host di origine. Il file `xtt.properties` di esempio seguente specifica i backup delle tre tablespace nella directory `/dsk1/backups`. Si tratta delle tablespace da trasportare nell'istanza database di destinazione. Specifica inoltre l'ID della piattaforma di origine per convertire automaticamente l'endiannes.
**Nota**
Per una piattaforma valida IDs, consulta [Data Guard Support per standby primari e fisici eterogenei nella stessa configurazione Data Guard (](https://support.oracle.com/epmos/faces/DocumentDisplay?id=413484.1)ID doc 413484.1).
```
#linux system
platformid=13
#list of tablespaces to transport
tablespaces=TBS1,TBS2,TBS3
#location where backup will be generated
src_scratch_location=/dsk1/backups
#RMAN command for performing backup
usermantransport=1
```
## Fase 2: preparazione del backup completo delle tablespace
In questa fase, si esegue il backup delle tablespace per la prima volta, si trasferiscono i backup sull'host di destinazione e quindi li si ripristina utilizzando la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Dopo aver completato questa fase, i backup iniziali delle tablespace si trovano nell'istanza database di destinazione e possono essere aggiornati mediante backup incrementali.
**Topics**
+ [Passaggio 1: esecuzione del backup delle tablespace sull'host di origine](#oracle-migrating-tts.backup-full)
+ [Passaggio 2: trasferimento dei file di backup nell'istanza database di destinazione](#oracle-migrating-tts.transfer-full)
+ [Passaggio 3: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.initial-tts-import)
### Passaggio 1: esecuzione del backup delle tablespace sull'host di origine
In questo passaggio, si utilizza lo script `xttdriver.pl` per eseguire un backup completo delle tablespace. L'output di `xttdriver.pl` è archiviato nella variabile di ambiente `TMPDIR`.
**Esecuzione del backup delle tablespace**
1. Se i tablespace sono in modalità di sola lettura, accedi al database di origine come utente con il privilegio e imposta i tablespace in modalità. `ALTER TABLESPACE` read/write Altrimenti, passare alla fase successiva.
L'esempio seguente posiziona e in modalità. `tbs1` `tbs2` `tbs3` read/write
```
ALTER TABLESPACE tbs1 READ WRITE;
ALTER TABLESPACE tbs2 READ WRITE;
ALTER TABLESPACE tbs3 READ WRITE;
```
1. Eseguire il backup delle tablespace utilizzando lo script `xttdriver.pl`. Facoltativamente, è possibile specificare `--debug` per eseguire lo script in modalità di debug.
```
export TMPDIR=location_of_log_files
cd location_of_xttdriver.pl
$ORACLE_HOME/perl/bin/perl xttdriver.pl --backup
```
### Passaggio 2: trasferimento dei file di backup nell'istanza database di destinazione
In questo passaggio, vengono copiati i file di backup e la configurazione dalla posizione temporanea all'istanza database di destinazione. Scegli una delle seguenti opzioni:
+ Se gli host di origine e di destinazione condividono un file system Amazon EFS, utilizzare un'utilità del sistema operativo, ad esempio `cp`, per copiare i file di backup e il file `res.txt` dalla posizione temporanea in una directory condivisa. Quindi passa a [Passaggio 3: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.initial-tts-import).
+ Se è necessario preparare i backup in un bucket Amazon S3, completare i seguenti passaggi.
![\[Trasferire i file utilizzando Amazon S3 o Amazon EFS.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-tts.png)
#### Passaggio 2.2: caricamento dei backup nel bucket Amazon S3
Caricare i backup e il file `res.txt` dalla cartella temporanea al bucket Amazon S3. Per ulteriori informazioni, consulta [Caricamento degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
#### Passaggio 2.3: scaricamento dei backup dal bucket Amazon S3 all'istanza database di destinazione
In questo passaggio, si utilizza la procedura `rdsadmin.rdsadmin_s3_tasks.download_from_s3` per scaricare i backup nell'istanza database RDS per Oracle.
**Scaricamento dei backup dal bucket Amazon S3**
1. Avviare SQL\$1Plus o Oracle SQL Developer e accedere all'istanza database RDS per Oracle.
1. Scaricare i backup dal bucket Amazon S3 nell'istanza database di destinazione utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3` su d. L'esempio seguente illustra come scaricare tutti i file da un bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'res.txt');
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Download di file da un bucket Amazon S3 a un'istanza database Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Passaggio 3: importazione delle tablespace nell'istanza database di destinazione
Per ripristinare i tablespace nell’istanza database di destinazione utilizza la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`. Questa procedura converte automaticamente i file di dati nel formato endian corretto.
Se esegui l’importazione da una piattaforma diversa da Linux, specifica la piattaforma di origine utilizzando il parametro `p_platform_id` quando chiami `import_xtts_tablespaces`. Assicurati che l’ID specificato corrisponda a quello presente nel file `xtt.properties` in [Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine](#oracle-migrating-tts.transport.export).
**Importazione delle tablespace nell'istanza database di destinazione**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Eseguire la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, specificando le tablespace da importare e la directory contenente i backup.
L'esempio seguente importa le tablespace *TBS1* e *TBS3* dalla directory. *TBS2* *DATA\$1PUMP\$1DIR* La piattaforma di origine è AIX-Based Systems (64 bit), identificata dall’ID `6`. È possibile trovare la piattaforma IDs eseguendo una query. `V$TRANSPORTABLE_PLATFORM`
```
VAR task_id CLOB
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces(
'TBS1,TBS2,TBS3',
'DATA_PUMP_DIR',
p_platform_id => 6);
END;
/
PRINT task_id
```
1. (Facoltativo) Monitorare l'avanzamento eseguendo una query sulla tabella `rdsadmin.rds_xtts_operation_info`. La colonna `xtts_operation_state` mostra il valore `EXECUTING`, `COMPLETED` o`FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Nota**
Per operazioni con tempi di esecuzione lunghi, è anche possibile eseguire una query su `V$SESSION_LONGOPS` `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Visualizzare il log dell'importazione completata utilizzando l'ID attività del passaggio precedente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assicurarsi che l'importazione sia stata completata correttamente prima di passare alla fase successiva.
## Fase 3: creazione e trasferimento dei backup incrementali
In questa fase, si effettuano e si trasferiscono periodicamente backup incrementali mentre il database di origine è attivo. Questa tecnica riduce le dimensioni del backup finale delle tablespace. Se vengono eseguiti più backup incrementali, è necessario copiare il file `res.txt` dopo l'ultimo backup incrementale prima di poterlo applicare all'istanza di destinazione.
I passaggi sono gli stessi di quelli indicati in [Fase 2: preparazione del backup completo delle tablespace](#oracle-migrating-tts.initial-br-phase), tranne per il fatto che il passaggio di importazione è facoltativo.
## Fase 4: trasporto delle tablespace
In questa fase, si esegue il backup delle tablespace di sola lettura e si esportano i metadati di Data Pump, questi file vengono quindi trasferiti nell'host di destinazione e infine vengono importati sia le tablespace che i metadati.
**Topics**
+ [Passaggio 1: esecuzione del backup delle tablespace di sola lettura](#oracle-migrating-tts.final-backup)
+ [Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine](#oracle-migrating-tts.transport.export)
+ [Passaggio 3: (solo Amazon S3) trasferimento dei file di backup ed esportazione nell'istanza database di destinazione](#oracle-migrating-tts.transport)
+ [Passaggio 4: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.restore-full)
+ [Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.transport.import-dmp)
### Passaggio 1: esecuzione del backup delle tablespace di sola lettura
Questo passaggio è identico a [Passaggio 1: esecuzione del backup delle tablespace sull'host di origine](#oracle-migrating-tts.backup-full), con una differenza fondamentale: le tablespace vengono impostate sulla modalità di sola lettura prima di eseguirne il backup per l'ultima volta.
L'esempio seguente imposta `tbs1`, `tbs2` e `tbs3` sulla modalità di sola lettura.
```
ALTER TABLESPACE tbs1 READ ONLY;
ALTER TABLESPACE tbs2 READ ONLY;
ALTER TABLESPACE tbs3 READ ONLY;
```
### Passaggio 2: esportazione dei metadati delle tablespace nell'host di origine
Esportare i metadati delle tablespace eseguendo l'utilità `expdb` nell'host di origine. L'esempio seguente esporta i tablespace e *TBS1* scarica *TBS2* il file nella *TBS3* directory. *xttdump.dmp* *DATA\$1PUMP\$1DIR*
```
expdp username/pwd \
dumpfile=xttdump.dmp \
directory=DATA_PUMP_DIR \
statistics=NONE \
transport_tablespaces=TBS1,TBS2,TBS3 \
transport_full_check=y \
logfile=tts_export.log
```
Se *DATA\$1PUMP\$1DIR* è una directory condivisa in Amazon EFS, passa a[Passaggio 4: importazione delle tablespace nell'istanza database di destinazione](#oracle-migrating-tts.restore-full).
### Passaggio 3: (solo Amazon S3) trasferimento dei file di backup ed esportazione nell'istanza database di destinazione
Se si utilizza Amazon S3 per preparare i backup delle tablespace e il file di esportazione di Data Pump, completare i seguenti passaggi.
#### Passaggio 3.1: caricamento dei backup e del file di dump dall'host di origine al bucket Amazon S3
Caricare i file di backup e i file di dump dall'host di origine al bucket Amazon S3. Per ulteriori informazioni, consulta [Caricamento degli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
#### Passaggio 3.2: scaricamento dei backup e del file di dump dal bucket Amazon S3 all'istanza database di destinazione
In questo passaggio, si utilizza la procedura `rdsadmin.rdsadmin_s3_tasks.download_from_s3` per scaricare i backup e il file di dump nell'istanza database RDS per Oracle. Segui la procedura riportata in [Passaggio 2.3: scaricamento dei backup dal bucket Amazon S3 all'istanza database di destinazione](#oracle-migrating-tts.download-full).
### Passaggio 4: importazione delle tablespace nell'istanza database di destinazione
Utilizzare la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces` per ripristinare le tablespace. Per la sintassi e la semantica di questa procedura, consulta [Importazione di tablespace trasportate nell'istanza database](rdsadmin_transport_util_import_xtts_tablespaces.md)
**Importante**
Dopo aver completato l'importazione finale delle tablespace, il passaggio successivo prevede l'[importazione dei metadati di Oracle Data Pump](#oracle-migrating-tts.transport.export). Se l'importazione non riesce, è importante ripristinare lo stato dell'istanza database precedente all'errore. Pertanto, è consigliabile creare uno snapshot DB dell'istanza database seguendo le istruzioni riportate in [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md). Lo snapshot conterrà tutte le tablespace importate. Pertanto, se l'importazione non riesce, non sarà necessario ripetere il processo di backup e importazione.
Se per l'istanza database di destinazione sono stati abilitati i backup automatici e Amazon RDS non rileva che è stato eseguito uno snapshot valido prima dell'importazione dei metadati, RDS tenta di creare uno snapshot. A seconda dell'attività dell'istanza, questo snapshot potrebbe riuscire o meno. Se non viene rilevato uno snapshot valido o non è possibile avviarne uno, l'importazione dei metadati viene terminata con errori.
**Importazione delle tablespace nell'istanza database di destinazione**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Eseguire la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces`, specificando le tablespace da importare e la directory contenente i backup.
L'esempio seguente importa i tablespace *TBS1* e *TBS3* dalla *TBS2* directory. *DATA\$1PUMP\$1DIR*
```
BEGIN
:task_id:=rdsadmin.rdsadmin_transport_util.import_xtts_tablespaces('TBS1,TBS2,TBS3','DATA_PUMP_DIR');
END;
/
PRINT task_id
```
1. (Facoltativo) Monitorare l'avanzamento eseguendo una query sulla tabella `rdsadmin.rds_xtts_operation_info`. La colonna `xtts_operation_state` mostra il valore `EXECUTING`, `COMPLETED` o`FAILED`.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
**Nota**
Per operazioni con tempi di esecuzione lunghi, è anche possibile eseguire una query su `V$SESSION_LONGOPS` `V$RMAN_STATUS` e `V$RMAN_OUTPUT`.
1. Visualizzare il log dell'importazione completata utilizzando l'ID attività del passaggio precedente.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file('BDUMP', 'dbtask-'||'&task_id'||'.log'));
```
Assicurarsi che l'importazione sia stata completata correttamente prima di passare alla fase successiva.
1. Eseguire uno snapshot DB manuale seguendo le istruzioni riportate in [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
### Passaggio 5: importazione dei metadati delle tablespace nell'istanza database di destinazione
In questo passaggio, vengono importati i metadati delle tablespace trasportabili nell'istanza database RDS per Oracle utilizzando la procedura `rdsadmin.rdsadmin_transport_util.import_xtts_metadata`. Per la sintassi e la semantica di questa procedura, consulta [Importazione dei metadati delle tablespace trasportabili nell'istanza database](rdsadmin_transport_util_import_xtts_metadata.md). Durante l'operazione, lo stato dell'importazione viene visualizzato nella tabella `rdsadmin.rds_xtts_operation_info`.
**Importante**
Prima di importare i metadati, è vivamente consigliabile di verificare che sia stato creato correttamente uno snapshot DB dopo aver importato le tablespace. Se la fase di importazione ha esito negativo, ripristinare l'istanza database, correggere gli errori di importazione e riprovare l'importazione.
**Importazione dei metadati di Data Pump nell'istanza database RDS per Oracle**
1. Avviare il client Oracle SQL e accedere come utente master all'istanza database RDS per Oracle di destinazione.
1. Se non esistono già, creare gli utenti proprietari degli schemi nelle tablespace trasportate.
```
CREATE USER tbs_owner IDENTIFIED BY password;
```
1. Importare i metadati, specificando il nome del file di dump e la sua posizione nella directory.
```
BEGIN
rdsadmin.rdsadmin_transport_util.import_xtts_metadata('xttdump.dmp','DATA_PUMP_DIR');
END;
/
```
1. (Facoltativo) Eseguire una query sulla tabella della cronologia delle tablespace trasportabili per visualizzare lo stato dell'importazione dei metadati.
```
SELECT * FROM rdsadmin.rds_xtts_operation_info;
```
Al termine dell'operazione, le tablespace sono in modalità di sola lettura.
1. (Facoltativo) Visualizzare il file di log.
L'esempio seguente elenca il contenuto della directory BDUMP e quindi esegue una query sul log di importazione.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'BDUMP'));
SELECT * FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-import_xtts_metadata-2023-05-22.01-52-35.560858000.log'));
```
## Fase 5: convalida delle tablespace trasportate
In questo passaggio facoltativo, si convalidano le tablespace trasportate utilizzando la procedura `rdsadmin.rdsadmin_rman_util.validate_tablespace` e quindi si attivano le tablespace. read/write
**Convalida dei dati trasportati**
1. Avviare SQL\$1Plus o SQL Developer e accedere come utente master all'istanza database RDS per Oracle.
1. Convalidare le tablespace utilizzando la procedura `rdsadmin.rdsadmin_rman_util.validate_tablespace`.
```
SET SERVEROUTPUT ON
BEGIN
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS1',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS2',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
rdsadmin.rdsadmin_rman_util.validate_tablespace(
p_tablespace_name => 'TBS3',
p_validation_type => 'PHYSICAL+LOGICAL',
p_rman_to_dbms_output => TRUE);
END;
/
```
1. Mettete le tablespace in modalità. read/write
```
ALTER TABLESPACE TBS1 READ WRITE;
ALTER TABLESPACE TBS2 READ WRITE;
ALTER TABLESPACE TBS3 READ WRITE;
```
## Fase 6: rimozione dei file residui
In questo passaggio facoltativo, tutti i file non necessari vengono rimossi. Usa la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per elencare i file di dati che sono rimasti orfani dopo un'importazione tablespace, quindi utilizza la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files` per eliminarli. Per la sintassi e la semantica di queste procedure, consulta [Elenco dei file orfani dopo un'importazione della tablespace](rdsadmin_transport_util_list_xtts_orphan_files.md) e [Eliminazione di file di dati rimasti orfani dopo un'importazione della tablespace](rdsadmin_transport_util_cleanup_incomplete_xtts_import.md).
**Rimozione dei file residui**
1. Rimuovi i vecchi backup nel modo seguente: *DATA\$1PUMP\$1DIR*
1. Elencare i file di backup eseguendo `rdsadmin.rdsadmin_file_util.listdir`.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir(p_directory => 'DATA_PUMP_DIR'));
```
1. Rimuovere i backup uno a uno chiamando `UTL_FILE.FREMOVE`.
```
EXEC UTL_FILE.FREMOVE ('DATA_PUMP_DIR', 'backup_filename');
```
1. Se è stata eseguita l'importazione delle tablespace, ma non dei relativi metadati, è possibile eliminare i file di dati orfani nel seguente modo:
1. Elencare i file di dati orfani da eliminare. L'esempio seguente esegue la procedura `rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files`.
```
SQL> SELECT * FROM TABLE(rdsadmin.rdsadmin_transport_util.list_xtts_orphan_files);
FILENAME FILESIZE
-------------- ---------
datafile_7.dbf 104865792
datafile_8.dbf 104865792
```
1. Eliminare i file orfani eseguendo la procedura `rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import`.
```
BEGIN
rdsadmin.rdsadmin_transport_util.cleanup_incomplete_xtts_import('DATA_PUMP_DIR');
END;
/
```
L'operazione di rimozione genera un file di log che utilizza il formato di nome `rds-xtts-delete_xtts_orphaned_files-YYYY-MM-DD.HH24-MI-SS.FF.log` nella directory `BDUMP`.
1. Leggere il file di log generato nel passaggio precedente. Il seguente esempio legge il log `rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log`.
```
SELECT *
FROM TABLE(rdsadmin.rds_file_util.read_text_file(
p_directory => 'BDUMP',
p_filename => 'rds-xtts-delete_xtts_orphaned_files-2023-06-01.09-33-11.868894000.log'));
TEXT
--------------------------------------------------------------------------------
orphan transported datafile datafile_7.dbf deleted.
orphan transported datafile datafile_8.dbf deleted.
```
1. Se è stata eseguita l'importazione sia delle tablespace che dei relativi metadati, ma sono stati restituiti errori di compatibilità o si sono verificati problemi di altro tipo con Oracle Data Pump, rimuovere i file di dati parzialmente trasportati nel seguente modo:
1. Elencare le tablespace contenente i file di dati parzialmente trasportati mediante una query su `DBA_TABLESPACES`.
```
SQL> SELECT TABLESPACE_NAME FROM DBA_TABLESPACES WHERE PLUGGED_IN='YES';
TABLESPACE_NAME
--------------------------------------------------------------------------------
TBS_3
```
1. Rimuovere le tablespace e i file di dati parzialmente trasportati.
```
DROP TABLESPACE TBS_3 INCLUDING CONTENTS AND DATAFILES;
```
# Importazione utilizzando Oracle Data Pump
Oracle Data Pump è un'utilità che consente di esportare i dati Oracle in un file di dump e importarli in un altro database Oracle. È un sostituto a lungo termine delle Export/Import utilità Oracle. rappresenta lo strumento consigliato per spostare grandi quantità di dati da un'installazione di Oracle a un'istanza database Amazon RDS.
Gli esempi riportati in questa sezione mostrano un modo per importare i dati in un database Oracle, ma Oracle Data Pump supporta anche altre procedure. Per ulteriori informazioni, consulta la [documentazione relativa a Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump.html#GUID-501A9908-BCC5-434C-8853-9A6096766B5A).
Gli esempi in questa sezione utilizzano il pacchetto `DBMS_DATAPUMP`. Puoi eseguire le stesse attività utilizzando le utilità della riga di comando di Oracle Data Pump `impdp` e `expdp`. È possibile installare queste utilità in un host remoto come parte di un'installazione Oracle Client, incluso Oracle Instant Client. Per ulteriori informazioni, consulta la pagina relativa alla [procedura di Oracle Instant Client da usare per eseguire l'importazione o l'esportazione di Data Pump per l'istanza database Amazon RDS per Oracle](https://aws.amazon.com/premiumsupport/knowledge-center/rds-oracle-instant-client-datapump/).
**Topics**
+ [Panoramica su Oracle Data Pump](#Oracle.Procedural.Importing.DataPump.Overview)
+ [Importazione di dati con Oracle Data Pump e un bucket Amazon S3](#Oracle.Procedural.Importing.DataPump.S3)
+ [Importazione di dati con Oracle Data Pump e un collegamento di database](#Oracle.Procedural.Importing.DataPump.DBLink)
## Panoramica su Oracle Data Pump
Oracle Data Pump è composto dai seguenti componenti:
+ Client della riga di comando `expdp` e `impdp`
+ Il pacchetto `DBMS_DATAPUMP` PL/SQL .
+ Il pacchetto `DBMS_METADATA` PL/SQL .
Puoi utilizzare Oracle Data Pump per gli scenari seguenti:
+ Importazione dei dati da un database Oracle (on-premise o in un'istanza Amazon EC2) in un'istanza database Amazon RDS per Oracle.
+ Importazione dei dati da un'istanza database RDS per Oracle in un database Oracle (locale o su un'istanza Amazon EC2).
+ Importazione dei dati tra istanze database RDS per Oracle (ad esempio, per la migrazione dei dati da EC2-Classic a VPC).
Per scaricare le utilità di Oracle Data Pump, consultare [Download di software per database Oracle](http://www.oracle.com/technetwork/database/enterprise-edition/downloads/index.html) sul sito web di Oracle Technology Network. Per le considerazioni sulla compatibilità durante la migrazione tra versioni di Oracle Database, consulta la [documentazione di Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-BAA3B679-A758-4D55-9820-432D9EB83C68).
### Flusso di lavoro di Oracle Data Pump
In genere, si utilizza Oracle Data Pump nelle seguenti fasi:
1. Esportazione dei dati in un file di dump nel database di origine.
1. Caricamento del file di dump nell'istanza database RDS per Oracle di destinazione. Puoi eseguire il trasferimento utilizzando un bucket Amazon S3 o un collegamento di database tra i due database.
1. Importazione i dati dal file di dump nell'istanza database RDS per Oracle.
### Best practice di Oracle Data Pump
Quando si utilizza Oracle Data Pump per importare dati in un'istanza RDS per Oracle, si consiglia di attenersi alle seguenti best practice:
+ Esegui le importazioni in modalità `schema` o `table` per importare schemi e oggetti specifici.
+ Limita gli schemi che importi a quelli richiesti dalla tua applicazione.
+ Non eseguire l'importazione in modalità `full`, né importare schemi per i componenti gestiti dal sistema.
Perché RDS per Oracle non consente l'accesso a utenti con privilegi di amministratore `SYS` o `SYSDBA`, queste azioni potrebbero danneggiare il dizionario dei dati Oracle e pregiudicare la stabilità del database.
+ Quando si caricano grandi quantità di dati, procedere nel seguente modo:
1. Trasferire il file di dump nell'istanza database RDS per Oracle di destinazione.
1. Acquisire una snapshot DB dell'istanza.
1. Verificare che l'importazione ha esito positivo.
Se i componenti del database sono invalidati, puoi eliminare l'istanza database e ricrearla dallo snapshot del database. L'istanza database ripristinata include i file di dump archiviati sull'istanza database al momento della creazione dello snapshot del database.
+ Non importare file di dump creati utilizzando i parametri di esportazione di Oracle Data Pump `TRANSPORT_TABLESPACES`, `TRANSPORTABLE` oppure `TRANSPORT_FULL_CHECK`. Le istanze database RDS per Oracle non supportano l'importazione di questi file di dump.
+ Non importare file di dump che contengono oggetti Oracle Scheduler in `SYS`, `SYSTEM`, `RDSADMIN`, `RDSSEC` e `RDS_DATAGUARD`, e che appartengono alle seguenti categorie:
+ Jobs
+ Programmi
+ Piani
+ Chain
+ Regole
+ Contesti di valutazione
+ Set di regole
Le istanze database RDS per Oracle non supportano l'importazione di questi file di dump.
+ Per escludere gli oggetti di Oracle Scheduler non supportati, utilizza direttive aggiuntive durante l'esportazione Data Pump. Se utilizzi `DBMS_DATAPUMP`, aggiungi un'altra direttiva `METADATA_FILTER` prima di `DBMS_METADATA.START_JOB`:
```
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
```
Se utilizzi `expdp`, crea un file di parametri contenente la direttiva `exclude` illustrata nell'esempio seguente. Quindi usa `PARFILE=parameter_file` con il comando `expdp`.
```
exclude=procobj:"IN
(SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)"
```
## Importazione di dati con Oracle Data Pump e un bucket Amazon S3
Il seguente processo di importazione utilizza Oracle Data Pump e un bucket Amazon S3. I passaggi sono i seguenti:
1. Esporta i dati nel database di origine utilizzando il pacchetto Oracle [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Inserisci il file di dump in un bucket Amazon S3.
1. Scarica il file di dump dal bucket Amazon S3 nella directory `DATA_PUMP_DIR` sull'istanza database RDS per Oracle di destinazione.
1. Importa i dati del file di dump copiato nell'istanza database RDS per Oracle utilizzando il pacchetto `DBMS_DATAPUMP`.
**Topics**
+ [Requisiti di importazione dei dati con Oracle Data Pump e un bucket Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.requirements)
+ [Fase 1: concessione dei privilegi all'utente del database sull'istanza database RDS per Oracle](#Oracle.Procedural.Importing.DataPumpS3.Step1)
+ [Fase 2: esportazione dei dati in un file di dump utilizzando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step2)
+ [Passaggio 3: Caricamento del file di dump sul bucket Amazon S3](#Oracle.Procedural.Importing.DataPumpS3.Step3)
+ [Fase 4: scaricamento del file di dump dal bucket Amazon S3 all'istanza database di destinazione](#Oracle.Procedural.Importing.DataPumpS3.Step4)
+ [Fase 5: importazione del file di dump nell'istanza DB di destinazione utilizzando DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpS3.Step5)
+ [Fase 6: eseguire la pulizia](#Oracle.Procedural.Importing.DataPumpS3.Step6)
### Requisiti di importazione dei dati con Oracle Data Pump e un bucket Amazon S3
Il processo ha i requisiti seguenti:
+ Assicurati che sia disponibile un bucket Amazon S3 per i trasferimenti di file e che il bucket Amazon S3 sia nella stessa istanza DB. Regione AWS Per istruzioni, consultare [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella *Guida introduttiva di Amazon Simple Storage Service*.
+ L'oggetto caricato nel bucket Amazon S3 deve essere pari o inferiore a 5 TB. Per ulteriori informazioni sull'utilizzo di oggetti nel Amazon S3, consulta [Guida per l'utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html).
**Nota**
Se il file di dump supera i 5 TB, è possibile eseguire l'esportazione Oracle Data Pump con l'opzione parallela. Questa operazione diffonde i dati in più file di dump in modo da non superare il limite di 5 TB per i singoli file.
+ È necessario preparare il bucket Amazon S3 per l'integrazione con Amazon RDS seguendo le istruzioni in [Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3](oracle-s3-integration.preparing.md).
+ È necessario disporre di spazio di storage sufficiente per archiviare il file dump nell'istanza di origine e nell'istanza database di destinazione.
**Nota**
Questo processo importa un file dump nella directory `DATA_PUMP_DIR`, una directory preconfigurata in tutte le istanze database Oracle. La directory si trova nello stesso volume di storage dei file di dati. Quando importi il file di dump, i file di dati di Oracle esistenti occupano più spazio. Pertanto, devi assicurarti che l'istanza database possa accomodare tale utilizzo dello spazio aggiuntivo. Il file dump importato non viene eliminato o ripulito automaticamente dalla directory `DATA_PUMP_DIR`. Per rimuovere il file di dump importato, utilizzare [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito web di Oracle.
### Fase 1: concessione dei privilegi all'utente del database sull'istanza database RDS per Oracle
In questa fase, si creano gli schemi in cui si intende importare i dati e si concedono agli utenti i privilegi necessari.
**Per creare utenti e concedere i privilegi necessari sull'istanza RDS per Oracle di destinazione**
1. Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione come utente master all'istanza database RDS per Oracle in cui verranno importati i dati. Per informazioni sulla connessione a un'istanza database, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Prima di importare i dati, crea gli spazi di tabella necessari. Per ulteriori informazioni, consulta [Creazione e dimensionamento di tablespace in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Se l'account utente in cui vengono importati i dati non esiste, crealo e concedigli le autorizzazioni e i ruoli necessari. Se intendi importare i dati su più schemi utente, crea tutti gli account utente e concedi loro i privilegi e i ruoli necessari.
Ad esempio, le istruzioni SQL seguenti permettono di creare un nuovo utente e concedergli le autorizzazioni e i ruoli necessari per importare i dati nel suo schema. In questo passaggio e in quelli successivi, sostituisci `schema_1` con il nome del tuo schema.
```
CREATE USER schema_1 IDENTIFIED BY my_password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Le istruzioni precedenti concedono al nuovo utente il privilegio `CREATE SESSION` e il ruolo `RESOURCE`. Potrebbero essere necessari privilegi e ruoli aggiuntivi, a seconda degli oggetti del database da importare.
### Fase 2: esportazione dei dati in un file di dump utilizzando DBMS\$1DATAPUMP
Per creare un file di dump, utilizza il pacchetto `DBMS_DATAPUMP`.
**Per esportare i dati Oracle in un file di dump**
1. Utilizza SQL Plus o Oracle SQL Developer per connetterti all'istanza database RDS per Oracle di origine come utente amministratore. Se il database di origine è un'istanza database RDS per Oracle, esegui la connessione con l'utente master Amazon RDS.
1. Esporta i dati richiamando le procedure `DBMS_DATAPUMP`.
Il seguente script esporta lo schema `SCHEMA_1` in un file di dump denominato `sample.dmp`nella directory `DATA_PUMP_DIR`. Sostituisci `SCHEMA_1` con il nome dello schema che si desidera esportare.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT',
job_mode => 'SCHEMA',
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_exp.log',
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM SYS.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**Nota**
Data Pump avvia i processi in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle.
1. (Facoltativo) Visualizza il contenuto del log di esportazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Passaggio 3: Caricamento del file di dump sul bucket Amazon S3
Utilizzare la procedura `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` di Amazon RDS per copiare il file dump sul bucket Amazon S3. L'esempio seguente carica tutti i file dalla directory `DATA_PUMP_DIR` su un bucket Amazon S3 denominato `amzn-s3-demo-bucket`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Caricamento di file da un'istanza database Oracle a un bucket Amazon S3](oracle-s3-integration.using.md#oracle-s3-integration.using.upload).
### Fase 4: scaricamento del file di dump dal bucket Amazon S3 all'istanza database di destinazione
Esegui questo passaggio utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`. Quando si scarica un file in una directory, la procedura `download_from_s3` salta il processo di scaricamento se nella directory esiste già un file con lo stesso nome. Per rimuovere il file di dump importato, utilizza [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito Web di Oracle.
**Per scaricare il file di dump**
1. Avvia SQL\$1Plus o Oracle SQL Developer e accedi come utente principale nell'istanza database Amazon RDS per Oracle di destinazione.
1. Scarica il file di dump utilizzando la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`.
L'esempio seguente illustra come scaricare tutti i file da un bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`. Per ulteriori informazioni, consulta [Download di file da un bucket Amazon S3 a un'istanza database Oracle](oracle-s3-integration.using.md#oracle-s3-integration.using.download).
### Fase 5: importazione del file di dump nell'istanza DB di destinazione utilizzando DBMS\$1DATAPUMP
Usa `DBMS_DATAPUMP` per importare lo schema nell'istanza database RDS per Oracle. Potrebbero essere necessarie opzioni aggiuntive, come `METADATA_REMAP`.
**Per importare dati nell'istanza database di destinazione**
1. Avvia SQL\$1Plus o SQL Developer e accedi come utente master all'istanza database RDS per Oracle.
1. Importa i dati chiamando le procedure `DBMS_DATAPUMP`.
L'esempio seguente importa i *SCHEMA\$11* dati dall'istanza DB di `sample_copied.dmp` destinazione.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di importazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
1. Verifica l'importazione dei dati elencando le tabelle dello schema nell'istanza database di destinazione.
Ad esempio, la query seguente restituisce il numero di tabelle per `SCHEMA_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Fase 6: eseguire la pulizia
Dopo che i dati sono stati importati, puoi eliminare i file che non intendi conservare.
**Per rimuovere i file non necessari**
1. Avvia SQL\$1Plus o SQL Developer e accedi come utente master all'istanza database RDS per Oracle.
1. Elenca i file contenuti in `DATA_PUMP_DIR` utilizzando il seguente comando.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
1. Elimina i file non più necessari da `DATA_PUMP_DIR` utilizzando il seguente comando.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','filename');
```
Ad esempio, il comando seguente elimina il file denominato `sample_copied.dmp`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
## Importazione di dati con Oracle Data Pump e un collegamento di database
I processi di importazione seguenti utilizzano Oracle Data Pump e il pacchetto Oracle [DBMS\$1FILE\$1TRANSFER](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_FILE_TRANSFER.html). I passaggi sono i seguenti:
1. Stabilisci una connessione a un database Oracle di origine che può essere on-premise, un'istanza Amazon EC2 o un'istanza database RDS per Oracle.
1. Esporta i dati utilizzando il pacchetto [DBMS\$1DATAPUMP](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DATAPUMP.html).
1. Utilizza `DBMS_FILE_TRANSFER.PUT_FILE` per copiare il file di dump dal database Oracle alla directory `DATA_PUMP_DIR` sull'istanza database RDS per Oracle di destinazione connessa tramite un collegamento di database.
1. Importa i dati del file di dump copiato nell'istanza database RDS per Oracle utilizzando il pacchetto ` DBMS_DATAPUMP`.
Il processo di importazione che utilizza Oracle Data Pump e il pacchetto `DBMS_FILE_TRANSFER` è costituito dalle seguenti fasi.
**Topics**
+ [Requisiti di importazione dei dati con Oracle Data Pump e un collegamento di database](#Oracle.Procedural.Importing.DataPumpDBLink.requirements)
+ [Fase 1: concessione dei privilegi all'utente sull'istanza database RDS per Oracle di destinazione](#Oracle.Procedural.Importing.DataPumpDBLink.Step1)
+ [Passaggio 2: Concessione dei privilegi all'utente nel database di origine](#Oracle.Procedural.Importing.DataPumpDBLink.Step2)
+ [Fase 3: creazione di un file di dump mediante DBMS\$1DATAPUM](#Oracle.Procedural.Importing.DataPumpDBLink.Step3)
+ [Fase 4: Creazione di un collegamento di database all'istanza database di destinazione](#Oracle.Procedural.Importing.DataPumpDBLink.Step4)
+ [Fase 5: copia del file di dump esportato nell'istanza database di destinazione mediante DBMS\$1FILE\$1TRANSFER](#Oracle.Procedural.Importing.DataPumpDBLink.Step5)
+ [Fase 6: importazione del file di dati nell'istanza database di destinazione mediante DBMS\$1DATAPUMP](#Oracle.Procedural.Importing.DataPumpDBLink.Step6)
+ [Fase 7: pulizia](#Oracle.Procedural.Importing.DataPumpDBLink.Step7)
### Requisiti di importazione dei dati con Oracle Data Pump e un collegamento di database
Il processo ha i requisiti seguenti:
+ Sono necessari i privilegi di esecuzione per i pacchetti `DBMS_FILE_TRANSFER` e `DBMS_DATAPUMP`.
+ Sono necessari i privilegi di scrittura nella directory `DATA_PUMP_DIR` nell'istanza database di origine.
+ È necessario disporre di spazio di storage sufficiente per archiviare il file dump nell'istanza di origine e nell'istanza database di destinazione.
**Nota**
Questo processo importa un file dump nella directory `DATA_PUMP_DIR`, una directory preconfigurata in tutte le istanze database Oracle. La directory si trova nello stesso volume di storage dei file di dati. Quando importi il file di dump, i file di dati di Oracle esistenti occupano più spazio. Pertanto, devi assicurarti che l'istanza database possa accomodare tale utilizzo dello spazio aggiuntivo. Il file dump importato non viene eliminato o ripulito automaticamente dalla directory `DATA_PUMP_DIR`. Per rimuovere il file di dump importato, utilizzare [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF), disponibile sul sito web di Oracle.
### Fase 1: concessione dei privilegi all'utente sull'istanza database RDS per Oracle di destinazione
Per concedere i privilegi all'utente sull'istanza database RDS per Oracle di destinazione, esegui i seguenti passaggi:
1. Utilizza SQL Plus o Oracle SQL Developer per la connessione all'istanza database RDS per Oracle di destinazione in cui verranno importati i dati. Esegui la connessione come utente master Amazon RDS. Per informazioni sulla connessione all'istanza database, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Prima di importare i dati, crea gli spazi di tabella necessari. Per ulteriori informazioni, consulta [Creazione e dimensionamento di tablespace in RDS for Oracle](Appendix.Oracle.CommonDBATasks.TablespacesAndDatafiles.md#Appendix.Oracle.CommonDBATasks.CreatingTablespacesAndDatafiles).
1. Se l'account utente in cui vengono importati i dati non esiste, crealo e concedigli le autorizzazioni e i ruoli necessari. Se intendi importare i dati su più schemi utente, crea tutti gli account utente e concedi loro i privilegi e i ruoli necessari.
Ad esempio, i comandi seguenti creano un nuovo utente denominato *schema\$11* e concedono le autorizzazioni e i ruoli necessari per importare i dati nello schema per questo utente.
```
CREATE USER schema_1 IDENTIFIED BY my-password;
GRANT CREATE SESSION, RESOURCE TO schema_1;
ALTER USER schema_1 QUOTA 100M ON users;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
L'esempio precedente concede al nuovo utente il privilegio `CREATE SESSION` e il ruolo `RESOURCE`. Potrebbero essere necessari privilegi e ruoli aggiuntivi, a seconda degli oggetti del database da importare.
**Nota**
In questo passaggio e in quelli successivi, sostituisci `schema_1` con il nome del tuo schema.
### Passaggio 2: Concessione dei privilegi all'utente nel database di origine
Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione all'istanza database RDS per Oracle contenente i dati da importare. Se necessario, crea un account utente e concedi le autorizzazioni necessarie.
**Nota**
Se il database di origine è un'istanza Amazon RDS, puoi ignorare questa fase. Per eseguire l'esportazione, utilizzi l'account utente master Amazon RDS.
I comandi seguenti creano un nuovo utente e gli concedono le autorizzazioni necessarie.
```
CREATE USER export_user IDENTIFIED BY my-password;
GRANT CREATE SESSION, CREATE TABLE, CREATE DATABASE LINK TO export_user;
ALTER USER export_user QUOTA 100M ON users;
GRANT READ, WRITE ON DIRECTORY data_pump_dir TO export_user;
GRANT SELECT_CATALOG_ROLE TO export_user;
GRANT EXECUTE ON DBMS_DATAPUMP TO export_user;
GRANT EXECUTE ON DBMS_FILE_TRANSFER TO export_user;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
### Fase 3: creazione di un file di dump mediante DBMS\$1DATAPUM
Per creare il file batch, procedi come segue:
1. Utilizza SQL\$1Plus o Oracle SQL Developer per la connessione all'istanza Oracle di origine come utente amministratore o come l'utente creato nel passaggio 2. Se il database di origine è un'istanza database Amazon RDS for Oracle, esegui la connessione con l'utente master Amazon RDS.
1. Crea un file di dump utilizzando l'utilità Oracle Data Pump.
Lo script seguente crea un file dump denominato *sample.dmp* nella directory `DATA_PUMP_DIR`.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'EXPORT' ,
job_mode => 'SCHEMA' ,
job_name => null
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample.dmp' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_dump_file
);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl ,
filename => 'sample_exp.log' ,
directory => 'DATA_PUMP_DIR' ,
filetype => dbms_datapump.ku$_file_type_log_file
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl ,
'SCHEMA_EXPR' ,
'IN (''SCHEMA_1'')'
);
DBMS_DATAPUMP.METADATA_FILTER(
v_hdnl,
'EXCLUDE_NAME_EXPR',
q'[IN (SELECT NAME FROM sys.OBJ$
WHERE TYPE# IN (66,67,74,79,59,62,46)
AND OWNER# IN
(SELECT USER# FROM SYS.USER$
WHERE NAME IN ('RDSADMIN','SYS','SYSTEM','RDS_DATAGUARD','RDSSEC')
)
)
]',
'PROCOBJ'
);
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di esportazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
### Fase 4: Creazione di un collegamento di database all'istanza database di destinazione
Crea un collegamento di database tra le istanze database di origine e destinazione. Tieni presente che, per creare un collegamento di database e trasferire il file dump esportato, l'istanza Oracle locale deve disporre di connettività di rete verso l'istanza database di destinazione.
Esegui questa fase connettendoti con lo stesso account utente utilizzato nella fase precedente.
Se stai creando un database link tra due istanze DB all'interno dello stesso VPC o VPCs peered, le due istanze DB dovrebbero avere un percorso valido tra di loro. Il gruppo di sicurezza di ogni istanza database deve permettere l'ingresso e l'uscita dall'altra istanza database. Le regole per il traffico in entrata e in uscita del gruppo di sicurezza possono fare riferimento a gruppi di sicurezza dello stesso VPC o di un VPC in peering. Per ulteriori informazioni, consulta [Modifica dei collegamenti di database per l'utilizzo con le istanze database in un VPC](Appendix.Oracle.CommonDBATasks.DBLinks.md).
Il comando seguente crea un collegamento di database denominato `to_rds` che si connette all'utente master Amazon RDS sull'istanza database di destinazione:
```
CREATE DATABASE LINK to_rds
CONNECT TO IDENTIFIED BY
USING '(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=)
(PORT=))(CONNECT_DATA=(SID=)))';
```
### Fase 5: copia del file di dump esportato nell'istanza database di destinazione mediante DBMS\$1FILE\$1TRANSFER
Utilizza `DBMS_FILE_TRANSFER` per copiare il file dump dall'istanza database di origine all'istanza database di destinazione. Il seguente script copia un file di dump denominato sample.dmp dall'istanza di origine su un collegamento di database di destinazione denominato *to\$1rds* (creato nel passaggio precedente).
```
BEGIN
DBMS_FILE_TRANSFER.PUT_FILE(
source_directory_object => 'DATA_PUMP_DIR',
source_file_name => 'sample.dmp',
destination_directory_object => 'DATA_PUMP_DIR',
destination_file_name => 'sample_copied.dmp',
destination_database => 'to_rds' );
END;
/
```
### Fase 6: importazione del file di dati nell'istanza database di destinazione mediante DBMS\$1DATAPUMP
Utilizza Oracle Data Pump per importare lo schema nell'istanza database. Potrebbero essere necessarie opzioni aggiuntive, come METADATA\$1REMAP.
Stabilisci la connessione all'istanza database con l'account utente master Amazon RDS per eseguire l'importazione.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'SCHEMA',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_copied.dmp',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'sample_imp.log',
directory => 'DATA_PUMP_DIR',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'SCHEMA_EXPR','IN (''SCHEMA_1'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
**Nota**
I processi di Data Pump vengono avviati in modo asincrono. Per informazioni sul monitoraggio di un processo di Data Pump, consulta la pagina relativa al [ monitoraggio dello stato dei processi](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-E365D74E-12CD-495C-BA23-5A55F679C7E7) nella documentazione di Oracle. È possibile visualizzare il contenuto del log di importazione utilizzando la procedura `rdsadmin.rds_file_util.read_text_file`. Per ulteriori informazioni, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
Puoi verificare l'importazione dei dati visualizzando le tabelle dell'utente nell'istanza database. Ad esempio, la query seguente restituisce il numero di tabelle per `schema_1`.
```
SELECT COUNT(*) FROM DBA_TABLES WHERE OWNER='SCHEMA_1';
```
### Fase 7: pulizia
Dopo che i dati sono stati importati, puoi eliminare i file che non intendi conservare. Puoi elencare i file contenuti in `DATA_PUMP_DIR` utilizzando il seguente comando.
```
SELECT * FROM TABLE(rdsadmin.rds_file_util.listdir('DATA_PUMP_DIR')) ORDER BY MTIME;
```
Per eliminare i file non più necessari da `DATA_PUMP_DIR`, utilizza il seguente comando.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','');
```
Ad esempio, il comando seguente elimina il file denominato `"sample_copied.dmp"`.
```
EXEC UTL_FILE.FREMOVE('DATA_PUMP_DIR','sample_copied.dmp');
```
# Importazione con le utilità Oracle di esportazione/importazione
È possibile valutare la possibilità di utilizzare le utilità Oracle di esportazione/importazione per le migrazioni nelle seguenti condizioni:
+ Le dimensioni dei dati sono ridotte.
+ Non sono richiesti tipi di dati come binary float e double.
Il processo di importazione crea gli oggetti dello schema necessari. Pertanto, non devi eseguire prima uno script per creare gli oggetti.
Il modo più semplice per installare le utilità Oracle di esportazione e importazione è installare Oracle Instant Client. Per scaricare il software, vai su [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Per la documentazione, consulta [Instant Client for SQL\$1Loader, Export and Import](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) nel manuale *Oracle Database Utilities*.
**Per esportare le tabelle e quindi importarle**
1. Esporta le tabelle dal database di origine utilizzano il comando `exp`.
Il comando seguente esporta le tabelle denominate `tab1`, `tab2` e `tab3`. Il file di dump è `exp_file.dmp`.
```
exp cust_dba@ORCL FILE=exp_file.dmp TABLES=(tab1,tab2,tab3) LOG=exp_file.log
```
L'esportazione crea un file dump binario contenente sia lo schema che i dati delle tabelle specificate.
1. Importa lo schema e i dati in un database di destinazione utilizzando il comando `imp`.
Il comando seguente importa le tabelle `tab1`, `tab2` e `tab3` dal file di dump `exp_file.dmp`.
```
imp cust_dba@targetdb FROMUSER=cust_schema TOUSER=cust_schema \
TABLES=(tab1,tab2,tab3) FILE=exp_file.dmp LOG=imp_file.log
```
Le esportazioni e importazione hanno altre varianti che potrebbero essere più adatte alle esigenze specifiche. Per dettagli completi, consulta la documentazione di Oracle Database.
# Importazione utilizzando Oracle SQL\$1Loader
Potresti valutare l'opportunità di utilizzare Oracle SQL\$1Loader per database di grandi dimensioni contenenti un numero limitato di oggetti. Poiché il processo di esportazione da un database di origine e di caricamento in un database di destinazione è specifico dello schema, l'esempio seguente crea gli oggetti dello schema di esempio, li esporta da un'origine e quindi carica i dati in un database di destinazione.
Il modo più semplice per installare Oracle SQL\$1Loader è installare Oracle Instant Client. Per scaricare il software, vai su [https://www.oracle.com/database/technologies/instant-client.html](https://www.oracle.com/database/technologies/instant-client.html). Per la documentazione, consulta [Instant Client for SQL\$1Loader, Export and Import](https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/instant-client-sql-loader-export-import.html#GUID-FF1B6F75-09F5-4911-9317-9776FAD15965) nel manuale *Oracle Database Utilities*.
**Per importare dati utilizzando Oracle SQL\$1Loader**
1. Crea una tabella di origine di esempio utilizzando la seguente istruzione SQL.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
```
1. Nell'istanza database RDS per Oracle di destinazione, crea una tabella di destinazione per caricare i dati. La clausola `WHERE 1=2` garantisce la copia della struttura di `ALL_OBJECTS`, ma non delle righe.
```
CREATE TABLE customer_1 TABLESPACE users
AS (SELECT 0 AS ID, OWNER, OBJECT_NAME, CREATED
FROM ALL_OBJECTS
WHERE 1=2);
```
1. Esporta i dati dal database di origine a un file di testo. L'esempio seguente utilizza SQL\$1Plus. Per i propri dati, è probabilmente necessario generare uno script che esegue l'esportazione per tutti gli oggetti nel database.
```
ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY/MM/DD HH24:MI:SS'
SET LINESIZE 800 HEADING OFF FEEDBACK OFF ARRAY 5000 PAGESIZE 0
SPOOL customer_0.out
SET MARKUP HTML PREFORMAT ON
SET COLSEP ','
SELECT id, owner, object_name, created
FROM customer_0;
SPOOL OFF
```
1. Crea un file di controllo per descrivere i dati. Potrebbe essere necessario scrivere uno script per eseguire questa operazione.
```
cat << EOF > sqlldr_1.ctl
load data
infile customer_0.out
into table customer_1
APPEND
fields terminated by "," optionally enclosed by '"'
(
id POSITION(01:10) INTEGER EXTERNAL,
owner POSITION(12:41) CHAR,
object_name POSITION(43:72) CHAR,
created POSITION(74:92) date "YYYY/MM/DD HH24:MI:SS"
)
```
Se necessario, copiare i file generati dal codice precedente in un'area di staging, ad esempio un'istanza Amazon EC2.
1. Importa i dati utilizzando SQL\$1Loader con il nome utente e la password appropriati per il database di destinazione.
```
sqlldr cust_dba@targetdb CONTROL=sqlldr_1.ctl BINDSIZE=10485760 READSIZE=10485760 ROWS=1000
```
# Migrazione con le viste materializzate Oracle
Per eseguire la migrazione di set di dati di grandi dimensioni in modo efficiente, è anche possibile utilizzare la replica delle viste materializzate Oracle. Una replica consente di mantenere la sincronizzazione tra le tabelle di destinazione e le tabelle di origine. Pertanto, puoi passare ad Amazon RDS in un secondo momento, se necessario.
Prima di poter migrare utilizzando le viste materializzate, verifica che siano soddisfatti i seguenti requisiti:
+ Configurazione dell'accesso dal database di destinazione al database di origine. Nell'esempio seguente sono state abilitate regole di accesso nel database di origine per permettere la connessione del database RDS per Oracle di destinazione all'origine tramite SQL\$1Net.
+ Crea un collegamento di database tra l'istanza database RDS per Oracle e il database di origine.
**Per eseguire la migrazione dei dati utilizzando viste materializzate**
1. Nelle istanze RDS per Oracle di origine e di destinazione crea un account utente per il quale sia possibile eseguire l'autenticazione con la stessa password. L'esempio seguente crea un utente denominato `dblink_user`.
```
CREATE USER dblink_user IDENTIFIED BY my-password
DEFAULT TABLESPACE users
TEMPORARY TABLESPACE temp;
GRANT CREATE SESSION TO dblink_user;
GRANT SELECT ANY TABLE TO dblink_user;
GRANT SELECT ANY DICTIONARY TO dblink_user;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Crea un collegamento di database dall'istanza RDS per Oracle di destinazione all'istanza di origine utilizzando il nuovo utente creato.
```
CREATE DATABASE LINK remote_site
CONNECT TO dblink_user IDENTIFIED BY my-password
USING '(description=(address=(protocol=tcp) (host=my-host)
(port=my-listener-port)) (connect_data=(sid=my-source-db-sid)))';
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Testare il collegamento:
```
SELECT * FROM V$INSTANCE@remote_site;
```
1. Creare una tabella di esempio con una chiave primaria e un log della vista materializzata nell'istanza di origine.
```
CREATE TABLE customer_0 TABLESPACE users
AS (SELECT ROWNUM id, o.*
FROM ALL_OBJECTS o, ALL_OBJECTS x
WHERE ROWNUM <= 1000000);
ALTER TABLE customer_0 ADD CONSTRAINT pk_customer_0 PRIMARY KEY (id) USING INDEX;
CREATE MATERIALIZED VIEW LOG ON customer_0;
```
1. Nell'istanza database RDS per Oracle di destinazione, crea una vista materializzata.
```
CREATE MATERIALIZED VIEW customer_0
BUILD IMMEDIATE REFRESH FAST
AS (SELECT *
FROM cust_dba.customer_0@remote_site);
```
1. Nell'istanza database RDS per Oracle di destinazione, aggiorna la vista materializzata.
```
EXEC DBMS_MVIEW.REFRESH('CUSTOMER_0', 'f');
```
1. Elimina la vista materializzata e includi la clausola `PRESERVE TABLE` per mantenere la tabella container della vista materializzata e il relativo contenuto.
```
DROP MATERIALIZED VIEW customer_0 PRESERVE TABLE;
```
La tabella conservata ha lo stesso nome della vista materializzata eliminata.
# Utilizzo di repliche di lettura per Amazon RDS per Oracle
Per configurare la replica tra istanze database di Oracle, è possibile creare database di replica. Per una panoramica delle repliche di lettura di Amazon RDS, consulta [Panoramica delle repliche di lettura di Amazon RDSPanoramica di ](USER_ReadRepl.md#USER_ReadRepl.Overview). Per un riepilogo delle differenze tra repliche Oracle e altri motori di database, vedere [Differenze tra repliche di lettura per i motori di database](USER_ReadRepl.Overview.Differences.md).
**Topics**
+ [Panoramica delle repliche RDS per Oracle](oracle-read-replicas.overview.md)
+ [Requisiti e considerazioni sulle repliche RDS per Oracle](oracle-read-replicas.limitations.md)
+ [Preparazione alla creazione di una replica Oracle](oracle-read-replicas.Configuration.md)
+ [Creazione di una replica RDS per Oracle in modalità montata](oracle-read-replicas.creating-in-mounted-mode.md)
+ [Modifica della modalità di replica RDS per Oracle](oracle-read-replicas.changing-replica-mode.md)
+ [Utilizzo dei backup di repliche RDS per Oracle](oracle-read-replicas.backups.md)
+ [Esecuzione di uno switchover Oracle Data Guard](oracle-replication-switchover.md)
+ [Risoluzione dei problemi relativi alle repliche Oracle](oracle-read-replicas.troubleshooting.md)
+ [Redo Transport Compression con RDS per Oracle](oracle-read-replicas.redo-transport-compression.md)
# Panoramica delle repliche RDS per Oracle
Un database *replica di Oracle* è una copia fisica del database primario. Una replica Oracle in modalità di sola lettura è denominata *replica di lettura*. Una replica Oracle in modalità montata è denominata *replica montata*. Oracle Database non consente la scrittura in una replica, ma è possibile promuovere una replica per renderla scrivibile. La replica di lettura promossa contiene i dati replicati fino al momento in cui è stata effettuata la richiesta di promozione.
Nel seguente video viene fornita una panoramica utile del ripristino di emergenza di RDS per Oracle.
[](http://www.youtube.com/watch?v=-XpzhIevwVg)
Per ulteriori informazioni, leggi il post del blog [Ripristino di emergenza gestito con backup automatizzati tra regioni di Amazon RDS per Oracle - Parte 1](https://aws.amazon.com/blogs/database/managed-disaster-recovery-with-amazon-rds-for-oracle-cross-region-automated-backups-part-1/) e [Ripristino di emergenza gestito con backup automatizzati tra regioni di Amazon RDS per Oracle - Parte 2](https://aws.amazon.com/blogs/database/part-2-managed-disaster-recovery-with-amazon-rds-for-oracle-xrab/).
**Topics**
+ [Repliche di sola lettura e montate](#oracle-read-replicas.overview.modes)
+ [Leggi le repliche di CDBs](#oracle-read-replicas.overview.data-guard)
+ [Conservazione dei log di ripristino archiviati](#oracle-read-replicas.overview.log-retention)
+ [Interruzioni durante la replica Oracle](#oracle-read-replicas.overview.outages)
## Repliche di sola lettura e montate
Quando si crea o si modifica una replica Oracle, è possibile inserirla in una delle seguenti modalità:
Sola lettura
Questa è l’impostazione predefinita. Active Data Guard trasmette e applica le modifiche dal database di origine a tutti i database di replica di lettura.
È possibile creare fino a cinque repliche di lettura da un'istanza database di origine. Per informazioni generali sulle repliche di lettura applicabili a tutti i motori DB, consulta [Uso delle repliche di lettura dell'istanza database](USER_ReadRepl.md). Per informazioni su Oracle Data Guard, consulta [Oracle Data Guard concepts and administration](https://docs.oracle.com/en/database/oracle/oracle-database/19/sbydb/oracle-data-guard-concepts.html#GUID-F78703FB-BD74-4F20-9971-8B37ACC40A65) (Concetti e amministrazione di Oracle Data Guard) nella documentazione di Oracle.
Montata
In questo caso, la replica utilizza Oracle Data Guard, ma il database di replica non accetta connessioni utente. L'uso principale per le repliche montate è il disaster recovery tra regioni.
Una replica montata non può gestire un carico di lavoro di sola lettura. La replica montata elimina i file di log redo archiviati dopo averli applicati, indipendentemente dalla policy di conservazione dei log archiviati.
È possibile creare una combinazione di repliche database montate e di sola lettura per la stessa istanza database di origine. È possibile modificare una replica di sola lettura in modalità montata oppure modificare una replica montata in modalità di sola lettura. In entrambi i casi, il database Oracle mantiene l'impostazione di conservazione dei log archiviati.
## Leggi le repliche di CDBs
RDS per Oracle supporta le repliche di lettura Data Guard per Oracle Database 19c e 21c CDBs in configurazioni single-tenant e multi-tenant. È possibile creare, gestire e promuovere repliche di lettura in un CDB, proprio come in un non CDB. Sono supportate anche le repliche montate. Si ottengono i seguenti vantaggi:
+ Ripristino di emergenza gestito, alta disponibilità e accesso in sola lettura alle repliche
+ La possibilità di creare repliche di lettura in un altro modo. Regione AWS
+ Integrazione con la replica di lettura RDS esistente APIs: [DBInstanceReadReplicaCreate](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html), e [PromoteReadReplica[SwitchoverReadReplica](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html)](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_PromoteReadReplica.html)
Per utilizzare questa funzionalità, è necessaria una licenza Active Data Guard e una licenza Oracle Database Enterprise Edition per la replica e per le istanze database primarie. Non ci sono costi aggiuntivi correlati all'utilizzo dell'architettura CDB. I prezzi sono calcolati in base alle istanze database.
Per ulteriori informazioni sulle configurazioni a tenant singolo e multi-tenant dell'architettura CDB, consulta [Panoramica di RDS per Oracle CDBs](Oracle.Concepts.CDBs.md).
## Conservazione dei log di ripristino archiviati
Se un'istanza database primaria non dispone di repliche di lettura tra Regioni, Amazon RDS per Oracle mantiene per un minimo di due ore i registri redo archiviati nell'istanza database di origine. Questo è vero indipendentemente dall'impostazione per `archivelog retention hours` in `rdsadmin.rdsadmin_util.set_configuration`.
RDS elimina i log dall’istanza database sorgente dopo due ore o dopo che il tempo impostato per il periodo di conservazione dell’archivio dei log è passato, a seconda di quale risulta maggiore. RDS elimina i log dalla replica di lettura dopo che il tempo impostato per il periodo di conservazione dei log archiviati è passato, solo se ciò è stato applicato correttamente al database.
In alcuni casi, un'istanza database primaria potrebbe avere una o più repliche di lettura tra regioni. In questa evenienza, Amazon RDS for Oracle mantiene i log delle transazioni sull'istanza database di origine finché non vengono trasmessi e applicati a tutte le repliche di lettura tra regioni. Per informazioni su `rdsadmin.rdsadmin_util.set_configuration`, consultare [Conservazione dei log redo archiviati](Appendix.Oracle.CommonDBATasks.RetainRedoLogs.md).
## Interruzioni durante la replica Oracle
Quando crei una replica di lettura, Amazon RDS acquisisce uno snapshot DB dell'istanza database di origine e avvia la replica. L'istanza DB di origine subisce una I/O sospensione molto breve all'inizio dell'operazione di snapshot DB. La I/O sospensione dura in genere circa un secondo. È possibile evitare la I/O sospensione se l'istanza DB di origine è una distribuzione Multi-AZ, perché in tal caso lo snapshot viene scattato dall'istanza DB secondaria.
Lo snapshot di database diventa la replica Oracle. Amazon RDS imposta i parametri e le autorizzazioni necessari per il database di origine e la replica senza interruzione del servizio. Analogamente, se si elimina una replica, non si verifica alcuna interruzione.
# Requisiti e considerazioni sulle repliche RDS per Oracle
Prima di creare una replica Oracle, esamina i requisiti e le considerazioni riportati di seguito.
**Topics**
+ [Requisiti di versione e licenza per le repliche RDS per Oracle](#oracle-read-replicas.limitations.versions-and-licenses)
+ [Limitazioni del gruppo di opzioni per le repliche RDS per Oracle](#oracle-read-replicas.limitations.options)
+ [Considerazioni su backup e ripristino per le repliche RDS per Oracle](#oracle-read-replicas.limitations.backups)
+ [Requisiti e limitazioni di Oracle Data Guard per le repliche RDS per Oracle](#oracle-read-replicas.data-guard.requirements)
+ [Limitazioni della configurazione multi-tenant per le repliche RDS for Oracle](#oracle-read-replicas.limitations.multitenant)
+ [Considerazioni varie sulle repliche RDS per Oracle](#oracle-read-replicas.limitations.miscellaneous)
## Requisiti di versione e licenza per le repliche RDS per Oracle
Prima di creare una replica RDS per Oracle, considera i seguenti requisiti:
+ Se la replica è in modalità di sola lettura, assicurarsi di disporre di una licenza Active Data Guard. Se si posiziona la replica in modalità montata, non è necessaria una licenza Active Data Guard. Solo il motore database Oracle supporta le repliche montate.
+ Le repliche Oracle sono supportate solo per Oracle Enterprise Edition (EE).
+ Le repliche Oracle di tipo non- CDBs sono supportate solo per le istanze DB create utilizzando istanze non CDB che eseguono Oracle Database 19c.
+ Le repliche Oracle sono disponibili per le istanze DB eseguite solo su classi di istanze DB con due o più v. CPUs Un'istanza DB di origine non può utilizzare la classe di istanze db.t3.small.
+ La versione del motore di database Oracle dell’istanza database di origine e quella di tutte le relative repliche devono essere uguali. Amazon RDS aggiorna la primaria immediatamente dopo l'aggiornamento dell’istanza database di origine, a prescindere dalla finestra di manutenzione della replica. Per gli aggiornamenti delle versioni principali delle repliche tra regioni, Amazon RDS esegue automaticamente le operazioni seguenti:
+ Genera automaticamente un gruppo di opzioni per la versione di destinazione
+ Copia tutte le opzioni e le impostazioni delle opzioni dal gruppo di opzioni originale al nuovo gruppo di opzioni
+ Associa la replica aggiornata tra regioni al nuovo gruppo di opzioni
Per ulteriori informazioni sull'aggiornamento della versione del motore del database, consultare [Aggiornamento del motore di database RDS per Oracle](USER_UpgradeDBInstance.Oracle.md).
## Limitazioni del gruppo di opzioni per le repliche RDS per Oracle
Quando gestisci i gruppi di opzioni relative alla replica RDS per Oracle, tieni presente quanto segue:
+ Non è possibile utilizzare un gruppo di opzioni di replica diverso dal gruppo di opzioni dell'istanza DB di origine quando l'origine e la replica si trovano nella stessa regione. AWS
Le modifiche apportate al gruppo di opzioni di origine o all’appartenenza al gruppo di opzioni di origine si propagano alle repliche Oracle. Queste modifiche vengono applicate alle repliche immediatamente dopo l'applicazione all'istanza database di origine, indipendentemente dalla finestra di manutenzione delle repliche. Per ulteriori informazioni sui gruppi di opzioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
+ Non è possibile rimuovere una replica multi-Regione RDS per Oracle dal relativo gruppo di opzioni dedicato, creato automaticamente per la replica.
+ Non è possibile aggiungere il gruppo di opzioni dedicato per una replica multi-Regione RDS per Oracle a un’istanza database diversa.
+ Non è possibile aggiungere o rimuovere opzioni non replicate da un gruppo di opzioni dedicato per una replica multi-Regione RDS per Oracle, ad eccezione delle opzioni seguenti:
+ `NATIVE_NETWORK_ENCRYPTION`
+ `OEM`
+ `OEM_AGENT`
+ `SSL`
Per aggiungere altre opzioni a una replica tra regioni RDS per Oracle, aggiungerle al gruppo di opzioni dell'istanza database di origine. L'opzione è installata anche su tutte le repliche dell'istanza database di origine. Per le opzioni con licenza, assicurarsi che siano disponibili licenze sufficienti per le repliche.
Quando promuovi una replica tra regioni RDS per Oracle, tale replica si comporta come qualsiasi altra istanza database di Oracle, compresa la gestione delle opzioni. Puoi promuovere una replica esplicitamente o implicitamente eliminando la sua istanza database di origine.
Per ulteriori informazioni sui gruppi di opzioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
+ Non è possibile aggiungere l’opzione `EFS_INTEGRATION` alle repliche multi-Regione RDS per Oracle.
## Considerazioni su backup e ripristino per le repliche RDS per Oracle
Prima di creare una replica RDS per Oracle, considera i seguenti requisiti:
+ Per creare snapshot delle repliche RDS per Oracle o attivare i backup automatici, assicurati di impostare manualmente il periodo di conservazione dei backup. Per impostazione predefinita, i backup automatici non sono attivati.
+ Quando si ripristina un backup di repliche, si esegue il ripristino corrispondente all'ora del database e non al momento in cui il backup è stato eseguito. L'ora del database si riferisce all'ora dell'ultima transazione applicata ai dati nel backup. La differenza è significativa perché una replica può fare riferimento a un'ora più o meno precedente all'ora del database primario.
Per trovare la differenza, usa il comando `describe-db-snapshots`. Confronta `snapshotDatabaseTime`, ovvero l'ora del database del backup di repliche e il campo `OriginalSnapshotCreateTime`, che è l'ultima transazione applicata al database primario.
## Requisiti e limitazioni di Oracle Data Guard per le repliche RDS per Oracle
Prima di creare una replica di RDS per Oracle, prendi nota dei seguenti requisiti e limitazioni:
+ Se l'istanza DB principale utilizza la configurazione single-tenant o multi-tenant dell'architettura multitenant, considera quanto segue:
+ Devi utilizzare Oracle Database versione 19c o successive con Enterprise Edition.
+ L'istanza CDB primaria deve trovarsi in un ciclo di vita `ACTIVE`.
+ Non puoi convertire un'istanza primaria non CDB in un'istanza CDB e convertire le rispettive repliche nella stessa operazione. Elimina, invece, le repliche non CDB, converti l'istanza database primaria in CDB e quindi crea nuove repliche
+ Assicurati che un trigger di accesso su un'istanza database primaria consenta l'accesso all'utente `RDS_DATAGUARD` e a qualsiasi utente il cui valore `AUTHENTICATED_IDENTITY` sia `RDS_DATAGUARD` o `rdsdb`. Inoltre, il trigger non deve impostare lo schema corrente per l'utente `RDS_DATAGUARD`.
+ Per evitare di bloccare le connessioni dal processo di broker Data Guard, non abilitare le sessioni con restrizioni. Per ulteriori informazioni sulle sessioni con restrizioni, consulta [Abilitazione e disabilitazione delle sessioni limitate](Appendix.Oracle.CommonDBATasks.RestrictedSession.md).
## Limitazioni della configurazione multi-tenant per le repliche RDS for Oracle
Quando si utilizza la configurazione multi-tenant su una replica RDS per Oracle, tenere presente le seguenti limitazioni:
+ È possibile creare, eliminare o modificare i database tenant solo sull'istanza DB principale. Queste modifiche si propagano automaticamente alle repliche.
+ I database tenant su un sistema primario, di origine o di replica RDS for Oracle non possono essere creati con un set di caratteri personalizzato. Se hai bisogno di un set di caratteri personalizzato, crea i database tenant prima di creare repliche di lettura per l'istanza DB.
## Considerazioni varie sulle repliche RDS per Oracle
Prima di creare una replica RDS per Oracle, considera i seguenti requisiti:
+ Quando si crea una replica RDS for Oracle per un'istanza DB con volumi di storage aggiuntivi, RDS configura automaticamente volumi di storage aggiuntivi sulla replica. Tuttavia, eventuali modifiche successive apportate ai volumi di archiviazione dell'istanza DB principale non vengono applicate automaticamente alla replica.
+ Se si aggiungono ulteriori volumi di storage nell'istanza DB principale, RDS non aggiunge automaticamente volumi di storage aggiuntivi alla replica. È necessario modificare la replica per aggiungere ulteriori volumi di archiviazione.
+ Se si modifica la configurazione dei volumi di archiviazione, ad esempio le dimensioni di archiviazione e gli IOPS, nell'istanza DB principale, RDS non modifica automaticamente i volumi di archiviazione nella replica. È necessario modificare la replica per aggiornare le configurazioni dei volumi di archiviazione.
+ Quando gestisci le posizioni dei file di dati tra i volumi, tieni presente che le modifiche apportate sull'istanza principale non si sincronizzano automaticamente con le repliche.
+ Per le repliche di sola lettura: puoi utilizzare le impostazioni dei gruppi di parametri per controllare le posizioni predefinite dei file o spostare manualmente i file dopo la loro creazione.
+ Per le repliche montate: le modifiche manuali alle posizioni dei file di dati nel database principale richiedono la ricreazione della replica montata per riflettere tali modifiche. Per evitare ciò, si consiglia di utilizzare le impostazioni dei gruppi di parametri per gestire le posizioni dei file predefinite.
+ Se l’istanza database è un’origine per una o più repliche multi-Regione, il database di origine mantiene i propri file di log di redo archiviati finché non vengono applicati a tutte le repliche multi-Regione. I log redo archiviati potrebbero causare un aumento del consumo di storage.
+ Per evitare di interrompere l'automazione RDS, i trigger di sistema devono consentire a utenti specifici di accedere al database primario e di replica. I [trigger di sistema](https://docs.oracle.com/en/database/oracle/oracle-database/19/lnpls/plsql-triggers.html#GUID-FE23FCE8-DE36-41EF-80A9-6B4B49E80E5B) includono trigger DDL, di accesso e ruolo database. Si consiglia di aggiungere codice ai trigger per escludere gli utenti elencati nel codice di esempio riportato di seguito:
```
-- Determine who the user is
SELECT SYS_CONTEXT('USERENV','AUTHENTICATED_IDENTITY') INTO CURRENT_USER FROM DUAL;
-- The following users should always be able to login to either the Primary or Replica
IF CURRENT_USER IN ('master_user', 'SYS', 'SYSTEM', 'RDS_DATAGUARD', 'rdsdb') THEN
RETURN;
END IF;
```
+ Il rilevamento delle modifiche di blocco è supportato per le repliche di sola lettura, ma non per le repliche montate. Puoi modificare una replica montata in una replica di sola lettura e quindi attivare il rilevamento delle modifiche di blocco. Per ulteriori informazioni, consulta [Abilitazione e disabilitazione del monitoraggio delle modifiche dei blocchi.](Appendix.Oracle.CommonDBATasks.BlockChangeTracking.md).
+ Non è possibile creare una replica di lettura Oracle quando il database di origine gestisce le credenziali dell’utente master con Secrets Manager.
# Preparazione alla creazione di una replica Oracle
Prima di iniziare a utilizzare la replica, eseguire le operazioni seguenti.
**Topics**
+ [Abilitazione di backup automatici](#oracle-read-replicas.configuration.autobackups)
+ [Attivazione della modalità di registrazione forzata](#oracle-read-replicas.configuration.force-logging)
+ [Modifica della configurazione di registrazione](#oracle-read-replicas.configuration.logging-config)
+ [Impostazione del parametro MAX\$1STRING\$1SIZE](#oracle-read-replicas.configuration.string-size)
+ [Ridimensionare le risorse di calcolo e storage.](#oracle-read-replicas.configuration.planning-resources)
## Abilitazione di backup automatici
Prima di poter utilizzare un'istanza database come istanza database di origine, devi abilitare i backup automatici sull'istanza database di origine. Per informazioni su come eseguire questa procedura, consulta [Abilitazione dei backup automatici](USER_WorkingWithAutomatedBackups.Enabling.md).
## Attivazione della modalità di registrazione forzata
Si consiglia di attivare la modalità di registrazione forzata. In modalità di registrazione forzata, il database Oracle scrive i record redo anche quando `NOLOGGING` viene utilizzato con istruzioni DDL (Data Definition Language).
**Per attivare la modalità di registrazione forzata**
1. Accedere al database Oracle utilizzando uno strumento client, ad esempio SQL Developer.
1. Attivare la modalità di registrazione forzata eseguendo la procedura seguente.
```
exec rdsadmin.rdsadmin_util.force_logging(p_enable => true);
```
Per ulteriori informazioni su questa procedura, consultare [Impostazione accesso forzato](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.SettingForceLogging).
## Modifica della configurazione di registrazione
Per *n* log di redo online di dimensione *m*, RDS crea automaticamente *n*\$11 log in standby di dimensione *m* sull’istanza database primaria e su tutte le repliche. Ogni volta che modifichi la configurazione per la registrazione di log sull’istanza primaria, le modifiche si propagano automaticamente alle repliche.
Se modifichi la configurazione per la registrazione di log, tieni presente le seguenti linee guida:
+ È consigliabile completare le modifiche prima di impostare un’istanza database come origine per le repliche. RDS per Oracle supporta l’aggiornamento dell’istanza anche dopo che è diventata un’origine.
+ Prima di modificare la configurazione per la registrazione di log sull’istanza database primaria, verifica che ogni replica disponga di archiviazione sufficiente per ospitare la nuova configurazione.
Puoi modificare la configurazione per la registrazione di log per un’istanza database utilizzando le procedure `rdsadmin.rdsadmin_util.add_logfile` e `rdsadmin.rdsadmin_util.drop_logfile` di Amazon RDS. Per ulteriori informazioni, consultare [Aggiunta di log redo online](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.RedoLogs) e [Eliminazione di log redo online](Appendix.Oracle.CommonDBATasks.Log.md#Appendix.Oracle.CommonDBATasks.DroppingRedoLogs).
## Impostazione del parametro MAX\$1STRING\$1SIZE
Prima di creare una replica di lettura, assicurarsi che l'impostazione del parametro `MAX_STRING_SIZE` sia la stessa sull'istanza database di origine e sulla replica di lettura. Puoi ottenere tale risultato associando entrambi gli oggetti allo stesso gruppo di parametri. Se disponi di gruppi di parametri diversi per l'origine e la replica di lettura, puoi impostare `MAX_STRING_SIZE` sullo stesso valore. Per ulteriori informazioni su questo parametro, consulta [Attivazione dei tipi di dati estesi per una nuova istanza database](Oracle.Concepts.ExtendedDataTypes.md#Oracle.Concepts.ExtendedDataTypes.CreateDBInstance).
## Ridimensionare le risorse di calcolo e storage.
Assicurati che l'istanza database di origine e le sue repliche siano dimensionate correttamente, in termini di capacità di calcolo e storage, per adattarsi al loro carico operativo. Se una replica di lettura raggiunge la massima capacità di risorse calcolo, rete o archiviazione, smette di ricevere o applicare modifiche dalla sua origine. Amazon RDS for Oracle non interviene per attenuare un elevato ritardo di replica tra un'istanza database di origine e le sue repliche di lettura. Puoi modificare le risorse di storage e CPU di una replica in modo indipendente dalla sua origine e dalle altre repliche.
# Creazione di una replica RDS per Oracle in modalità montata
Per impostazione predefinita, le repliche Oracle sono di sola lettura. Per creare una replica in modalità montata, utilizzare la console, AWS CLI o l'API RDS.
## Console
**Per creare una replica montata da un'istanza Oracle DB di origine**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegliere **Databases (Database)**.
1. Scegliere l'istanza Oracle DB che si desidera utilizzare come origine per una replica montata.
1. Per **Actions (Operazioni)**, scegliere **Create replica (Crea replica)**.
1. Per la **modalità Replica**, scegliere **Montato**.
1. Scegliere le impostazioni che si desiderano usare. Per **DB instance identifier (Identificatore istanze DB)** inserire un nome per la replica di lettura. Modificare le altre impostazioni nel modo necessario.
1. Per **Regioni**, scegliere la regione in cui verrà avviata la replica montata.
1. Scegli la dimensione e il tipo di archiviazione dell'istanza. Consigliamo di usare la stessa classe di istanza database e lo stesso tipo di storage dell'istanza database di origine per la replica di lettura.
1. Per **Multi-AZ deployment (Implementazione Multi-AZ)** scegliere **Creare un’istanza di standby** per creare una versione di standby delle replica in un'altra zona di disponibilità per il supporto del failover per la replica montata. La creazione della replica montata come un'istanza database Multi-AZ non dipende dal fatto che il database di origine sia un'istanza database Multi-AZ.
1. Scegliere le altre impostazioni che si desiderano usare.
1. Scegliere **Crea replica**.
Nella pagina **Database** la replica montata ha il ruolo Replica.
## AWS CLI
Per creare una replica Oracle in modalità montata, impostare `--replica-mode` su `mounted` nel comando AWS CLI [create-db-instance-read-replica](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance-read-replica.html).
**Example**
Per Linux, macOS o Unix:
```
aws rds create-db-instance-read-replica \
--db-instance-identifier myreadreplica \
--source-db-instance-identifier mydbinstance \
--replica-mode mounted
```
Per Windows:
```
aws rds create-db-instance-read-replica ^
--db-instance-identifier myreadreplica ^
--source-db-instance-identifier mydbinstance ^
--replica-mode mounted
```
Per modificare una replica di sola lettura in uno stato montato, impostare `--replica-mode` su `mounted` nel comando AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Per posizionare una replica montata in modalità di sola lettura, imposta `--replica-mode` su `open-read-only`.
## API RDS
Per creare una replica Oracle in modalità montata, specificare `ReplicaMode=mounted` nell'operazione API RDS [CreatedBinstancereadReplica](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html).
# Modifica della modalità di replica RDS per Oracle
Per modificare la modalità di replica di una replica esistente, utilizzare la console, AWS CLI o l'API RDS. Quando si passa alla modalità montata, la replica disconnette tutte le connessioni attive. Quando si passa alla modalità di sola lettura, Amazon RDS inizializza Active Data Guard.
L'operazione di modifica può richiedere alcuni minuti. Durante l'operazione, lo stato dell'istanza database cambia in **modifying (modifica)**. Per ulteriori informazioni sulle modifiche di stato, consulta [Visualizzazione dello stato dell'istanza database Amazon RDS ](accessing-monitoring.md#Overview.DBInstance.Status).
## Console
**Per modificare la modalità di replica di una replica Oracle da montata a sola lettura**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegliere **Databases (Database)**.
1. Scegliere il database di replica montato.
1. Scegliere **Modify (Modifica)**.
1. In **Modalità replica**, scegliere **Sola lettura**.
1. Scegliere le altre impostazioni che si desiderano usare.
1. Scegli **Continue (Continua)**.
1. In **Scheduling of Modifications (Pianificazione delle modifiche)**, scegliere **Apply immediately (Applica immediatamente)**.
1. Scegliere **Modify DB Instance (Modifica istanza database)**.
## AWS CLI
Per modificare una replica di lettura in modalità montata, impostare `--replica-mode` su `mounted` nel comando AWS CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html). Per modificare una replica montata in modalità di sola lettura, imposta `--replica-mode` su `open-read-only`.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier myreadreplica \
--replica-mode mode
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier myreadreplica ^
--replica-mode mode
```
## API RDS
Per modificare una replica di sola lettura in modalità montata, impostare `ReplicaMode=mounted` su [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstanceReadReplica.html). Per modificare una replica montata in modalità di sola lettura, impostare `ReplicaMode=read-only`.
# Utilizzo dei backup di repliche RDS per Oracle
È possibile creare e ripristinare i backup di una replica RDS per Oracle. Sono supportati sia i backup automatici che gli snapshot manuali. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md). Le sezioni seguenti descrivono le principali differenze tra la gestione dei backup di una replica primaria e di una replica RDS per Oracle.
## Attivazione di RDS per i backup di repliche Oracle
Per impostazione predefinita, i backup automatici non sono attivati per una replica Oracle. Per attivare i backup automatici, imposta il periodo di conservazione dei backup su un valore diverso da zero positivo.
### Console
**Per abilitare immediatamente i backup automatici**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegli **Database**, quindi scegli l'istanza database o il cluster di database multi-AZ che vuoi modificare.
1. Scegliere **Modify (Modifica)**.
1. In **Periodo di conservazione dei backup**, scegli un valore positivo diverso da zero, ad esempio tre giorni.
1. Scegli **Continue (Continua)**.
1. Scegliere **Apply immediately** (Applica immediatamente).
1. Scegli **Modifica istanza database** o **Modifica cluster** per salvare le modifiche e abilitare i backup automatici.
### AWS CLI
Per abilitare immediatamente i backup automatici, utilizza il comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) o [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html) della AWS CLI.
Includere i seguenti parametri:
+ `--db-instance-identifier` (o `--db-cluster-identifier` per un cluster di database multi-AZ)
+ `--backup-retention-period`
+ `--apply-immediately` o `--no-apply-immediately`
In questo esempio vengono abilitati i backup automatici impostando il periodo di conservazione dei backup su tre giorni. Le modifiche vengono applicate immediatamente.
**Example**
Per Linux, macOS o Unix:
```
aws rds modify-db-instance \
--db-instance-identifier my_db_instance \
--backup-retention-period 3 \
--apply-immediately
```
Per Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier my_db_instance ^
--backup-retention-period 3 ^
--apply-immediately
```
### API RDS
Per abilitare i backup automatici, utilizza l’operazione [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) o [ModifyDBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) dell’API RDS con i seguenti parametri obbligatori:
+ `DBInstanceIdentifier` o `DBClusterIdentifier`
+ `BackupRetentionPeriod`
## Ripristino di un backup di repliche RDS per Oracle
È possibile ripristinare un backup di repliche Oracle così come è possibile ripristinare un backup dell'istanza primaria. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md)
+ [Ripristino di un’istanza database a un punto temporale specifico per Amazon RDS](USER_PIT.md)
Quando si esegue il ripristino di un backup di repliche, è importante determinare il momento in cui eseguire il ripristino. L'ora del database si riferisce all'ora dell'ultima transazione applicata ai dati nel backup. Quando si ripristina un backup di repliche, si esegue il ripristino corrispondente all'ora del database e non al momento in cui il backup è stato completato. La differenza è significativa perché una replica RDS per Oracle può fare riferimento a un'ora più o meno precedente all'ora del database primario. Pertanto, l'ora del database di un backup di repliche, e quindi il momento in cui viene ripristinato, potrebbe essere molto precedente al momento della creazione del backup.
Per trovare la differenza tra l'ora del database e l'ora di creazione, utilizza il comando `describe-db-snapshots`. Confronta `SnapshotDatabaseTime`, ovvero l'ora del database del backup di repliche e il campo `OriginalSnapshotCreateTime`, che è l'ultima transazione applicata al database primario. L'esempio seguente visualizza la differenza tra due ore.
```
aws rds describe-db-snapshots \
--db-instance-identifier my-oracle-replica
--db-snapshot-identifier my-replica-snapshot
{
"DBSnapshots": [
{
"DBSnapshotIdentifier": "my-replica-snapshot",
"DBInstanceIdentifier": "my-oracle-replica",
"SnapshotDatabaseTime": "2022-07-26T17:49:44Z",
...
"OriginalSnapshotCreateTime": "2021-07-26T19:49:44Z"
}
]
}
```
# Esecuzione di uno switchover Oracle Data Guard
Uno *switchover* è un'inversione di ruolo tra un database primario e un database in standby. Durante uno switchover, il database primario originale passa a un ruolo di standby, mentre il database in standby originale passa al ruolo primario.
In un ambiente Oracle Data Guard, un database primario supporta uno o più database in standby. È possibile eseguire una transizione di ruolo gestita e basata sullo switchover da un database primario a un database in standby. Uno *switchover* è un'inversione di ruolo tra un database primario e un database in standby. Durante uno switchover, il database primario originale passa a un ruolo di standby, mentre il database in standby originale passa al ruolo primario.
**Topics**
+ [Panoramica sullo switchover Oracle Data Guard](#oracle-replication-switchover.overview)
+ [Requisiti per lo switchover Oracle Data Guard](oracle-switchover.preparing.md)
+ [Avvio dello switchover Oracle Data Guard](oracle-switchover.initiating.md)
+ [Monitoraggio dello switchover Oracle Data Guard](oracle-switchover.monitoring.md)
## Panoramica sullo switchover Oracle Data Guard
Amazon RDS supporta una transizione di ruolo completamente gestita e basata sullo switchover per le repliche Oracle Database. È possibile avviare uno switchover solo a un database in standby montato o aperto in modalità di sola lettura.
Le repliche possono risiedere in zone di disponibilità separate Regioni AWS o diverse (AZs) di una singola regione. Regioni AWS Sono tutte supportate.
![\[Switchover di un’istanza in standby per convertirla in istanza database primaria\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/read-replica-switchover.png)
Lo switchover è diverso dalla promozione delle repliche di lettura. In uno switchover, le istanze database di origine e di replica si scambiano i ruoli. In una promozione, una replica di lettura diventa un’istanza database di origine, mentre l’istanza database di origine non diventa una replica. Per ulteriori informazioni, consulta [Promozione di una replica di lettura a istanza database standalone](USER_ReadRepl.Promote.md).
**Topics**
+ [Vantaggi dello switchover Oracle Data Guard](#oracle-replication-switchover.overview.benefits)
+ [Versioni di Oracle Database supportate](#oracle-replication-switchover.overview.engine-support)
+ [Costo dello switchover Oracle Data Guard](#oracle-replication-switchover.overview.cost)
+ [Come funziona lo switchover Oracle Data Guard](#oracle-replication-switchover.overview.how-it-works)
### Vantaggi dello switchover Oracle Data Guard
Proprio come per le repliche di lettura RDS per Oracle, uno switchover gestito utilizza Oracle Data Guard. L'operazione è stata ideata in modo da annullare il rischio di perdite di dati. Amazon RDS automatizza i seguenti passaggi dello switchover:
+ Inverte i ruoli del database primario e del database in standby specificato, impostando il nuovo database in standby sullo stesso stato (montato o di sola lettura) del database in standby originale
+ Garantisce la consistenza dei dati
+ Conserva la configurazione di replica dopo la transizione
+ Supporta inversioni ripetute, consentendo al nuovo database in standby di tornare al ruolo primario originale
### Versioni di Oracle Database supportate
Lo switchover di Oracle Data Guard è supportato in Oracle Database versione 19c e successive.
### Costo dello switchover Oracle Data Guard
La funzionalità di switchover di Oracle Data Guard non comporta costi aggiuntivi. Oracle Database Enterprise Edition include il supporto per i database in standby in modalità montata. Per aprire i database in standby in modalità di sola lettura, è necessaria l'opzione Oracle Active Data Guard.
### Come funziona lo switchover Oracle Data Guard
Lo switchover di Oracle Data Guard è un'operazione completamente gestita. Per avviare lo switchover per un database in standby, esegui il comando CLI `switchover-read-replica`. Amazon RDS modifica quindi i ruoli di database primario e in standby nella configurazione di replica.
I ruoli di database *in standby originale* e *primario originale* esistono già prima dello switchover. I ruoli di database *nuovo in standby* e *nuovo primario* esistono dopo lo switchover. Una *replica bystander* è un database di replica che funge da database in standby nell'ambiente Oracle Data Guard e che non cambia ruolo.
**Topics**
+ [Fasi dello switchover Oracle Data Guard](#oracle-replication-switchover.overview.how-it-works.during-switchover)
+ [Dopo lo switchover Oracle Data Guard](#oracle-replication-switchover.overview.how-it-works.after-switchover)
#### Fasi dello switchover Oracle Data Guard
Per effettuare lo switchover, Amazon RDS deve eseguire le seguenti operazioni:
1. Bloccare le nuove transazioni sul database primario originale. Durante lo switchover, Amazon RDS interrompe la replica per tutti i database nella configurazione di Oracle Data Guard in uso. Durante lo switchover, il database primario originale non è in grado di elaborare richieste di scrittura.
1. Inviare e applicare le transazioni non applicate al database di standby originale.
1. Riavviare il nuovo database in standby in modalità di sola lettura o montata. La modalità dipende dallo stato di apertura del database in standby originale prima dello switchover.
1. Aprire il nuovo database primario in read/write modalità.
#### Dopo lo switchover Oracle Data Guard
Amazon RDS scambia i ruoli dei database primario e in standby. Sarà tua la responsabilità di riconnettere l'applicazione e di eseguire qualsiasi altra configurazione desiderata.
**Topics**
+ [Criteri di successo](#oracle-replication-switchover.overview.how-it-works.after-switchover.success)
+ [Connessione al nuovo database primario](#oracle-replication-switchover.overview.how-it-works.after-switchover.connection)
+ [Configurazione del nuovo database primario](#oracle-replication-switchover.overview.how-it-works.after-switchover.success.configuration)
##### Criteri di successo
Lo switchover Oracle Data Guard ha esito positivo quando il database in standby originale esegue le seguenti operazioni:
+ Passaggio al suo ruolo di nuovo database primario
+ Completamento della riconfigurazione
Per ridurre i tempi di inattività, il nuovo database primario diventa attivo il prima possibile. Poiché Amazon RDS configura le repliche bystander in modo asincrono, queste repliche potrebbero diventare attive dopo il database primario originale.
##### Connessione al nuovo database primario
Amazon RDS non propagherà le attuali connessioni di database al nuovo database primario dopo lo switchover. Una volta completato lo switchover Oracle Data Guard, ricollega l'applicazione al nuovo database primario.
##### Configurazione del nuovo database primario
Per effettuare lo switchover al nuovo database primario, Amazon RDS modifica la modalità di apertura del database in standby originale. Il cambio di ruolo è l'unica modifica apportata al database. Amazon RDS non configura le caratteristiche, come la replica Multi-AZ.
Se si esegue lo switchover a una replica tra più regioni con opzioni diverse, il nuovo database primario conserva le proprie opzioni. Amazon RDS non eseguirà la migrazione delle opzioni sul database principale originale. Se il database primario originale aveva opzioni come SSL, NNE, OEM e OEM\$1AGENT, Amazon RDS non le propaga al nuovo database primario.
# Requisiti per lo switchover Oracle Data Guard
Prima di iniziare lo switchover Oracle Data Guard, verifica che il tuo ambiente di replica soddisfi i seguenti requisiti:
+ Il database in standby originale è montato o aperto in modalità di sola lettura.
+ I backup automatici sono abilitati sul database di standby originale.
+ Il database primario e il database in standby originali sono in stato `available`.
+ Il database primario e il database in standby originali non hanno azioni di manutenzione in sospeso in nessuno degli stati seguenti: `required`, `next window` o `in progress`. Le azioni in questi stati bloccano lo switchover. Per informazioni su come verificare lo stato degli aggiornamenti di manutenzione in sospeso, consulta [Visualizzazione degli aggiornamento di manutenzione in sospeso](USER_UpgradeDBInstance.Maintenance.md#USER_UpgradeDBInstance.Maintenance.Viewing).
Le azioni di manutenzione in stato `available` non bloccano lo switchover. RDS per Oracle rilascia spesso aggiornamenti del sistema operativo (OS) in stato `available`. Questi aggiornamenti del sistema operativo in sospeso non bloccano uno switchover a meno che non siano pianificati per la successiva finestra di manutenzione, per la quale viene impostato lo stato `next window`.
**Nota**
Se desideri posticipare un’azione di manutenzione pianificata in modo da poter eseguire uno switchover, scegli **Azioni** e quindi **Rinvia l’aggiornamento** nella console RDS. Puoi anche evitare il blocco di uno switchover applicando un’azione di manutenzione in sospeso o spostando la finestra di manutenzione su un intervallo anteriore allo switchover. Per ulteriori informazioni, consulta l’articolo re:Post [How to remove RDS pending maintenance items](https://repost.aws/questions/QUV3dBjmVVRnmVV1pAlzjx1w/how-to-remove-rds-pending-maintenance-item).
+ Il database in standby originale è nello stato di replica.
+ Non si sta tentando di avviare uno switchover durante un ciclo di vita dello switchover per il database primario o il database in standby. Se un database di replica viene riconfigurato dopo uno switchover, Amazon RDS impedisce di avviare un altro switchover.
**Nota**
Una *replica bystander* è una replica nella configurazione di Oracle Data Guard che non è la destinazione dello switchover. Le repliche bystander possono avere qualsiasi stato durante il passaggio.
+ Il database in standby originale ha una configurazione il più vicino possibile al database primario originale. Si supponga uno scenario in cui i database in standby primario e originale abbiano opzioni diverse. Una volta completato lo switchover, Amazon RDS non riconfigura automaticamente il nuovo database primario in modo che abbia le stesse opzioni del database primario originale.
+ È necessario configurare l'implementazione multi-AZ desiderata prima di avviare uno switchover. Amazon RDS non gestisce multi-AZ come parte dello switchover. L'implementazione multi-AZ rimane così com'è.
Supponi che db\$1maz sia il database principale in un'implementazione multi-AZ e db\$1saz sia una replica single-AZ. Avvii uno switchover da db\$1maz a db\$1saz. Al termine, db\$1maz è un database di replica multi-AZ e db\$1saz è un database primario Single-AZ. Il nuovo database principale ora non è protetto da un'implementazione multi-AZ.
+ In preparazione allo switchover tra regioni, il database principale non utilizza lo stesso gruppo di opzioni di un'istanza database al di fuori della configurazione di replica. Affinché lo switchover tra regioni venga eseguito, il database principale corrente e le relative repliche di lettura devono essere le uniche istanze database a utilizzare il gruppo di opzioni del database principale corrente. In caso contrario, Amazon RDS impedisce lo switchover.
# Avvio dello switchover Oracle Data Guard
È possibile eseguire lo switchover di una replica di lettura RDS per Oracle al ruolo primario e della precedente istanza database primaria a un ruolo di replica.
## Console
**Per eseguire lo switchover di una replica di lettura Oracle al ruolo DB primario**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nella console Amazon RDS scegliere **Databases (Database)**.
Verrà visualizzato il riquadro **Databases (Database)**. Ogni replica di lettura mostra la **Replica** nella colonna **Role (Ruolo)**.
1. Scegli la replica di lettura per cui eseguire lo switchover al ruolo primario.
1. In **Actions** (Operazioni), scegli **Switch over replica** (Esegui switchover replica).
1. Scegli **I acknowledge** (Accetto). Scegli quindi **Switch over replica** (Esegui switchover replica).
1. Nella pagina **Databases** (Database), monitora lo stato di avanzamento dello switchover.
![\[Monitora l'avanzamento dello switchover Oracle Data Guard.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-switchover-progress.png)
Una volta completato lo switchover, il ruolo di destinazione dello switchover cambia da **Replica** a **Source** (Origine).
![\[I database di origine e di replica cambiano ruolo.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-switchover-complete.png)
## AWS CLI
Per eseguire lo switchover di una replica Oracle al ruolo DB primario, utilizza il comando AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/switchover-read-replica.html](https://docs.aws.amazon.com/cli/latest/reference/rds/switchover-read-replica.html). Nei seguenti esempi, la replica Oracle denominata *replica-to-be-made-primary* viene impostata come nuovo database primario.
**Example**
Per Linux, macOS o Unix:
```
aws rds switchover-read-replica \
--db-instance-identifier replica-to-be-made-primary
```
Per Windows:
```
aws rds switchover-read-replica ^
--db-instance-identifier replica-to-be-made-primary
```
## API RDS
Per eseguire lo switchover di una replica Oracle al ruolo database primario, richiama l'operazione [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_SwitchoverReadReplica.html) dell'API RDS con il parametro obbligatorio `DBInstanceIdentifier`. Questo parametro specifica il nome della replica Oracle a cui si desidera assegnare il ruolo di DB primario.
# Monitoraggio dello switchover Oracle Data Guard
Per verificare lo stato delle istanze, utilizza il comando AWS CLI `describe-db-instances`. Il seguente comando verifica lo stato dell'istanza database *orcl2*. Questo database, che era un database in standby prima dello switchover, è il nuovo database primario dopo lo switchover.
```
aws rds describe-db-instances \
--db-instance-identifier orcl2
```
Per confermare il corretto completamento dello switchover, esegui una query su `V$DATABASE.OPEN_MODE`. Verifica che il valore del il nuovo database primario sia `READ WRITE`.
```
SELECT OPEN_MODE FROM V$DATABASE;
```
Per cercare gli eventi relativi allo switchover, usa il comando AWS CLI `describe-events`. L'esempio seguente cerca gli eventi nell'istanza *ocl2*.
```
aws rds describe-events \
--source-identifier orcl2 \
--source-type db-instance
```
# Risoluzione dei problemi relativi alle repliche Oracle
In questa sezione vengono descritti i possibili problemi di replica e le soluzioni.
**Topics**
+ [Monitoraggio del ritardo della replica Oracle](#oracle-read-replicas.troubleshooting.lag)
+ [Risoluzione dei problemi di replica Oracle dopo l'aggiunta o la modifica dei trigger](#oracle-read-replicas.troubleshooting.triggers)
## Monitoraggio del ritardo della replica Oracle
Per monitorare il ritardo di replica in Amazon CloudWatch, visualizza la metrica Amazon `ReplicaLag` RDS. Per ulteriori informazioni sul ritardo della replica, consulta [Monitoraggio della replica di lettura](USER_ReadRepl.Monitoring.md) e [CloudWatch Parametri Amazon per Amazon RDS](rds-metrics.md).
Per una replica di lettura, se il ritardo è troppo lungo, esegui una query nelle visualizzazioni seguenti:
+ `V$ARCHIVED_LOG` – Mostra quali commit sono stati applicati alla replica di lettura.
+ `V$DATAGUARD_STATS` – Mostra un'analisi dettagliata dei componenti che costituiscono il parametro `ReplicaLag`.
+ `V$DATAGUARD_STATUS` – Mostra l'output del log dei processi di interni di replica di Oracle.
Per una replica montata, se il ritardo è troppo lungo, non è possibile eseguire query nelle visualizzazioni `V$`. Effettua invece le seguenti operazioni:
+ Controlla la metrica. `ReplicaLag` CloudWatch
+ Controlla il file di log degli avvisi per la replica nella console. Cerca gli errori nei messaggi di ripristino. I messaggi includono il numero di sequenza di registro, che è possibile confrontare con il numero di sequenza principale. Per ulteriori informazioni, consulta [File di log del database Amazon RDS per Oracle](USER_LogAccess.Concepts.Oracle.md).
## Risoluzione dei problemi di replica Oracle dopo l'aggiunta o la modifica dei trigger
Se si aggiungono o si modificano trigger e se la replica non riesce in seguito, i trigger potrebbero essere il problema. Assicurarsi che il trigger escluda i seguenti utenti, richiesti da RDS per la replica:
+ Account utente con privilegi di amministratore
+ `SYS`
+ `SYSTEM`
+ `RDS_DATAGUARD`
+ `rdsdb`
Per ulteriori informazioni, consulta [Considerazioni varie sulle repliche RDS per Oracle](oracle-read-replicas.limitations.md#oracle-read-replicas.limitations.miscellaneous).
# Redo Transport Compression con RDS per Oracle
Redo Transport Compression di RDS per Oracle consente di migliorare le prestazioni di replica tra l’istanza database primaria e le repliche in standby. Questa funzionalità è particolarmente utile in ambienti con larghezza di banda della rete limitata o connessioni a elevata latenza.
## Acquisizione di una licenza per Redo Transport Compression
Redo Transport Compression fa parte dell’opzione [Oracle Advanced Compression](//www.oracle.com/database/advanced-compression/). Per utilizzare questa funzionalità, è necessaria una licenza valida per l’opzione Oracle Advanced Compression. Per informazioni sulle licenze, contatta il rappresentante Oracle.
## Configurazione di Redo Transport Compression
Per configurare Redo Transport Compression, è possibile utilizzare il parametro `rds.replica.redo_compression`. Questo parametro è disponibile per le versioni 19c e 21c di Oracle.
Il parametro `rds.replica.redo_compression` accetta i seguenti valori:
+ `DISABLE`: valore predefinito che disabilita Redo Transport Compression.
+ `ENABLE`: valore che abilita Redo Transport Compression tramite l’algoritmo [ZLIB](https://zlib.net/) predefinito.
+ `ZLIB`: valore che abilita esplicitamente Redo Transport Compression utilizzando l’algoritmo ZLIB, che fornisce buoni rapporti di compressione.
+ `LZO`: valore che abilita esplicitamente Redo Transport Compression utilizzando l’algoritmo [LZO](https://www.oberhumer.com/opensource/lzo/), che ottimizza la velocità di compressione, in particolare durante la decompressione.
## Considerazioni sulle prestazioni per Redo Transport Compression
Le operazioni di compressione e decompressione consumano risorse della CPU sia sull’istanza primaria che sulle istanze in standby. Se utilizzi Redo Transport Compression, tieni conto dell’utilizzo delle risorse dell’istanza e delle condizioni della rete.
## Argomenti correlati per Redo Transport Compression
Per ulteriori informazioni sulla configurazione di Redo Transport Compression, consulta le seguenti risorse:
+ [Gruppi di parametri database per istanze database Amazon RDS](USER_WorkingWithDBInstanceParamGroups.md)
+ [RedoCompression](https://docs.oracle.com/en/database/oracle/oracle-database/19/dgbkr/oracle-data-guard-broker-properties.html#GUID-5E6DDFD0-6196-48EB-94AF-21A1AFBB7DE1)nelle note di rilascio di Oracle Database 19c
# Aggiunta di opzioni alle istanze database Oracle
In Amazon RDS, una opzione è una funzionalità aggiuntiva. Di seguito, è possibile trovare una descrizione delle opzioni che è possibile aggiungere a istanze Amazon RDS che eseguono il motore database di Oracle.
**Topics**
+ [Panoramica sulle opzioni database Oracle](Appendix.Oracle.Options.overview.md)
+ [Integrazione Amazon S3](oracle-s3-integration.md)
+ [Oracle Application Express (APEX)](Appendix.Oracle.Options.APEX.md)
+ [Integrazione Amazon EFS](oracle-efs-integration.md)
+ [Oracle Java Virtual Machine](oracle-options-java.md)
+ [Oracle Enterprise Manager](Oracle.Options.OEM.md)
+ [Oracle Label Security](Oracle.Options.OLS.md)
+ [Oracle Locator](Oracle.Options.Locator.md)
+ [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md)
+ [Oracle OLAP](Oracle.Options.OLAP.md)
+ [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md)
+ [Oracle Spatial](Oracle.Options.Spatial.md)
+ [Oracle SQLT](Oracle.Options.SQLT.md)
+ [Oracle Statspack](Appendix.Oracle.Options.Statspack.md)
+ [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md)
+ [Aggiornamento automatico dei file di fuso orario Oracle](Appendix.Oracle.Options.Timezone-file-autoupgrade.md)
+ [Oracle Transparent Data Encryption](Appendix.Oracle.Options.AdvSecurity.md)
+ [UTL\$1MAIL di Oracle](Oracle.Options.UTLMAIL.md)
+ [Oracle XML DB](Appendix.Oracle.Options.XMLDB.md)
# Panoramica sulle opzioni database Oracle
Per abilitare queste opzioni per database Oracle, dovrai aggiungerle a un gruppo di opzioni e quindi associare il gruppo di opzioni all'istanza database. Per ulteriori informazioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md).
**Topics**
+ [Riepilogo delle opzioni database Oracle](#Appendix.Oracle.Options.summary)
+ [Opzioni supportate per diverse edizioni](#Appendix.Oracle.Options.editions)
+ [Requisiti di memoria per opzioni specifiche](#Appendix.Oracle.Options.memory)
## Riepilogo delle opzioni database Oracle
Puoi aggiungere le seguenti opzioni per le istanze database Oracle.
****
| Opzione | ID opzione |
| --- | --- |
| [Integrazione Amazon S3](oracle-s3-integration.md) | `S3_INTEGRATION` |
| [Oracle Application Express (APEX)](Appendix.Oracle.Options.APEX.md) | `APEX` `APEX-DEV` |
| [Oracle Enterprise Manager](Oracle.Options.OEM.md) | `OEM` `OEM_AGENT` |
| [Oracle Java Virtual Machine](oracle-options-java.md) | `JVM` |
| [Oracle Label Security](Oracle.Options.OLS.md) | `OLS` |
| [Oracle Locator](Oracle.Options.Locator.md) | `LOCATOR` |
| [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md) | `NATIVE_NETWORK_ENCRYPTION` |
| [Oracle OLAP](Oracle.Options.OLAP.md) | `OLAP` |
| [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md) | `SSL` |
| [Oracle Spatial](Oracle.Options.Spatial.md) | `SPATIAL` |
| [Oracle SQLT](Oracle.Options.SQLT.md) | `SQLT` |
| [Oracle Statspack](Appendix.Oracle.Options.Statspack.md) | `STATSPACK` |
| [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md) | `Timezone` |
| [Aggiornamento automatico dei file di fuso orario Oracle](Appendix.Oracle.Options.Timezone-file-autoupgrade.md) | `TIMEZONE_FILE_AUTOUPGRADE` |
| [Oracle Transparent Data Encryption](Appendix.Oracle.Options.AdvSecurity.md) | `TDE` |
| [UTL\$1MAIL di Oracle](Oracle.Options.UTLMAIL.md) | `UTL_MAIL` |
| [Oracle XML DB](Appendix.Oracle.Options.XMLDB.md) | `XMLDB` |
## Opzioni supportate per diverse edizioni
RDS per Oracle impedisce di aggiungere opzioni a un'edizione se non sono supportate. Per scoprire quali opzioni RDS sono supportate in diverse edizioni del database Oracle, utilizzare il comando `aws rds describe-option-group-options`. Nell'esempio seguente vengono elencate le opzioni supportate per il database Oracle 19c Enterprise Edition.
```
aws rds describe-option-group-options \
--engine-name oracle-ee \
--major-engine-version 19
```
Per ulteriori informazioni, consulta [describe-option-group-options](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-option-group-options.html) nel *Riferimento ai comandi CLI AWS*.
## Requisiti di memoria per opzioni specifiche
L'esecuzione di alcune opzioni nella tua istanza database richiede memoria aggiuntiva. Ad esempio, Oracle Enterprise Manager Database Control utilizza circa 300 MB di RAM. Se abiliti questa opzione per una istanza database di piccole dimensioni, potresti riscontrare problemi di prestazioni dovuti ai limiti di memoria. Puoi regolare i parametri Oracle in modo che il database richieda meno RAM. In alternativa, puoi dimensionare l'istanza database aumentandone le dimensioni.
# Integrazione Amazon S3
Puoi trasferire i file tra un'istanza database Amazon RDS per Oracle e un bucket Amazon S3. Puoi utilizzare l'integrazione Amazon S3 con le funzionalità Oracle Database, ad esempio Oracle Data Pump. Ad esempio, è possibile scaricare i file di Data Pump da Amazon S3 sull'istanza database RDS per Oracle. Per ulteriori informazioni, consulta [Importazione di dati in Oracle in Amazon RDS](Oracle.Procedural.Importing.md).
**Nota**
L'istanza database e il bucket Amazon S3 devono trovarsi nella stessa Regione AWS.
**Topics**
+ [Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3](oracle-s3-integration.preparing.md)
+ [Aggiunta dell'opzione di integrazione Amazon S3](oracle-s3-integration.preparing.option-group.md)
+ [Trasferimento dei file tra Amazon RDS for Oracle e un bucket Amazon S3](oracle-s3-integration.using.md)
+ [Risoluzione dei problemi di integrazione Amazon S3](#oracle-s3-integration.troubleshooting)
+ [Rimozione dell'opzione di integrazione Amazon S3](oracle-s3-integration.removing.md)
# Configurazione delle autorizzazioni IAM per l'integrazione di RDS per Oracle con Amazon S3
Affinché RDS per Oracle si integri con Amazon S3, l'istanza database avere accesso a un bucket Amazon S3. Il Amazon VPC utilizzato dall'istanza database non deve fornire accesso agli endpoint Amazon S3.
RDS per Oracle supporta il trasferimento di file tra un’istanza database in un account e un bucket Amazon S3 in un account diverso. Se sono necessari ulteriori passaggi, vengono annotati nelle sezioni seguenti.
**Topics**
+ [Fase 3: creazione di una policy IAM per il ruolo di Amazon RDS](#oracle-s3-integration.preparing.policy)
+ [Fase 2: (facoltativo) creazione di una policy IAM per il bucket Amazon S3](#oracle-s3-integration.preparing.policy-bucket)
+ [Fase 3: creazione di un ruolo IAM per l'istanza database e collegamento della policy](#oracle-s3-integration.preparing.role)
+ [Fase 4: associazione del ruolo IAM all'istanza database RDS per Oracle](#oracle-s3-integration.preparing.instance)
## Fase 3: creazione di una policy IAM per il ruolo di Amazon RDS
In questo passaggio, crei una policy AWS Identity and Access Management (IAM) con le autorizzazioni necessarie per trasferire file tra il bucket Amazon S3 e l'istanza DB RDS. Questo passaggio presuppone che tu abbia già creato un bucket S3.
Prima di creare la policy, prendi nota delle seguenti informazioni:
+ L'Amazon Resource Name (ARN) del bucket
+ L'ARN per la tua AWS KMS chiave, se il bucket utilizza la crittografia SSE-KMS o SSE-S3
**Nota**
Un'istanza database RDS per Oracle non può accedere ai bucket Amazon S3 crittografati con SSE-C.
Per ulteriori informazioni, consulta [Protezione dei dati con la crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
### Console
**Per creare una policy IAM per consentire ad Amazon RDS l'accesso a un bucket Amazon S3**
1. Aprire la [console di gestione IAM](https://console.aws.amazon.com/iam/home?#home).
1. In **Gestione accessi** scegli **Policy**.
1. Scegli **Crea policy**.
1. Nella scheda **Visual editor (Editor visivo)** selezionare **Choose a service (Scegli un servizio)** e quindi **S3**.
1. Per **Operazioni**, seleziona **Espandi tutto**, quindi sceglie le autorizzazioni del bucket e dell’oggetto necessarie per trasferire i file da un bucket Amazon S3 a Amazon RDS. Ad esempio, completa le seguenti operazioni:
+ **Espandi** Elenco, **ListBucket**quindi seleziona.
+ Espandi **Leggi**, quindi seleziona **GetObject**.
+ Espandi **Scrittura**, quindi seleziona **PutObject**DeleteObject****, **AbortMultipartUpload**, e **ListMultipartUploadParts**. Le autorizzazioni per il caricamento in più parti sono necessarie per caricare file di grandi dimensioni (100 MB o più) su Amazon S3.
+ Espandi **Gestione delle autorizzazioni**, quindi seleziona **PutObjectAcl**. Questa autorizzazione è necessaria se si prevede di caricare file in un bucket di proprietà di un account diverso e questo account ha bisogno del pieno controllo del contenuto del bucket.
Le *autorizzazioni oggetto* sono autorizzazioni per operazioni sugli oggetti in Amazon S3. Devi concedere queste autorizzazioni agli oggetti presenti nel bucket e non al bucket stesso. Per ulteriori informazioni, consulta la pagina [Autorizzazioni per le operazioni sugli oggetti](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-with-s3-actions.html#using-with-s3-actions-related-to-objects).
1. Scegli **Aggiungi regola**, quindi effettua le seguenti operazioni:
1. Scegli **Specifiche**.
1. In **Bucket**, scegli **Aggiungi ARN**. Inserisci l'ARN del bucket. Il nome del bucket viene inserito automaticamente. Quindi scegliere **Add (Aggiungi)**.
1. Se viene visualizzata la risorsa **oggetto**, scegli **Aggiungi ARN** per aggiungere risorse manualmente o scegli **Qualsiasi**.
**Nota**
È possibile impostare **Amazon Resource Name (ARN)** su un valore dell'ARN più specifico in modo da consentire ad Amazon RDS di accedere solo a specifici file o cartelle presenti in un bucket Amazon S3. Per ulteriori informazioni su come definire una policy di accesso per Amazon S3, consulta [Gestione delle autorizzazioni di accesso alle risorse Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
1. (Facoltativo) Scegli **Aggiungi autorizzazioni aggiuntive** per aggiungere risorse alla policy. Ad esempio, completa le seguenti operazioni:
1. Se il bucket è crittografato con una chiave KMS personalizzata, seleziona **KMS** per il servizio.
1. In **Operazioni manuali**, seleziona quanto segue:
+ **Encrypt**
+ **ReEncrypt da** **e per ReEncrypt **
+ **Decrypt**
+ **DescribeKey**
+ **GenerateDataKey**
1. In **Risorse**, scegli **Specifiche**.
1. In **Chiave**, scegli **Aggiungi ARN**. Specifica l'ARN della chiave personalizzata come risorsa, quindi scegli **Aggiungi**.
Per ulteriori informazioni, consulta [Protezione dei dati utilizzando la crittografia lato server con chiavi KMS archiviate in AWS Key Management Service (SSE-KMS) nella Guida per l'utente di Amazon Simple](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) *Storage Service*.
1. Se desideri che Amazon RDS acceda per accedere ad altri bucket, aggiungi ARNs i relativi bucket. Facoltativamente, è anche possibile concedere l'accesso a tutti i bucket e gli oggetti in Amazon S3.
1. Scegliere **Next: Tags (Successivo: Tag)** e **Next: Review (Successivo: Verifica)**.
1. Per **Name (Nome)**, immettere un nome per la policy IAM, ad esempio `rds-s3-integration-policy`. Questo nome viene utilizzato quando si crea un ruolo IAM e lo si associa all'istanza database. È anche possibile aggiungere un valore **Description (Descrizione)** facoltativo.
1. Seleziona **Create Policy** (Crea policy).
### AWS CLI
Crea una policy AWS Identity and Access Management (IAM) che conceda ad Amazon RDS l'accesso a un bucket Amazon S3. Dopo aver creato la policy, prendere nota del relativo ARN. L'ARN servirà in una fase successiva.
Includi le azioni appropriate nella policy in base al tipo di accesso richiesto:
+ `GetObject` – È necessario trasferire i file da un bucket Amazon S3 a Amazon RDS.
+ `ListBucket` – È necessario trasferire i file da un bucket Amazon S3 a Amazon RDS.
+ `PutObject` – È necessario trasferire i file da un bucket Amazon RDS a un bucket Amazon S3.
+ `AbortMultipartUpload`: è necessario per i caricamenti in più parti durante il trasferimento di file di grandi dimensioni (100 MB o più) da Amazon RDS a un bucket Amazon S3.
+ `ListMultipartUploadParts`: è necessario per i caricamenti in più parti durante il trasferimento di file di grandi dimensioni (100 MB o più) da Amazon RDS a un bucket Amazon S3.
Il AWS CLI comando seguente crea una policy IAM denominata `rds-s3-integration-policy` con queste opzioni. Concede l'accesso a un bucket denominato `amzn-s3-demo-bucket`.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-policy \
--policy-name rds-s3-integration-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
Nell'esempio seguente sono incluse le autorizzazioni per le chiavi KMS personalizzate.
```
aws iam create-policy \
--policy-name rds-s3-integration-policy \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"kms:Decrypt",
"kms:Encrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey",
"kms:DescribeKey",
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:::your-kms-arn"
]
}
]
}'
```
Per Windows:
```
aws iam create-policy ^
--policy-name rds-s3-integration-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}'
```
Nell'esempio seguente sono incluse le autorizzazioni per le chiavi KMS personalizzate.
```
aws iam create-policy ^
--policy-name rds-s3-integration-policy ^
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "s3integration",
"Action": [
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"kms:Decrypt",
"kms:Encrypt",
"kms:ReEncrypt",
"kms:GenerateDataKey",
"kms:DescribeKey",
],
"Effect": "Allow",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:::your-kms-arn"
]
}
]
}'
```
## Fase 2: (facoltativo) creazione di una policy IAM per il bucket Amazon S3
Questo passaggio è necessario solo nelle seguenti condizioni:
+ Prevedi di caricare i file su un bucket Amazon S3 da un account (account A) e di accedervi da un altro account (account B).
+ L'account B possiede il bucket.
+ L'account B necessita del pieno controllo degli oggetti caricati nel bucket.
Se le condizioni precedenti non si applicano al tuo scenario, passa a [Fase 3: creazione di un ruolo IAM per l'istanza database e collegamento della policy](#oracle-s3-integration.preparing.role).
Per creare la policy per il bucket, assicurati di disporre di quanto segue:
+ L'ID account dell'account A.
+ Il nome utente dell'account A
+ Il valore ARN per il bucket Amazon S3 nell'account B
### Console
**Per creare o modificare una policy del bucket**
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nell'elenco **Buckets (Bucket)** scegliere il nome del bucket per il quale si desidera creare o modificare una policy di bucket.
1. Seleziona **Autorizzazioni**.
1. In **Policy del bucket**, scegli **Modifica**. Verrà visualizzata la pagina Modifica policy del bucket.
1. Nella pagina **Edit bucket policy (Modifica policy del bucket) **vai negli **Esempi di policy** della *Guida per l'utente di Amazon S3* e scegli **Policy generator (Generatore di policy)** per generare automaticamente una policy o modificare il JSON nella sezione **Policy**.
Se scegli **Policy generator**, il AWS Policy Generator si apre in una nuova finestra:
1. Nella pagina **Generatore di policy di AWS**, all'opzione **Seleziona tipo di Policy**, scegli **Policy del bucket S3**.
1. Aggiungi un'istruzione inserendo le informazioni nei campi forniti, quindi scegli **Aggiungi istruzione**. Ripetere per tutte le istruzioni che si desidera aggiungere. Per ulteriori informazioni su questi campi, consulta [Riferimento agli elementi delle policy IAM JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) nella *Guida per l'utente IAM*.
**Nota**
Per comodità, la pagina **Modifica policy del bucket** mostra l'**ARN (Amazon Resource Name) del bucket** corrente sopra il campo di testo della **Policy**. Puoi copiare questo ARN per utilizzarlo nelle istruzioni alla pagina **Generatore di policy di AWS**.
1. Dopo aver aggiunto le istruzioni, scegli **Genera policy**.
1. Copia il testo della policy generata, scegli **Chiudi** e torna alla pagina **Modifica policy del bucket** nella console di Amazon S3.
1. Nella casella **Policy**, modificare la policy esistente o incollare la policy del bucket dal generatore di policy. Assicurati di risolvere gli avvisi di sicurezza, gli errori, gli avvisi generali e i suggerimenti prima di salvare la policy.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "ExamplePermissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:user/account-A-user"
},
"Action": [
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket",
"arn:aws:s3:::amzn-s3-demo-destination-bucket/*"
]
}
]
}
```
------
1. Scegli **Salva le modifiche**, che ti riporterà alla pagina Autorizzazioni bucket.
## Fase 3: creazione di un ruolo IAM per l'istanza database e collegamento della policy
Questo passaggio presuppone che tu abbia creato la policy IAM in [Fase 3: creazione di una policy IAM per il ruolo di Amazon RDS](#oracle-s3-integration.preparing.policy). In questo passaggio, si crea un ruolo per l'istanza database RDS per Oracle e quindi si collega la policy al ruolo.
### Console
**Per creare un ruolo IAM per consentire ad Amazon RDS l'accesso a un bucket Amazon S3**
1. Aprire la [console di gestione IAM](https://console.aws.amazon.com/iam/home?#home).
1. Nel pannello di navigazione, seleziona **Roles** (Ruoli).
1. Selezionare **Create role (Crea ruolo)**.
1. Scegli un servizio in **Servizio AWS**.
1. Per i **casi d'uso per altri AWS servizi:**, scegli **RDS** e poi **RDS — Aggiungi ruolo al database**. Quindi scegli **Successivo**.
1. In **Cerca**, in **Policy di autorizzazione**, inserisci il nome della policy IAM creata in [Fase 3: creazione di una policy IAM per il ruolo di Amazon RDS](#oracle-s3-integration.preparing.policy) e seleziona la policy quando viene visualizzata nell'elenco. Quindi scegli **Successivo**.
1. In **Nome ruolo**, specifica un nome per il ruolo IAM, ad esempio `rds-s3-integration-role`. È anche possibile aggiungere un valore **Description (Descrizione)** facoltativo.
1. Scegli **Crea ruolo**.
### AWS CLI
**Per creare un ruolo e collegarvi una policy**
1. Creare un ruolo IAM che Amazon RDS può assumere per conto dell'utente per accedere ai bucket Amazon S3.
Si consiglia di utilizzare le chiavi di contesto delle condizioni globali [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) nelle relazioni di trust basate sulle risorse per limitare le autorizzazioni del servizio relative a una risorsa specifica. Questo è il modo più efficace per proteggersi dal [problema di deputy confused](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Puoi usare le chiavi di contesto delle condizioni globali e avere il valore `aws:SourceArn` che contiene l'ID dell'account. In questo caso, il valore `aws:SourceAccount` e l'account nel valore `aws:SourceArn` deve utilizzare lo stesso ID account quando viene utilizzato nella stessa istruzione.
+ Utilizzare `aws:SourceArn` se si desidera un accesso cross-service per una singola risorsa.
+ Utilizzare `aws:SourceAccount` se si desidera consentire l'associazione di qualsiasi risorsa in tale account all'uso cross-service.
Nella relazione di trust, assicurati di utilizzare la chiave di contesto della condizione globale `aws:SourceArn` con l'Amazon Resource Name (ARN) completo delle risorse che accedono al ruolo.
Il AWS CLI comando seguente crea il ruolo denominato `rds-s3-integration-role` per questo scopo.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-role \
--role-name rds-s3-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "my_account_ID",
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
Per Windows:
```
aws iam create-role ^
--role-name rds-s3-integration-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "my_account_ID",
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
Per ulteriori informazioni, consulta la pagina relativa alla [creazione di un ruolo per delegare le autorizzazioni a un utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) nella *Guida per l'utente IAM*.
1. Una volta creato il ruolo, annota l'ARN del ruolo. L'ARN servirà in una fase successiva.
1. Collega la policy creata al ruolo creato.
Il AWS CLI comando seguente associa la policy al ruolo denominato`rds-s3-integration-role`.
**Example**
Per Linux, macOS o Unix:
```
aws iam attach-role-policy \
--policy-arn your-policy-arn \
--role-name rds-s3-integration-role
```
Per Windows:
```
aws iam attach-role-policy ^
--policy-arn your-policy-arn ^
--role-name rds-s3-integration-role
```
Sostituire `your-policy-arn` con l'ARN della policy annotato nel passaggio precedente.
## Fase 4: associazione del ruolo IAM all'istanza database RDS per Oracle
L'ultimo passaggio per configurare le autorizzazioni per l'integrazione di Amazon S3 prevede l'associazione del ruolo IAM all'istanza database. Si notino i requisiti seguenti:
+ Devi disporre dell'accesso a un ruolo a cui sono collegate le policy di autorizzazione di Amazon S3.
+ È possibile associare un solo ruolo IAM alla volta all'istanza RDS per Oracle.
+ Lo stato dell'istanza database deve essere **Disponibile**.
### Console
**Per associare il ruolo IAM all'istanza database RDS per Oracle**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione seleziona **Database**.
1. Scegli il nome dell'istanza database RDS per Oracle per visualizzarne i dettagli.
1. Sulla scheda **Connettività e sicurezza**, scorri verso il basso fino alla sezione **Gestisci i ruoli IAM** in fondo alla pagina.
1. Per **Aggiungi i ruoli IAM a questa istanza**, scegli il ruolo creato in [Fase 3: creazione di un ruolo IAM per l'istanza database e collegamento della policy](#oracle-s3-integration.preparing.role).
1. Per **Feature (Caratteristica)**, selezionare **S3\$1INTEGRATION**.
![\[Aggiungi ruolo S3_INTEGRATION\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/ora-s3-integration-role.png)
1. Scegliere **Add role (Aggiungi ruolo)**.
### AWS CLI
Il AWS CLI comando seguente aggiunge il ruolo a un'istanza Oracle DB denominata`mydbinstance`.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier mydbinstance \
--feature-name S3_INTEGRATION \
--role-arn your-role-arn
```
Per Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name S3_INTEGRATION ^
--role-arn your-role-arn
```
Sostituire `your-role-arn` con il ruolo ARN annotato nel passaggio precedente. `S3_INTEGRATION` deve essere specificato per l'opzione `--feature-name`.
# Aggiunta dell'opzione di integrazione Amazon S3
Per utilizzare l'integrazione tra Amazon RDS per Oracle e Amazon S3, l'istanza database deve essere associata a un gruppo di opzioni che include l'opzione `S3_INTEGRATION`.
## Console
**Per configurare un gruppo di opzioni per l'integrazione Amazon S3**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `S3_INTEGRATION`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `S3_INTEGRATION` al gruppo di opzioni.
Per informazioni sull'aggiunta di un'opzione a un gruppo di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Crea una nuova istanza database RDS per Oracle e associarvi il gruppo opzioni oppure modificare un'istanza database RDS per Oracle per associare il gruppo opzioni a essa.
Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
Per ulteriori informazioni sulla modifica di un'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## AWS CLI
**Per configurare un gruppo di opzioni per l'integrazione Amazon S3**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `S3_INTEGRATION`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `S3_INTEGRATION` al gruppo di opzioni.
Ad esempio, il comando seguente AWS CLI aggiunge l'opzione `S3_INTEGRATION` a un gruppo opzioni denominato **myoptiongroup**.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name myoptiongroup \
--options OptionName=S3_INTEGRATION,OptionVersion=1.0
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name myoptiongroup ^
--options OptionName=S3_INTEGRATION,OptionVersion=1.0
```
1. Crea una nuova istanza database RDS per Oracle e associarvi il gruppo opzioni oppure modificare un'istanza database RDS per Oracle per associare il gruppo opzioni a essa.
Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
Per informazioni sulla modifica di un'istanza database RDS per Oracle, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Trasferimento dei file tra Amazon RDS for Oracle e un bucket Amazon S3
Puoi utilizzare il package Amazon RDS `rdsadmin_s3_tasks` per trasferire file tra un'istanza database RDS per Oracle e un bucket Amazon S3. È possibile comprimere i file con GZIP al momento del caricamento e decomprimerli al momento del download.
**Topics**
+ [Requisiti e limitazioni per i trasferimenti di file](#oracle-s3-integration.using.reqs)
+ [Caricamento di file da un'istanza database Oracle a un bucket Amazon S3](#oracle-s3-integration.using.upload)
+ [Download di file da un bucket Amazon S3 a un'istanza database Oracle](#oracle-s3-integration.using.download)
+ [Monitoraggio dello stato di un file transfer](#oracle-s3-integration.using.task-status)
## Requisiti e limitazioni per i trasferimenti di file
Prima di trasferire i file tra un’istanza database e un bucket Amazon S3, tieni presente quanto segue:
+ Il pacchetto `rdsadmin_s3_tasks` trasferisce i file presenti in una singola directory. Non puoi includere sottodirectory in un trasferimento.
+ La dimensione massima dell'oggetto in un bucket Amazon S3 è di 5 TB.
+ Le attività create da `rdsadmin_s3_tasks` vengono eseguite in modo asincrono.
+ Puoi caricare i file dalla directory Data Pump, ad esempio `DATA_PUMP_DIR`, o da qualsiasi directory creata dall’utente. Non puoi caricare file da una directory utilizzata dai processi in background di Oracle, ad esempio le directory `adump`, `bdump` o `trace`.
+ Per `download_from_s3`, il limite di scaricamento è pari a 2000 file per ogni chiamata della procedura. Se devi scaricare più di 2000 file da Amazon S3, suddividi il processo di scaricamento in operazioni distinte contenenti non più di 2000 file per chiamata.
+ Se esiste un file nella cartella di scaricamento e si tenta di scaricare un file con lo stesso nome, `download_from_s3` ignora lo scaricamento del file in questione. Per rimuovere un file dalla directory di download, utilizzare la PL/SQL procedura [UTL\$1FILE.FREMOVE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/UTL_FILE.html#GUID-09B09C2A-2C21-4F70-BF04-D0EEA7B59CAF).
## Caricamento di file da un'istanza database Oracle a un bucket Amazon S3
Per caricare i file da un'istanza database a un bucket Amazon S3, utilizza la procedura `rdsadmin.rdsadmin_s3_tasks.upload_to_s3`. Ad esempio, è possibile caricare i file di backup di Oracle Recovery Manager (RMAN) o i file di Oracle Data Pump. Per informazioni sull'utilizzo di oggetti, consulta [Guida per l'utente di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingObjects.html). Per ulteriori informazioni sull'esecuzione dei backup RMAN, consulta [Esecuzione di attività RMAN comuni per le istanze database Oracle](Appendix.Oracle.CommonDBATasks.RMAN.md).
La procedura `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Description |
| --- | --- | --- | --- | --- |
| `p_bucket_name` | VARCHAR2 | – | obbligatorio | Il nome del bucket Amazon S3 in cui caricare i file. |
| `p_directory_name` | VARCHAR2 | – | obbligatorio | Il nome dell'oggetto directory Oracle da cui caricare i file. La directory può essere un qualsiasi oggetto directory creato dall'utente o directory Data Pump, come `DATA_PUMP_DIR`. Non puoi caricare file da una directory utilizzata dai processi in background, ad esempio `adump`, `bdump` o `trace`. È possibile solo caricare i file dalla directory specificata. NOn è possibile caricare i file nelle sottodirectory nella directory specificata. |
| `p_s3_prefix` | VARCHAR2 | – | obbligatorio | Un prefisso del nome file Amazon S3 con cui vengono caricati i file. Un prefisso vuoto carica tutti i file al livello superiore nel bucket Amazon S3 specificato e non aggiunge un prefisso ai nomi file. Ad esempio, se il prefisso è `folder_1/oradb`, i file vengono caricati su `folder_1`. In questo caso, il prefisso `oradb` viene aggiunto a ogni file. |
| `p_prefix` | VARCHAR2 | – | obbligatorio | Un prefisso nome file con cui i nomi file devono corrispondere per essere caricati. Un prefisso vuoto carica tutti i file nella directory specificata. |
| `p_compression_level` | NUMBER | `0` | facoltativo | Il livello di compressione GZIP. I valori validi sono compresi tra `0` e `9`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/oracle-s3-integration.using.html) |
| `p_bucket_owner_full_control` | VARCHAR2 | – | facoltativo | L'impostazione di controllo degli accessi per il bucket. Gli unici valori validi sono null o `FULL_CONTROL`. Questa impostazione è necessaria solo se si caricano file da un account (account A) in un bucket di proprietà di un account diverso (account B) e l'account B ha bisogno del pieno controllo dei file. |
Il valore restituito per la procedura `rdsadmin.rdsadmin_s3_tasks.upload_to_s3` è un ID attività.
L'esempio seguente carica tutti i file nella directory `DATA_PUMP_DIR` nel bucket Amazon S3 denominato *amzn-s3-demo-bucket*. I file non vengono compressi.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'esempio seguente carica tutti i file con prefisso `db` nella directory `DATA_PUMP_DIR` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket`. Amazon RDS applica ai file il livello di compressione GZIP più alto.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => 'db',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR',
p_compression_level => 9)
AS TASK_ID FROM DUAL;
```
L'esempio seguente carica tutti i file nella directory `DATA_PUMP_DIR` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket`. I file vengono caricati in una cartella `dbfiles`. In questo esempio, il livello di compressione GZIP è*1*, che è il livello di compressione più veloce.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => 'dbfiles/',
p_directory_name => 'DATA_PUMP_DIR',
p_compression_level => 1)
AS TASK_ID FROM DUAL;
```
L'esempio seguente carica tutti i file nella directory `DATA_PUMP_DIR` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket`. I file vengono caricati in una cartella `dbfiles` e `ora` viene aggiunto all'inizio di ogni nome file. Non viene applicata alcuna compressione.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_prefix => '',
p_s3_prefix => 'dbfiles/ora',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'esempio seguente presuppone che il comando sia eseguito nell'account A, ma l'account B richiede il pieno controllo del contenuto del bucket. Il comando `rdsadmin_s3_tasks.upload_to_s3` trasferisce tutti i file nella directory `DATA_PUMP_DIR` al bucket denominato `s3bucketOwnedByAccountB`. Il controllo degli accessi è impostato su `FULL_CONTROL` in modo che l'account B possa accedere ai file nel bucket. Il livello di compressione GZIP è*6*, che bilancia velocità e dimensione del file.
```
SELECT rdsadmin.rdsadmin_s3_tasks.upload_to_s3(
p_bucket_name => 's3bucketOwnedByAccountB',
p_prefix => '',
p_s3_prefix => '',
p_directory_name => 'DATA_PUMP_DIR',
p_bucket_owner_full_control => 'FULL_CONTROL',
p_compression_level => 6)
AS TASK_ID FROM DUAL;
```
In ogni esempio, l'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`.
È possibile visualizzare il risultato visualizzando il file di output dell'attività.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
Sostituire *`task-id`* con l'ID attività restituito dalla procedura.
**Nota**
Le attività vengono eseguite in modo asincrono.
## Download di file da un bucket Amazon S3 a un'istanza database Oracle
Per scaricare i file da un bucket Amazon S3 a un'istanza database RDS per Oracle, utilizza la procedura Amazon RDS `rdsadmin.rdsadmin_s3_tasks.download_from_s3`.
La procedura `download_from_s3` include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Description |
| --- | --- | --- | --- | --- |
| `p_bucket_name` | VARCHAR2 | – | Richiesto | Il nome del bucket Amazon S3 da cui scaricare i file. |
| `p_directory_name` | VARCHAR2 | – | Richiesto | Il nome dell'oggetto directory Oracle su cui scaricare i file. La directory può essere un qualsiasi oggetto directory creato dall'utente o directory Data Pump, come `DATA_PUMP_DIR`. |
| `p_error_on_zero_downloads` | VARCHAR2 | FALSE | Facoltativo | Un flag che determina se l'attività genera un errore quando nessun oggetto nel bucket Amazon S3 corrisponde al prefisso. Se questo parametro non è impostato o è impostato su FALSE (impostazione predefinita), l'attività stampa un messaggio che indica che non è stato trovato alcun oggetto, ma non genera un'eccezione o un errore. Se questo parametro è TRUE, l'attività genera un'eccezione e non riesce. Esempi di specifiche dei prefissi che possono non riuscire nei test di corrispondenza sono gli spazi nei prefissi, come in `' import/test9.log'`, e le mancate corrispondenze tra maiuscole e minuscole, come in `test9.log` e `test9.LOG`. |
| `p_s3_prefix` | VARCHAR2 | – | Richiesto | Un prefisso nome file con cui i nomi file devono corrispondere per essere scaricati. Un prefisso vuoto scarica tutti i file di livello superiore nel bucket Amazon S3 specificato, ma non i file nelle cartelle nel bucket. La procedura scarica gli oggetti Amazon S3 solo dalla cartella di primo livello che corrisponde al prefisso. Le strutture directory nidificate corrispondenti al prefisso specificato non vengono scaricate. Ad esempio, si supponga che un bucket Amazon S3 abbia la struttura della cartella `folder_1/folder_2/folder_3`. Specifica il prefisso `'folder_1/folder_2/'`. In questo caso, vengono scaricati solo i file in `folder_2`, non i file in `folder_1` o `folder_3`. Se, invece, viene specificato il prefisso `'folder_1/folder_2'`, tutti i file in `folder_1` che corrispondono al prefisso `'folder_2'` vengono scaricati, mentre i file in `folder_2` non vengono scaricati. |
| `p_decompression_format` | VARCHAR2 | – | Facoltativo | Il formato di decompressione. I valori validi sono `NONE` per non eseguire la decompressione e `GZIP` per eseguire la decompressione. |
Il valore restituito per la procedura `rdsadmin.rdsadmin_s3_tasks.download_from_s3` è un ID attività.
L'esempio seguente scarica tutti i file nel bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`. I file non sono compressi, quindi non viene applicata alcuna decompressione.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
L'esempio seguente scarica tutti i file con prefisso `db` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`. I file non sono compressi, quindi non viene applicata alcuna decompressione. Il parametro `p_error_on_zero_downloads` attiva il controllo degli errori dei prefissi, quindi se il prefisso non corrisponde a nessun file nel bucket, l'attività genera un'eccezione e non riesce.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'db',
p_directory_name => 'DATA_PUMP_DIR',
p_decompression_format => 'GZIP',
p_error_on_zero_downloads => 'TRUE')
AS TASK_ID FROM DUAL;
```
L'esempio seguente scarica tutti i file nella cartella `myfolder/` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`. Utilizzare il parametro `p_s3_prefix` per specificare la cartella Amazon S3. I file caricati vengono compressi con GZIP, ma non vengono decompressi durante il download.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'myfolder/',
p_directory_name => 'DATA_PUMP_DIR',
p_decompression_format => 'NONE')
AS TASK_ID FROM DUAL;
```
L'esempio seguente scarica il file `mydumpfile.dmp` nel bucket Amazon S3 denominato `amzn-s3-demo-bucket` nella directory `DATA_PUMP_DIR`. Non viene applicata alcuna decompressione.
```
SELECT rdsadmin.rdsadmin_s3_tasks.download_from_s3(
p_bucket_name => 'amzn-s3-demo-bucket',
p_s3_prefix => 'mydumpfile.dmp',
p_directory_name => 'DATA_PUMP_DIR')
AS TASK_ID FROM DUAL;
```
In ogni esempio, l'istruzione `SELECT` restituisce l'ID dell'attività in un tipo di dati `VARCHAR2`.
È possibile visualizzare il risultato visualizzando il file di output dell'attività.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
Sostituire *`task-id`* con l'ID attività restituito dalla procedura.
**Nota**
Le attività vengono eseguite in modo asincrono.
Per rimuovere i file da una directory, è possibile utilizzare la procedura Oracle `UTL_FILE.FREMOVE`. Per ulteriori informazioni, consulta la sezione relativa alla [Procedura FREMOVE](https://docs.oracle.com/database/121/ARPLS/u_file.htm#ARPLS70924) nella documentazione di Oracle.
## Monitoraggio dello stato di un file transfer
Le attività di file transfer pubblicano gli eventi Amazon RDS al loro inizio e al completamento. Il messaggio dell'evento contiene l'ID dell'attività per il trasferimento file. Per informazioni sulla visualizzazione degli eventi, consultare [Visualizzazione di eventi Amazon RDS](USER_ListEvents.md).
È possibile visualizzare lo stato di un'attività in corso in un file bdump. I file bdump si trovano nella directory `/rdsdbdata/log/trace`. Il nome del file bdump ha il formato che segue.
```
dbtask-task-id.log
```
Sostituire `task-id` con l'ID dell'attività da monitorare.
**Nota**
Le attività vengono eseguite in modo asincrono.
Puoi usare la procedura memorizzata in `rdsadmin.rds_file_util.read_text_file` per visualizzare i contenuti dei file bdump. Ad esempio, la query seguente restituisce i contenuti del file bdump `dbtask-1234567890123-1234.log`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1234567890123-1234.log'));
```
L'esempio seguente mostra il file di log di un trasferimento non riuscito.
```
TASK_ID
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1234567890123-1234
TEXT
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2023-04-17 18:21:33.993 UTC [INFO ] File #1: Uploading the file /rdsdbdata/datapump/A123B4CDEF567890G1234567890H1234/sample.dmp to Amazon S3 with bucket name amzn-s3-demo-bucket and key sample.dmp.
2023-04-17 18:21:34.188 UTC [ERROR] RDS doesn't have permission to write to Amazon S3 bucket name amzn-s3-demo-bucket and key sample.dmp.
2023-04-17 18:21:34.189 UTC [INFO ] The task failed.
```
## Risoluzione dei problemi di integrazione Amazon S3
Per suggerimenti sulla risoluzione dei problemi, consulta l'articolo nella pagina AWS re:post intitolato [Come posso risolvere i problemi relativi all'integrazione di Amazon RDS per Oracle con Amazon S3?](https://repost.aws/en/knowledge-center/rds-oracle-s3-integration).
# Rimozione dell'opzione di integrazione Amazon S3
Puoi rimuovere l'opzione di integrazione Amazon S3 da un'istanza database.
Per rimuovere l'opzione di integrazione Amazon S3 da un'istanza database, procedi in uno dei seguenti modi:
+ Per rimuovere l'opzione di integrazione Amazon S3 da più istanze database, rimuovere l'opzione `S3_INTEGRATION` dal gruppo di opzioni a cui appartengono le istanze database. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Per rimuovere l'opzione di integrazione Amazon S3 da una singola istanza database, modifica l'istanza database e specifica un gruppo di opzioni diverso che non comprenda l'opzione `S3_INTEGRATION`. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle Application Express (APEX)
Amazon RDS supporta Oracle Application Express (APEX) tramite l'utilizzo delle opzioni `APEX` e `APEX-DEV`. Puoi implementare Oracle APEX come ambiente di runtime o come ambiente di sviluppo completo per le applicazioni basate sul web. Utilizzando Oracle APEX, puoi compilare le applicazioni interamente all'interno del browser Web. Per ulteriori informazioni, consulta [Oracle Application Express](https://apex.oracle.com/) nella documentazione di Oracle.
**Topics**
+ [Componenti di Oracle APEX](#Appendix.Oracle.Options.APEX.components)
+ [Requisiti e limitazioni](Appendix.Oracle.Options.APEX.Requirements.md)
+ [Configurazione di Oracle APEX e Oracle Rest Data Services (ORDS)](Appendix.Oracle.Options.APEX.settingUp.md)
+ [Configurazione di Oracle Rest Data Services (ORDS)](Appendix.Oracle.Options.APEX.ORDSConf.md)
+ [Aggiornamento e rimozione di Oracle APEX](Appendix.Oracle.Options.APEX.UpgradeandRemove.md)
## Componenti di Oracle APEX
Oracle APEX è costituito dai seguenti componenti principali:
+ Un *repository* che archivia i metadati per i componenti e le applicazioni Oracle APEX. Il repository è formato da tabelle, indici e altri oggetti che sono installati nella tua istanza database Amazon RDS.
+ Un *listener* che gestisce le comunicazioni HTTP con i client Oracle APEX. L'ascoltatore risiede in un host separato, come un'istanza Amazon EC2, un server on-premise della tua azienda oppure il tuo computer desktop. Il listener accetta le connessioni in entrata dai browser Web, le inoltra all'istanza database Amazon RDS per l'elaborazione e quindi invia nuovamente i risultati dal repository ai browser.
RDS per Oracle supporta i seguenti tipi di ascoltatori:
+ Per Oracle APEX versione 5.0 e successive, utilizza Oracle REST Data Services (ORDS) versione 19.1 e successive. Si consiglia di utilizzare la versione più recente supportata di Oracle APEX e ORDS. Questa documentazione descrive le versioni precedenti solo per la compatibilità con le versioni precedenti.
+ Per Oracle APEX versione 4.1.1, puoi utilizzare Oracle APEX Listener versione 1.1.4.
+ È possibile utilizzare Oracle HTTP Server e i listener `mod_plsql`.
**Nota**
Amazon RDS non supporta il server HTTP Oracle XML DB con il gateway PL/SQL integrato come listener per Oracle APEX. In generale, Oracle consiglia di utilizzare il gateway PL/SQL integrato per le applicazioni eseguite su Internet.
Per ulteriori informazioni su questi tipi di listener, consulta [About Choosing a Web Listener](https://docs.oracle.com/database/apex-5.1/HTMIG/choosing-web-listener.htm#HTMIG29321) nella documentazione di Oracle.
Quando aggiungi le opzioni `APEX` e `APEX-DEV` all’istanza database RDS per Oracle, Amazon RDS installa solo il repository Oracle APEX. Installa l'ascoltatore su un host separato.
# Requisiti e limitazioni
L’argomento seguente elenca i requisiti e le limitazioni per Oracle APEX e ORDS.
## Requisiti per la versione Oracle APEX
L’opzione `APEX` utilizza l’archiviazione nella classe di istanza database per l’istanza database. Di seguito si riportano le versioni supportate e i requisiti di storage approssimativi per Oracle APEX.
****
| Versione di Oracle APEX | Requisiti di storage | Versioni di Oracle Database supportate | Note |
| --- | --- | --- | --- |
| Oracle APEX versione 24.2.v1 | 114 MiB | Tutti | Questa versione include la patch 37885097: PACCHETTO PSE PER APEX 24.2 (PSES IN AGGIUNTA ALLA 24.2.0), PATCH\$1VERSION 4. |
| Oracle APEX versione 24.1.v1 | 112 MiB | Tutti | Questa versione include la patch 36695709: PACCHETTO PSE PER APEX 24.1 (PSES IN AGGIUNTA ALLA 24.1.0), PATCH\$1VERSION 3. Se hai bisogno della stessa versione esatta di immagini APEX da installare sull’istanza EC2, scarica la patch 37544819: 24.1.3 PSE BUNDLE PER APEX 24.1 (PSES SU 24.1.0). |
| Oracle APEX versione 23.2.v1 | 110 MiB | Tutti | Questa versione include la patch 35895964: PSE BUNDLE PER APEX 23.2 (PSES SU 23.2.0), PATCH\$1VERSION 6. Se hai bisogno della stessa versione esatta di immagini APEX da installare sull’istanza EC2, scarica la patch 37593125: 23.2.6 PSE BUNDLE PER APEX 23.2 (PSES SU 23.2.0). |
| Oracle APEX versione 23.1.v1 | 106 MiB | Tutti | Questa versione include la patch 35283657: PSE BUNDLE FOR APEX 23.1 (PSES ON TOP OF 23.1.0), PATCH\$1VERSION 2. |
| Oracle APEX versione 22.2.v1 | 106 MiB | Tutti | Questa versione include la patch 34628174: PSE BUNDLE FOR APEX 22.2 (PSES SU 22.2.0), PATCH\$1VERSION 4. |
| Oracle APEX versione 22.1.v1 | 124 MiB | Tutti | Questa versione include la patch 34020981: PSE BUNDLE FOR APEX 22.1 (PSES SU 22.1.0), PATCH\$1VERSION 6. |
| Oracle APEX versione 21.2.v1 | 125 MiB | Tutti | Questa versione include la patch 33420059: PSE BUNDLE FOR APEX 21.2 (PSES SU 21.2.0), PATCH\$1VERSION 8. |
| Oracle APEX versione 21.1.v1 | 125 MiB | Tutti | Questa versione include la patch 32598392: PSE BUNDLE FOR APEX 21.1, PATCH\$1VERSION 3. |
| Oracle APEX versione 20.2.v1 | 148 MiB | Tutti tranne Oracle Database 21c | Questa versione include la patch 32006852: PSE BUNDLE FOR APEX 20.2, PATCH\$1VERSION 2020.11.12. È possibile visualizzare il numero e la data della patch eseguendo la seguente query: SELECT PATCH_VERSION, PATCH_NUMBER
FROM APEX_PATCHES;
|
| Oracle APEX versione 20.1.v1 | 173 MiB | Tutti tranne Oracle Database 21c | Questa versione include la patch 30990551: PSE BUNDLE FOR APEX 20.1, PATCH\$1VERSION 2020.07.15. |
| Oracle APEX versione 19.2.v1 | 149 MiB | Tutti tranne Oracle Database 21c | |
| Oracle APEX versione 19.1.v1 | 148 MiB | Tutti tranne Oracle Database 21c | |
Per i file .zip Oracle APEX scaricabili, consulta [Oracle APEX Prior Release Archives](https://www.oracle.com/tools/downloads/apex-all-archives-downloads.html) sul sito web di Oracle.
## Prerequisiti per Oracle APEX e ORDS
Di seguito sono indicati i prerequisiti per l’utilizzo di Oracle APEX e ORDS:
+ È necessario che il sistema utilizzi l’ambiente di runtime Java (JRE).
+ L'installazione client Oracle deve includere quanto segue:
+ SQL\$1Plus o SQL Developer per le attività di amministrazione
+ Oracle Net Services per la configurazione delle connessioni all'istanza database RDS per Oracle
## Limitazioni Oracle APEX
Non puoi modificare l’account utente `APEX_version`, che è gestito da Amazon RDS. Pertanto, non puoi applicare profili di database né applicare regole delle password a questo utente. I profili e le impostazioni delle password per `APEX_version` sono predefiniti da Oracle AWS e sono progettati per soddisfare i requisiti di sicurezza di Amazon RDS.
# Configurazione di Oracle APEX e Oracle Rest Data Services (ORDS)
L’argomento seguente elenca i passaggi necessari per configurare Oracle APEX e ORDS
**Topics**
+ [Aggiunta delle opzioni APEX e APEX-DEV all’istanza database](#Appendix.Oracle.Options.APEX.Add)
+ [Sblocco dell’account utente pubblico sull’istanza database](#Appendix.Oracle.Options.APEX.PublicUser)
+ [Configurazione dei RESTful servizi per Oracle APEX](#Appendix.Oracle.Options.APEX.ConfigureRESTful)
+ [Preparazione per installare ORDS su un host separato](#Appendix.Oracle.Options.APEX.ORDS.ords-setup)
+ [Impostazione del listener Oracle APEX](#Appendix.Oracle.Options.APEX.Listener)
## Aggiunta delle opzioni APEX e APEX-DEV all’istanza database
Per aggiungere le opzioni `APEX` e `APEX-DEV` a un’istanza database di RDS per Oracle, esegui le operazioni indicate di seguito:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungi le opzioni `APEX` e `APEX-DEV` al gruppo di opzioni.
1. Associa il gruppo di opzioni a questa istanza database.
Quando aggiungi le opzioni `APEX` e `APEX-DEV`, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente.
**Nota**
`APEX_MAIL` è disponibile se l'opzione `APEX` è installata. Il privilegio di esecuzione per il pacchetto `APEX_MAIL` è concesso a `PUBLIC` e quindi non è necessario l'account amministrativo APEX per utilizzarlo.
**Per aggiungere le opzioni APEX e APEX-DEV a un’istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine (Motore)**, scegliere l'edizione di Oracle da utilizzare. Le opzioni `APEX` e `APEX-DEV` sono supportate in tutte le edizioni.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere le opzioni al gruppo di opzioni. Per distribuire solo l’ambiente di runtime Oracle APEX aggiungi solo l’opzione `APEX`. Per distribuire l’ambiente di sviluppo completo, aggiungi entrambe le opzioni `APEX` e `APEX-DEV`.
In **Versione**, scegli la versione di Oracle APEX che desideri utilizzare.
**Importante**
Se aggiungi le opzioni `APEX` o `APEX-DEV` a un gruppo di opzioni esistente già associato a una o più istanze database, si verifica una breve interruzione. Durante questa interruzione, tutte le istanze database vengono riavviate automaticamente.
Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Quando aggiungi le opzioni `APEX` o `APEX-DEV` a un’istanza database esistente, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Sblocco dell’account utente pubblico sull’istanza database
Dopo aver installato le opzioni `APEX` o `APEX-DEV` sull’istanza database, assicurati di eseguire le operazioni indicate di seguito:
1. Modifica della password per l’account `APEX_PUBLIC_USER`.
1. Sbloccare l'account.
Per farlo, utilizza l'utilità a riga di comando Oracle SQL\$1Plus. Connettiti alla tua istanza database come utente master e utilizza i seguenti comandi. Sostituisci `new_password` con una password a tua scelta.
```
1. ALTER USER APEX_PUBLIC_USER IDENTIFIED BY new_password;
2. ALTER USER APEX_PUBLIC_USER ACCOUNT UNLOCK;
```
## Configurazione dei RESTful servizi per Oracle APEX
Per configurare RESTful i servizi in Oracle APEX (non necessari per Oracle APEX 4.1.1.v1), usa SQL\$1Plus per connetterti all'istanza DB come utente principale. Successivamente, esegui la stored procedure `rdsadmin.rdsadmin_run_apex_rest_config`. Quando esegui la stored procedure, fornisci le password per i seguenti utenti:
+ `APEX_LISTENER`
+ `APEX_REST_PUBLIC_USER`
La stored procedure esegue lo script `apex_rest_config.sql`, che crea nuovi account database per questi utenti.
**Nota**
Oracle APEX versione 4.1.1.v1 non necessita configurazione. Per questa versione di Oracle APEX non devi eseguire la procedura archiviata.
Il comando seguente avvia la procedura archiviata.
```
1. EXEC rdsadmin.rdsadmin_run_apex_rest_config('apex_listener_password', 'apex_rest_public_user_password');
```
## Preparazione per installare ORDS su un host separato
Installa ORDS in un host separato, come un’istanza Amazon EC2, un server on-premises nella tua azienda oppure il tuo computer desktop. Negli esempi riportati in questa sezione si suppone che l’host esegua Linux e sia denominato `myapexhost.example.com`.
Prima di poter installare ORDS, è necessario creare un utente del sistema operativo senza privilegi, quindi scaricare e decomprimere il file di installazione Oracle APEX.
**Per preparare l'installazione di ORDS**
1. Accedere a `myapexhost.example.com` come `root`.
1. Creare un utente del sistema operativo senza privilegi che possieda l'installazione del listener. Il comando seguente crea un nuovo utente denominato *apexuser*.
```
useradd -d /home/apexuser apexuser
```
Il seguente comando assegna una password al nuovo utente.
```
passwd apexuser;
```
1. Accedi a `myapexhost.example.com` come `apexuser` e scarica il file di installazione Oracle APEX da Oracle e salvalo nella directory `/home/apexuser`:
+ [http://www.oracle. com/technetwork/developer-tools/apex/downloads/index.html](http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html)
+ [Oracle Application Express Prior Release Archives](http://www.oracle.com/technetwork/developer-tools/apex/downloads/all-archives-099381.html)
1. Decomprimi il file nella directory `/home/apexuser`.
```
unzip apex_version.zip
```
Dopo aver decompresso il file, troverai una directory `apex` nella directory `/home/apexuser`.
1. [Mentre sei ancora connesso`apexuser`, scarica il file Oracle REST Data Services da Oracle `/home/apexuser` nella tua directory: http://www.oracle. `myapexhost.example.com` com/technetwork/developer-tools/apex-listener/downloads/index.html.](http://www.oracle.com/technetwork/developer-tools/apex-listener/downloads/index.html)
## Impostazione del listener Oracle APEX
**Nota**
Il listener Oracle APEX è obsoleto.
Amazon RDS per Oracle continua a supportare Oracle APEX versione 4.1.1 e Oracle APEX Listener versione 1.1.4. Si consiglia di utilizzare le versioni più recenti supportate di Oracle APEX e ORDS.
Installa Oracle APEX Listener in un host separato, come un'istanza Amazon EC2, un server locale nella tua azienda oppure il tuo computer desktop. Ipotizziamo che il nome del tuo host sia `myapexhost.example.com` e che esegua Linux.
### Preparazione all'installazione del listener Oracle APEX
Prima di installare il listener Oracle APEX, è necessario creare un utente del sistema operativo senza privilegi, quindi scaricare e decomprimere il file di installazione Oracle APEX.
**Per preparare l'installazione del listener Oracle APEX**
1. Accedere a `myapexhost.example.com` come `root`.
1. Creare un utente del sistema operativo senza privilegi che possieda l'installazione del listener. Il comando seguente crea un nuovo utente denominato *apexuser*.
```
useradd -d /home/apexuser apexuser
```
Il seguente comando assegna una password al nuovo utente.
```
passwd apexuser;
```
1. Accedi a `myapexhost.example.com` come `apexuser` e scarica il file di installazione Oracle APEX da Oracle e salvalo nella directory `/home/apexuser`:
+ [http://www.oracle. com/technetwork/developer-tools/apex/downloads/index.html](http://www.oracle.com/technetwork/developer-tools/apex/downloads/index.html)
+ [Oracle Application Express Prior Release Archives](http://www.oracle.com/technetwork/developer-tools/apex/downloads/all-archives-099381.html)
1. Decomprimi il file nella directory `/home/apexuser`.
```
unzip apex_.zip
```
Dopo aver decompresso il file, troverai una directory `apex` nella directory `/home/apexuser`.
1. Rimanendo collegato a `myapexhost.example.com` come `apexuser`, scarica il file di APEX Listener da Oracle e salvalo nella directory `/home/apexuser`:
#### Installazione e configurazione del listener Oracle APEX
Prima di poter utilizzare Oracle APEX, è necessario scaricare il file `apex.war`, utilizzare Java per installare il listener Oracle APEX e quindi avviare il listener.
**Per installare e configurare il listener Oracle APEX**
1. Creare una nuova directory basata sul listener Oracle APEX e aprire il file listener:
Eseguire il seguente codice:
```
mkdir /home/apexuser/apexlistener
cd /home/apexuser/apexlistener
unzip ../apex_listener.version.zip
```
1. Eseguire il seguente codice.
```
java -Dapex.home=./apex -Dapex.images=/home/apexuser/apex/images -Dapex.erase -jar ./apex.war
```
1. Il programma richiede le seguenti informazioni.
+ Nome dell'utente amministratore di APEX Listener. Il valore predefinito è *adminlistener*.
+ Una password per l'amministratore APEX Listener.
+ Nome dell'utente manager di APEX Listener. Il valore predefinito è *managerlistener*.
+ Una password per l'amministratore APEX Listener.
Il programma stampa un URL necessario per completare la configurazione nel modo seguente:
```
INFO: Please complete configuration at: http://localhost:8080/apex/listenerConfigure
Database is not yet configured
```
1. Lasciare il listener Oracle APEX in esecuzione in modo da poter utilizzare Oracle Application Express. Al termine della procedura di configurazione è possibile eseguire il listener in background.
1. Dal browser web, accedere all’URL fornito dal programma Oracle APEX Listener. Viene visualizzata la finestra di amministrazione di Oracle Application Express Listener. Immettere le seguenti informazioni:
+ **Username (Nome utente** – `APEX_PUBLIC_USER`
+ **Password** – La password per *APEX\$1PUBLIC\$1USER*. La password è una di quelle specificate in precedenza durante la configurazione del repository Oracle APEX. Per ulteriori informazioni, consulta [Sblocco dell’account utente pubblico sull’istanza database](#Appendix.Oracle.Options.APEX.PublicUser).
+ **Connection Type (Tipo di connessione)** – Basic (Di base)
+ **Hostname (Nome host)** – Endpoint dell'istanza database Amazon RDS, ad esempio `mydb.f9rbfa893tft.us-east-1.rds.amazonaws.com`.
+ **Port (Porta** – 1521
+ **SID** – Nome del database nell'istanza database Amazon RDS, ad esempio `mydb`.
1. Scegliere **Apply (Applica)**. Viene visualizzata la finestra di amministrazione Oracle APEX.
1. Imposta una password per l’utente `admin` di Oracle APEX. Per farlo, utilizzare SQL\$1Plus per connettersi alla propria istanza database come utente master, quindi utilizzare i seguenti comandi:
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
Sostituire `master` con il proprio nome utente master. Quando lo script `apxchpwd.sql` lo richiede, inserire una nuova password `admin`.
1. Torna alla finestra di amministrazione Oracle APEX nel browser e scegli l’opzione **Administration**. Scegliere quindi **Application Express Internal Administration (Amministrazione interna Application Express)**. Quando vengono richieste le credenziali, inserire le seguenti informazioni:
+ **User name (Nome utente** – `admin`
+ **Password** – La password impostata usando lo script `apxchpwd.sql`
Scegliere **Login (Accedi)**, quindi impostare una nuova password per l'utente `admin`.
Il listener è ora pronto per essere utilizzato.
# Configurazione di Oracle Rest Data Services (ORDS)
L’argomento seguente illustra le opzioni di configurazione per ORDS 21 e 22:
**Topics**
+ [Installazione e configurazione di ORDS 21 e versioni precedenti](#Appendix.Oracle.Options.APEX.ORDS)
+ [Installazione e configurazione di ORDS 22 e versioni successive](#Appendix.Oracle.Options.APEX.ORDS22)
## Installazione e configurazione di ORDS 21 e versioni precedenti
È ora possibile installare e configurare Oracle Rest Data Services (ORDS) per l'utilizzo con Oracle APEX. Per Oracle APEX versione 5.0 e versioni successive, utilizza ORDS versioni da 19.1 a 21. Per informazioni su come installare ORDS 22 e versioni successive, consulta [Installazione e configurazione di ORDS 22 e versioni successive](#Appendix.Oracle.Options.APEX.ORDS22).
Installa il listener in un host separato, come un'istanza Amazon EC2, un server locale nella tua azienda oppure il tuo computer desktop. Per gli esempi in questa sezione, supponiamo che il nome dell'host sia `myapexhost.example.com` e che l'host esegua Linux.
**Per installare e configurare ORDS 21 e versioni precedenti per l’utilizzo con Oracle APEX**
1. Vai ai [Oracle REST data services](https://www.oracle.com/database/technologies/appdev/rest-data-services-downloads-212.html) ed esamina il file Readme. Verifica che sia installata la versione richiesta di Java.
1. Crea una nuova directory per l’installazione di ORDS.
```
mkdir /home/apexuser/ORDS
cd /home/apexuser/ORDS
```
1. Scarica il file `ords.version.number.zip` da [Oracle REST Data Services](https://www.oracle.com/database/technologies/appdev/rest-data-services-downloads-212.html).
1. Decomprimere il file nella directory `/home/apexuser/ORDS`.
1. Se stai installando ORDS in un database multilocazione, aggiunge la riga seguente al file `/home/apexuser/ORDS/params/ords_params.properties`:
```
pdb.disable.lockdown=false
```
1. Concedere all'utente master i privilegi necessari per installare ORDS.
Una volta installate le opzioni per Oracle APEX, concedi all’utente master i privilegi necessari per installare lo schema ORDS. Questa operazione può essere eseguita collegandosi al database ed eseguendo questi comandi: Sostituisci `MASTER_USER` con il nome in maiuscolo dell'utente master.
**Importante**
Quando si immette il nome utente, utilizzare maiuscole a meno che l'utente non sia stato creato con un identificatore con distinzione tra maiuscole e minuscole. Ad esempio, se esegui `CREATE USER myuser` o `CREATE USER MYUSER`, il dizionario dati memorizza `MYUSER`. Tuttavia, se si utilizzano virgolette doppie in `CREATE USER "MyUser"`, il dizionario dati memorizza `MyUser`. Per ulteriori informazioni, consulta [Concedere privilegi SELECT o EXECUTE agli oggetti SYS](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md).
```
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_ROLE_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONS_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONSTRAINTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_PROCEDURES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TABLES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_VIEWS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPIUTL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SESSION', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_UTILITY', 'MASTER_USER', 'EXECUTE', true);
```
**Nota**
Questi comandi si applicano a ORDS versione 19.1 e successive.
1. Installare lo schema ORDS utilizzando il file scaricato ords.war.
```
java -jar ords.war install advanced
```
Il programma richiede le seguenti informazioni. I valori predefiniti sono riportati tra parentesi. Per altre informazioni, consulta l'articolo relativo a [Introduzione a Oracle REST Data Services](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/20.2/aelig/installing-REST-data-services.html#GUID-6F7B4E61-B730-4E73-80B8-F53299123730) nella documentazione Oracle.
+ Destinazione di archiviazione dei dati di configurazione
Specificare (sì */home/apexuser/ORDS*. Questa è la posizione dei file di configurazione di ORDS.
+ Specificare il tipo di connessione al database da utilizzare. Immettere il numero per [1] Basic [2] TNS [3] URL personalizzato [1]:
Scegliere il tipo di connessione desiderato.
+ Immettete il nome del server del database [localhost]: *DB\$1instance\$1endpoint*
Scegli il valore predefinito o digita il valore corretto.
+ Immettete la porta del listener del database [1521]: *DB\$1instance\$1port*
Scegli il valore predefinito o digita il valore corretto.
+ Immettere 1 per specificare il nome del servizio di database o 2 per specificare il SID del database [1]:
Scegliere `2` per specificare il SID del database.
+ SID del database [xe]
Scegli il valore predefinito o digita il valore corretto.
+ Immettere 1 se si desidera utilizzare lo schema verify/install Oracle REST Data Services o 2 per saltare questo passaggio [1]:
Scegliere `1`. Questo passaggio crea l'utente proxy di Oracle REST Data Services denominato ORDS\$1PUBLIC\$1USER.
+ Immettere la password del database per ORDS\$1PUBLIC\$1USER:
Immettere la password, quindi confermarla.
+ Richiede l’accesso con i privilegi di amministratore per verificare lo schema Oracle REST Data Services.
Immettere il nome utente dell'amministratore: *master\$1user*
Inserisci la password del database per*master\$1user*: *master\$1user\$1password*
Conferma la password: *master\$1user\$1password*
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
+ Inserire lo spazio tabella predefinito per ORDS\$1METADATA [SYSAUX].
Inserire lo spazio tabella temporaneo per ORDS\$1METADATA [TEMP].
Inserire lo spazio tabella predefinito per ORDS\$1PUBLIC\$1USER [USERS].
Inserire lo spazio tabella temporaneo per ORDS\$1PUBLIC\$1USER [USERS].
+ Inserisci 1 se desideri utilizzare PL/SQL Gateway o 2 per saltare questo passaggio. Se si sta utilizzando Oracle Application Express o si sta migrando da mod\$1plsql, inserire 1 [1].
Scegliere il valore predefinito.
+ Immettete il nome utente del database PL/SQL Gateway [APEX\$1PUBLIC\$1USER]
Scegliere il valore predefinito.
+ Inserire la password del database per APEX\$1PUBLIC\$1USER
Immettere la password, quindi confermarla.
+ Immettete 1 per specificare le password per gli utenti del database di Application Express RESTful Services (APEX\$1LISTENER, APEX\$1REST\$1PUBLIC\$1USER) o 2 per saltare questo passaggio [1]:
Scegliere `2` per APEX 4.1.1.V1 oppure scegliere `1` per tutte le altre versioni di APEX.
+ [Non necessario per APEX 4.1.1.v1] Password di database per APEX\$1LISTENER
Immettere la password (se necessario), quindi confermarla.
+ [Non necessario per APEX 4.1.1.v1] Password di database per APEX\$1REST\$1PUBLIC\$1USER
Immettere la password (se necessario), quindi confermarla.
+ Immettere un numero per selezionare una funzione da abilitare:
Immettere `1` per abilitare tutte le funzioni: SQL Developer Web, REST Enabled SQL e Database API.
+ Immettere 1 se si desidera avviare in modalità standalone o 2 per uscire [1]:
Specificare (sì `1`.
+ Immettere l'ubicazione delle risorse statiche APEX:
Se i file di installazione APEX sono stati decompressi in `/home/apexuser`, immettere `/home/apexuser/apex/images`. Altrimenti, inserisci, dov'è la directory in cui hai decompresso il file. `unzip_path/apex/images` *unzip\$1path*
+ Immettere 1 se si utilizza HTTP o 2 se si utilizza HTTPS [1]:
Se si immette `1`, specificare la porta HTTP. Se si immette `2`, specificare la porta HTTPS e il nome host SSL. L'opzione HTTPS richiede di specificare come si fornirà il certificato:
+ Immettere `1` per utilizzare il certificato autofirmato.
+ Immettere `2` per fornire il proprio certificato. Se si immette `2`, specificare il percorso per il certificato SSL e il percorso per la chiave privata del certificato SSL.
1. Impostare una password per l'utente `admin` APEX. Per farlo, utilizzare SQL\$1Plus per connettersi alla propria istanza database come utente master, quindi utilizzare i seguenti comandi:
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
Sostituire `master` con il proprio nome utente master. Quando lo script `apxchpwd.sql` lo richiede, inserire una nuova password `admin`.
1. Avviare il listener ORDS. Eseguire il seguente codice.
```
java -jar ords.war
```
Al primo avvio dell'ORDS viene richiesto di fornire la posizione delle risorse statiche APEX. Questa cartella di immagini è posizionata nella directory `/apex/images` all’interno della directory di installazione per APEX.
1. Torna alla finestra di amministrazione Oracle APEX nel browser e scegli l’opzione **Administration**. Scegliere quindi **Application Express Internal Administration (Amministrazione interna Application Express)**. Quando vengono richieste le credenziali, inserire le seguenti informazioni:
+ **User name (Nome utente** – `admin`
+ **Password** – La password impostata usando lo script `apxchpwd.sql`
Scegliere **Login (Accedi)**, quindi impostare una nuova password per l'utente `admin`.
Il listener è ora pronto per essere utilizzato.
## Installazione e configurazione di ORDS 22 e versioni successive
È ora possibile installare e configurare Oracle Rest Data Services (ORDS) per l'utilizzo con Oracle APEX. Per gli esempi in questa sezione, supponiamo che il nome dell’host separato sia `myapexhost.example.com` e che l’host esegua Linux. Le istruzioni per ORDS 22 differiscono da quelle per le versioni precedenti.
**Per installare e configurare ORDS 22 e versioni successive per l’uso con Oracle APEX**
1. Vai ai [Oracle REST data services](http://www.oracle.com/technetwork/developer-tools/rest-data-services/downloads/index.html) ed esamina il file Readme per la versione di ORDS che intendi scaricare. Verifica che sia installata la versione richiesta di Java.
1. Crea una nuova directory per l’installazione di ORDS.
```
mkdir /home/apexuser/ORDS
cd /home/apexuser/ORDS
```
1. Scarica il file `ords.version.number.zip` o `ords-latest.zip` da [Oracle REST data services](http://www.oracle.com/technetwork/developer-tools/rest-data-services/downloads/index.html).
1. Decomprimere il file nella directory `/home/apexuser/ORDS`.
1. Concedere all'utente master i privilegi necessari per installare ORDS.
Una volta installata l’opzione `APEX`, concedi all’utente master i privilegi necessari per installare lo schema ORDS. Questa operazione può essere eseguita collegandosi al database ed eseguendo questi comandi: Sostituisci `MASTER_USER` con il nome in maiuscolo dell'utente master.
**Importante**
Quando si immette il nome utente, utilizzare maiuscole a meno che l'utente non sia stato creato con un identificatore con distinzione tra maiuscole e minuscole. Ad esempio, se esegui `CREATE USER myuser` o `CREATE USER MYUSER`, il dizionario dati memorizza `MYUSER`. Tuttavia, se si utilizzano virgolette doppie in `CREATE USER "MyUser"`, il dizionario dati memorizza `MyUser`. Per ulteriori informazioni, consulta [Concedere privilegi SELECT o EXECUTE agli oggetti SYS](Appendix.Oracle.CommonDBATasks.TransferPrivileges.md).
```
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_ROLE_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONS_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_CONSTRAINTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_OBJECTS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_PROCEDURES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TAB_COLUMNS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_TABLES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('USER_VIEWS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPIUTL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SESSION', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_UTILITY', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_LOB', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_ASSERT', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_OUTPUT', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SCHEDULER', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('HTP', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('OWA', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('WPG_DOCLOAD', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_CRYPTO', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_METADATA', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_SQL', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('UTL_SMTP', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBMS_NETWORK_ACL_ADMIN', 'MASTER_USER', 'EXECUTE', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('SESSION_PRIVS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_USERS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_NETWORK_ACL_PRIVILEGES', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_NETWORK_ACLS', 'MASTER_USER', 'SELECT', true);
exec rdsadmin.rdsadmin_util.grant_sys_object('DBA_REGISTRY', 'MASTER_USER', 'SELECT', true);
```
**Nota**
I comandi precedenti si applicano a ORDS 22 e versioni successive.
1. Installa lo schema ORDS utilizzando lo script `ords` scaricato. Specifica le directory in cui inserire i file di configurazione e i file di log. Oracle Corporation consiglia di non inserire queste directory nella directory che contiene il software del prodotto ORDS.
```
mkdir -p /home/apexuser/ords_config /home/apexuser/ords_logs
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config \
install --interactive --log-folder /home/apexuser/ords_logs
```
Per le istanze database che eseguono l’architettura del database dei container (CDB), utilizza ORDS 23.3 o versioni successive e passa l’argomento `--pdb-skip-disable-lockdown` durante l’installazione di ORDS.
```
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config \
install --interactive --log-folder /home/apexuser/ords_logs --pdb-skip-disable-lockdown
```
Il programma richiede le seguenti informazioni. I valori predefiniti sono riportati tra parentesi. Per altre informazioni, consulta l'articolo relativo a [Introduzione a Oracle REST Data Services](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/20.2/aelig/installing-REST-data-services.html#GUID-6F7B4E61-B730-4E73-80B8-F53299123730) nella documentazione Oracle.
+ `Choose the type of installation:`
Sceglie **2** per installare gli schemi ORDS nel database e creare un pool di connessioni al database nei file di configurazione ORDS locali.
+ `Specify the database connection type to use. Enter number for [1] Basic [2] TNS [3] Custom URL:`
Scegliere il tipo di connessione desiderato. Questo esempio presuppone che tu scelga **1**.
+ `Enter the name of the database server [localhost]:` ***DB\$1instance\$1endpoint***
Scegli il valore predefinito o digita il valore corretto.
+ `Enter the database listener port [1521]:` ***DB\$1instance\$1port***
Scegli il valore predefinito **1521** o digita il valore corretto.
+ `Enter the database service name [orcl]:`
Immetti il nome del database utilizzato dall’istanza database RDS per Oracle.
+ `Provide database user name with administrator privileges`
Inserisci il nome utente master per l’istanza database RDS per Oracle.
+ `Enter the database password for [username]:`
Inserisci la password dell’utente master per l’istanza database RDS per Oracle.
+ `Enter the default tablespace for ORDS_METADATA and ORDS_PUBLIC_USER [SYSAUX]:`
+ `Enter the temporary tablespace for ORDS_METADATA [TEMP]. Enter the default tablespace for ORDS_PUBLIC_USER [USERS]. Enter the temporary tablespace for ORDS_PUBLIC_USER [TEMP].`
+ `Enter a number to select additional feature(s) to enable [1]:`
+ `Enter a number to configure and start ORDS in standalone mode [1]: `
Scegli **2** per saltare immediatamente l’avvio di ORDS in modalità standalone.
+ `Enter a number to select the protocol [1] HTTP`
+ `Enter the HTTP port [8080]:`
+ `Enter the APEX static resources location:`
Immetti il percorso ai file di installazione di Oracle APEX (`/home/apexuser/apex/images`).
1. Imposta una password per l’utente `admin` di Oracle APEX. Per farlo, utilizzare SQL\$1Plus per connettersi alla propria istanza database come utente master, quindi utilizzare i seguenti comandi:
```
1. EXEC rdsadmin.rdsadmin_util.grant_apex_admin_role;
2. grant APEX_ADMINISTRATOR_ROLE to master;
3. @/home/apexuser/apex/apxchpwd.sql
```
Sostituire `master` con il proprio nome utente master. Quando lo script `apxchpwd.sql` lo richiede, inserire una nuova password `admin`.
1. Esegui ORDS in modalità standalone utilizzando lo script `ords` con il comando `serve`. Per le implementazioni di produzione, prendi in considerazione l'utilizzo di server applicativi Java EE supportati come Apache Tomcat o Oracle Server. WebLogic Per altre informazioni, consulta l’articolo [Deploying and Monitoring Oracle REST Data Services](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/23.1/ordig/deploying-and-monitoring-oracle-rest-data-services.html#GUID-6791F5DF-AC67-4885-BFFA-B80964C17EC9) nella documentazione Oracle.
```
/home/apexuser/ORDS/bin/ords \
--config /home/apexuser/ords_config serve \
--port 8193 \
--apex-images /home/apexuser/apex/images
```
Se ORDS è in esecuzione, ma non è possibile accedere all’installazione di Oracle APEX, è possibile che venga visualizzato il seguente errore, in particolare sulle istanze non CDB.
```
The procedure named apex_admin could not be accessed, it may not be declared, or the user executing this request may not have been granted execute privilege on the procedure, or a function specified by security.requestValidationFunction configuration property has prevented access.
```
Per correggere questo errore, modifica la funzione di convalida della richiesta utilizzata da ORDS eseguendo lo script `ords` con il comando `config`. Per impostazione predefinita, ORDS utilizza la procedura `ords_util.authorize_plsql_gateway`, che è supportata solo sulle istanze CDB. Per le istanze non CDB, puoi modificare questa procedura nel pacchetto `wwv_flow_epg_include_modules.authorize`. Consulta la documentazione di Oracle Database e Oracle Support per le best practice sulla configurazione della funzione di convalida delle richieste appropriata per il tuo caso d’uso.
1. Torna alla finestra di amministrazione Oracle APEX nel browser e scegli l’opzione **Administration**. Scegliere quindi **Application Express Internal Administration (Amministrazione interna Application Express)**. Quando vengono richieste le credenziali, inserire le seguenti informazioni:
+ **User name (Nome utente** – `admin`
+ **Password** – La password impostata usando lo script `apxchpwd.sql`
Scegliere **Login (Accedi)**, quindi impostare una nuova password per l'utente `admin`.
Il listener è ora pronto per essere utilizzato.
# Aggiornamento e rimozione di Oracle APEX
Per aggiornare o rimuovere Oracle APEX, segui le istruzioni riportate in questo argomento:
**Topics**
+ [Aggiornamento della versione di Oracle APEX](#Appendix.Oracle.Options.APEX.Upgrade)
+ [Aggiunta delle opzioni APEX e APEX-DEV](#Appendix.Oracle.Options.APEX.Remove)
## Aggiornamento della versione di Oracle APEX
**Importante**
Effettua il backup della tua istanza database prima di aggiornare Oracle APEX. Per ulteriori informazioni, consultare [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md) e [Verifica di un aggiornamento del database Oracle](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md).
Per aggiornare Oracle APEX con l’istanza database, utilizza la seguente procedura:
+ Creare un nuovo gruppo di opzioni per la versione aggiornata dell'istanza database.
+ Aggiungi le versioni aggiornate di `APEX` e `APEX-DEV` al nuovo gruppo di opzioni. Assicurarsi di includere eventuali altre opzioni utilizzate dall'istanza database. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
+ Al momento dell'aggiornamento dell'istanza database, specificare il nuovo gruppo di opzioni per la propria istanza database aggiornata.
Dopo l’aggiornamento della versione di Oracle APEX, lo schema Oracle APEX per la precedente versione potrebbe comunque rimanere all’interno del database. Se non ne hai più bisogno, puoi eliminare il vecchio schema Oracle APEX dal database dopo l’aggiornamento.
Se si aggiorna la versione di Oracle APEX e RESTful i servizi non erano configurati nella versione precedente di Oracle APEX, si consiglia di configurare RESTful i servizi. Per ulteriori informazioni, consulta [Configurazione dei RESTful servizi per Oracle APEX](Appendix.Oracle.Options.APEX.settingUp.md#Appendix.Oracle.Options.APEX.ConfigureRESTful).
In alcuni casi, quando pianifichi di eseguire un aggiornamento della versione principale dell’istanza database, è possibile che la versione APEX in uso non sia compatibile con la versione del database di destinazione. In questi casi, puoi aggiornare la versione di Oracle APEX prima di aggiornare l’istanza database. In questo modo, puoi ridurre il tempo necessario per aggiornare l’istanza database.
**Nota**
Dopo l’aggiornamento di Oracle APEX, installa e configura un listener da utilizzare con la versione aggiornata. Per istruzioni, consulta [Impostazione del listener Oracle APEX](Appendix.Oracle.Options.APEX.settingUp.md#Appendix.Oracle.Options.APEX.Listener).
## Aggiunta delle opzioni APEX e APEX-DEV
Puoi rimuovere le opzioni `APEX` e `APEX-DEV` dall’istanza database. Per rimuovere queste opzioni dall’istanza database, procedi in uno dei seguenti modi:
+ Per rimuovere le opzioni `APEX` e `APEX-DEV` da più istanze database, rimuovile dal gruppo di opzioni a cui appartengono. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Quando rimuovi le opzioni da un gruppo di opzioni associato a più istanze database, si verifica una breve interruzione mentre le istanze database vengono riavviate.
Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Per rimuovere le opzioni `APEX` e `APEX-DEV` da una singola istanza database, modifica l’istanza database e specifica un gruppo di opzioni diverso che non comprenda queste opzioni. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Quando rimuovi le opzioni, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente.
Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
Quando rimuovi le opzioni `APEX` e `APEX-DEV` da un’istanza database, lo schema APEX viene rimosso dal database.
# Integrazione Amazon EFS
Amazon Elastic File System (Amazon EFS) fornisce un'archiviazione di file serverless e completamente elastica in modo da poter condividere i dati dei file senza dover fornire o gestire la capacità e le prestazioni di archiviazione. Con Amazon EFS, puoi creare un file system e poi montarlo nel tuo VPC tramite le versioni 4.0 e 4.1 () NFSv4 del protocollo NFS. È quindi utilizzare il file system EFS come qualsiasi altro file system compatibile con POSIX. Per informazioni generali, consulta l'argomento relativo ad [Amazon Elastic File System](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) e il post del blog AWS relativo all'[integrazione di Amazon RDS per Oracle con Amazon EFS](https://aws.amazon.com//blogs/database/integrate-amazon-rds-for-oracle-with-amazon-efs/).
**Topics**
+ [Panoramica dell'integrazione Amazon EFS](#oracle-efs-integration.overview)
+ [Configurazione delle autorizzazioni di rete per l'integrazione RDS per Oracle con Amazon EFS](oracle-efs-integration.network.md)
+ [Configurazione delle autorizzazioni IAM per l'integrazione RDS per Oracle con Amazon EFS](oracle-efs-integration.iam.md)
+ [Aggiunta dell'opzione EFS\$1INTEGRATION](oracle-efs-integration.adding.md)
+ [Configurazione delle autorizzazioni del file system Amazon EFS](oracle-efs-integration.file-system.md)
+ [Trasferimento di file tra RDS per Oracle e un file system Amazon EFS](oracle-efs-integration.transferring.md)
+ [Rimozione dell'opzione EFS\$1INTEGRATION](oracle-efs-integration.removing.md)
+ [Risoluzione dei problemi di integrazione Amazon EFS](oracle-efs-integration.troubleshooting.md)
## Panoramica dell'integrazione Amazon EFS
Con Amazon EFS, è possibile trasferire file tra l'istanza database RDS per Oracle e un file system EFS. Ad esempio, è possibile utilizzare EFS per supportare i seguenti casi d'uso:
+ Condividere un file system tra applicazioni e più server di database.
+ Creare una directory condivisa per i file relativi alla migrazione, inclusi i file di dati delle tablespace trasportabili. Per ulteriori informazioni, consulta [Migrazione utilizzando le tablespace trasportabili Oracle](oracle-migrating-tts.md).
+ Archiviare e condividere i file di log di redo archiviati senza allocare spazio di archiviazione aggiuntivo sul server.
+ Utilizzare le utilità di Oracle Database, ad esempio `UTL_FILE` per leggere e scrivere file.
### Vantaggi dell'integrazione Amazon EFS
Quando si sceglie un file system EFS rispetto a soluzioni di trasferimento dati alternative, si ottengono i seguenti vantaggi:
+ È possibile trasferire file di Oracle Data Pump tra Amazon EFS e l'istanza database RDS per Oracle. Non è necessario copiare questi file localmente perché Data Pump importa direttamente dal file system EFS. Per ulteriori informazioni, consulta [Importazione di dati in Oracle in Amazon RDS](Oracle.Procedural.Importing.md).
+ La migrazione dei dati è più rapida rispetto all'utilizzo di un collegamento al database.
+ Si evita di allocare spazio di archiviazione sull'istanza database RDS per Oracle per contenere i file.
+ Un file system EFS può dimensionare automaticamente lo spazio di archiviazione senza richiedere il provisioning.
+ L'integrazione Amazon EFS non prevede tariffe o costi di configurazione minimi. I prezzi sono calcolati solo in base all'uso effettivo.
+ L’integrazione Amazon EFS supporta due forme di crittografia: la crittografia dei dati in transito e la crittografia dei dati a riposo. Con TLS versione 1.2, la crittografia dei dati in transito è abilitata per impostazione predefinita. Alla creazione di un file system Amazon EFS, è possibile abilitare la crittografia dei dati a riposo. Per ulteriori informazioni, consulta [Encrypting data at rest](https://docs.aws.amazon.com/efs/latest/ug/encryption-at-rest.html) (Crittografia dei dati a riposo) nella *Guida per l'utente di Amazon Elastic File System*.
### Requisiti per l'integrazione Amazon EFS
Verificare che vengano soddisfatti i seguenti requisiti:
+ Il database deve eseguire la versione 19.0.0.0.ru-2022-07.rur-2022-07.r1 o superiore.
+ L'istanza DB e il file system EFS devono trovarsi nello stesso Regione AWS VPC e. Account AWS RDS per Oracle non supporta l’accesso multi-account e multi-Regione per EFS.
+ La **risoluzione DNS** e i **nomi host DNS** devono essere abilitati per il VPC. Per ulteriori informazioni, consulta [Attributi DNS nel VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) nella *Guida per l'utente di Amazon Virtual Private Cloud*.
+ Se utilizzi un nome DNS nel comando `mount`, assicurati che il VPC sia configurato in modo da utilizzare il server DNS fornito da Amazon. I server DNS personalizzati non sono supportati.
+ Per eseguire il backup del file system EFS devi utilizzare soluzioni non RDS. RDS per Oracle non supporta backup automatici o snapshot di database manuali di un file system EFS. Per ulteriori informazioni, consulta [Backing up your Amazon EFS file systems](https://docs.aws.amazon.com/efs/latest/ug/efs-backup-solutions.html) (Backup dei file system Amazon EFS).
# Configurazione delle autorizzazioni di rete per l'integrazione RDS per Oracle con Amazon EFS
Affinché RDS per Oracle si integri con Amazon EFS, assicurati che l'istanza database disponga dell'accesso di rete a un file system EFS. Per ulteriori informazioni, consulta [Controlling network access to Amazon EFS file systems for NFS clients](https://docs.aws.amazon.com/efs/latest/ug/NFS-access-control-efs.html) (Controllo dell'accesso di rete ai file system Amazon EFS per i client NFS) nella *Guida per l'utente di Amazon Elastic File System*.
**Topics**
+ [Controllo degli accessi di rete con i gruppi di sicurezza](#oracle-efs-integration.network.inst-access)
+ [Controllo degli accesso di rete con le policy di file system](#oracle-efs-integration.network.file-system-policy)
## Controllo degli accessi di rete con i gruppi di sicurezza
È possibile controllare l'accesso dell'istanza database ai file system EFS utilizzando meccanismi di sicurezza a livello di rete come i gruppi di sicurezza VPC. Per consentire l'accesso a un file system EFS per l'istanza database, assicurati che il file system EFS soddisfi i seguenti requisiti:
+ In ogni zona di disponibilità utilizzata da un'istanza database RDS per Oracle è presente una destinazione di montaggio EFS.
Un *target di montaggio EFS* fornisce un indirizzo IP per un NFSv4 endpoint sul quale è possibile montare un file system EFS. Il file system è montato utilizzando il relativo nome DNS, che si risolverà nell'indirizzo IP della destinazione di montaggio di EFS nella stessa zona di disponibilità dell'istanza database.
È possibile configurare istanze DB in diverse istanze AZs per utilizzare lo stesso file system EFS. Per implementazioni Multi-AZ, è necessario disporre di un punto di montaggio per ogni zona di disponibilità definita nell'implementazione interessata. Potrebbe essere necessario spostare un'istanza database in una zona di disponibilità diversa. Per questi motivi, è consigliabile creare un punto di montaggio EFS in ogni zona di disponibilità presente nel cloud privato virtuale (VPC) in uso. Per impostazione predefinita, quando si crea un nuovo file system EFS utilizzando la console, RDS crea destinazioni di montaggio per tutti AZs.
+ Un gruppo di sicurezza è collegato alla destinazione di montaggio.
+ Il gruppo di sicurezza dispone di una regola in entrata per autorizzare la sottorete o il gruppo di sicurezza di rete dell'istanza database RDS per Oracle su TCP/2049 (tipo NFS).
Per ulteriori informazioni, consulta [Creazione di file system Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/creating-using-create-fs.html#configure-efs-network-access) e [Creating and managing EFS mount targets and security groups](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs.html) (Creazione e gestione delle destinazioni di montaggio e dei gruppi di sicurezza EFS) nella *Guida per l'utente di Amazon Elastic File System*.
## Controllo degli accesso di rete con le policy di file system
L'integrazione Amazon EFS con RDS per Oracle funziona con la policy di file system EFS predefinita (vuota). La policy predefinita non utilizza IAM per l'autenticazione. Garantisce invece l'accesso completo a qualsiasi client anonimo in grado di connettersi al file system utilizzando una destinazione di montaggio. La policy predefinita è effettiva ogni volta che non esiste una policy di file system configurata dall'utente, anche a livello di creazione del file system. Per ulteriori informazioni, consulta [Policy EFS predefinita per il file system EFS](https://docs.aws.amazon.com/efs/latest/ug/iam-access-control-nfs-efs.html#default-filesystempolicy) nella *Guida per l'utente di Amazon Elastic File System*.
Per rafforzare l'accesso al file system EFS per tutti i client, incluso RDS per Oracle, puoi configurare le autorizzazioni IAM. Con questo approccio si crea una policy di file system. Per ulteriori informazioni, consulta [Creating file system policies](https://docs.aws.amazon.com/efs/latest/ug/create-file-system-policy.html) (Creazione di policy di file system) nella *Guida per l'utente di Amazon Elastic File System*.
# Configurazione delle autorizzazioni IAM per l'integrazione RDS per Oracle con Amazon EFS
Per impostazione predefinita, la funzionalità di integrazione di Amazon EFS non utilizza un ruolo IAM: l’impostazione dell’opzione `USE_IAM_ROLE` è `FALSE`. Per l’integrazione di RDS per Oracle con Amazon EFS e un ruolo IAM, è necessario che l’istanza database disponga delle autorizzazioni IAM per l’accesso a un file system Amazon EFS.
**Topics**
+ [Fase 1: creazione di un ruolo IAM per l'istanza database e collegamento della policy](#oracle-efs-integration.iam.role)
+ [Fase 2: creazione di una policy per il file system Amazon EFS](#oracle-efs-integration.iam.policy)
+ [Fase 3: associazione del ruolo IAM all'istanza database RDS per Oracle](#oracle-efs-integration.iam.instance)
## Fase 1: creazione di un ruolo IAM per l'istanza database e collegamento della policy
In questa fase, viene creato un ruolo per l'istanza database RDS per Oracle per consentire ad Amazon RDS di accedere al file system EFS.
### Console
**Per creare un ruolo IAM per consentire ad Amazon RDS di accedere a un file system EFS**
1. Aprire la [console di gestione IAM](https://console.aws.amazon.com/iam/home?#home).
1. Nel pannello di navigazione, seleziona **Roles** (Ruoli).
1. Selezionare **Create role (Crea ruolo)**.
1. In **AWS Service** scegliere **RDS**.
1. Per **Select your use case (Seleziona caso di utilizzo)**, selezionare **RDS – Add Role to Database (RDS – Aggiungi ruolo al database)**.
1. Scegli **Next (Successivo)**.
1. Non aggiungere alcuna policy di autorizzazione. Scegli **Next (Successivo)**.
1. Impostare **Role Name (Nome ruolo)** su un nome per il ruolo IAM, ad esempio `rds-efs-integration-role`. È anche possibile aggiungere un valore **Description (Descrizione)** facoltativo.
1. Scegli **Crea ruolo**.
### AWS CLI
Per limitare le autorizzazioni del servizio a una risorsa specifica, si consiglia di utilizzare le chiavi di contesto delle condizioni globali [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount) nelle relazioni di trust basate sulle risorse. Questo è il modo più efficace per proteggersi dal [problema di deputy confused](https://docs.aws.amazon.com/IAM/latest/UserGuide/confused-deputy.html).
Puoi usare le chiavi di contesto delle condizioni globali e avere il valore `aws:SourceArn` che contiene l'ID dell'account. In questo caso, il valore `aws:SourceAccount` e l'account nel valore `aws:SourceArn` deve utilizzare lo stesso ID account quando viene utilizzato nella stessa istruzione.
+ Utilizzare `aws:SourceArn` se si desidera un accesso cross-service per una singola risorsa.
+ Utilizzare `aws:SourceAccount` se si desidera consentire l'associazione di qualsiasi risorsa in tale account all'uso cross-service.
Nella relazione di trust, assicurati di utilizzare la chiave di contesto della condizione globale `aws:SourceArn` con l'Amazon Resource Name (ARN) completo delle risorse che accedono al ruolo.
Il AWS CLI comando seguente crea il ruolo denominato `rds-efs-integration-role` per questo scopo.
**Example**
Per Linux, macOS o Unix:
```
aws iam create-role \
--role-name rds-efs-integration-role \
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": my_account_ID,
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
Per Windows:
```
aws iam create-role ^
--role-name rds-efs-integration-role ^
--assume-role-policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "rds.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": my_account_ID,
"aws:SourceArn": "arn:aws:rds:Region:my_account_ID:db:dbname"
}
}
}
]
}'
```
Per ulteriori informazioni, consulta la pagina relativa alla [creazione di un ruolo per delegare le autorizzazioni a un utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) nella *Guida per l'utente IAM*.
## Fase 2: creazione di una policy per il file system Amazon EFS
In questa fase viene creata una policy per il file system EFS.
**Per creare o modificare una policy di file system EFS**
1. Apri la [console di gestione EFS](https://console.aws.amazon.com/efs/home?#home).
1. Selezionare **File Systems (File system)**.
1. Nella pagina **File systems** (File system), scegli il file system per cui vuoi creare una policy di file system. Viene visualizzata la pagina dei dettagli per il file system scelto.
1. Scegli la scheda **File system policy** (Policy di file system).
Se è vuota, viene utilizzata la policy di file system EFS predefinita. Per ulteriori informazioni, consulta [Policy EFS predefinita per il file system EFS](https://docs.aws.amazon.com/efs/latest/ug/iam-access-control-nfs-efs.html#default-filesystempolicy ) nella *Guida per l'utente di Amazon Elastic File System*.
1. Scegli **Modifica**. Viene visualizzata la pagina **Policy del file system**.
1. Nell'**editor di policy**, immetti una policy come la seguente, quindi scegli **Save** (Salva).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "ExamplePolicy01",
"Statement": [
{
"Sid": "ExampleStatement01",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:role/rds-efs-integration-role"
},
"Action": [
"elasticfilesystem:ClientMount",
"elasticfilesystem:ClientWrite",
"elasticfilesystem:ClientRootAccess"
],
"Resource": "arn:aws:elasticfilesystem:us-east-1:123456789012:file-system/fs-1234567890abcdef0"
}
]
}
```
------
## Fase 3: associazione del ruolo IAM all'istanza database RDS per Oracle
In questa fase il ruolo IAM viene associato all'istanza database. Tieni presenti i seguenti requisiti:
+ Devi disporre dell'accesso a un ruolo IAM a cui è collegata la policy di autorizzazione richiesta di Amazon EFS.
+ È possibile associare un solo ruolo IAM alla volta all'istanza database RDS per Oracle.
+ Lo stato dell'istanza deve essere **Available** (Disponibile).
Per ulteriori informazioni, consulta [Identity and access management for Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/auth-and-access-control.html) (Identity and Access Management per Amazon EFS) nella *Guida per l'utente di Amazon Elastic File System*.
### Console
**Per associare il ruolo IAM all'istanza database RDS per Oracle**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Scegli **Database**.
1. Se l'istanza del database non è disponibile, scegli **Operazioni** , quindi **Avvia**. Quando lo stato dell'istanza mostra **Avviato**, vai al passaggio successivo.
1. Scegliere il nome dell'istanza database Oracle per visualizzarne i dettagli.
1. Sulla scheda **Connettività e sicurezza**, scorri verso il basso fino alla sezione **Gestisci i ruoli IAM** in fondo alla pagina.
1. Scegli il ruolo da aggiungere nella sezione **Aggiungi ruoli IAM a questa istanza**.
1. Per **Feature** (Caratteristica) scegli **EFS\$1INTEGRATION**.
1. Scegliere **Add role (Aggiungi ruolo)**.
### AWS CLI
Il AWS CLI comando seguente aggiunge il ruolo a un'istanza Oracle DB denominata`mydbinstance`.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-role-to-db-instance \
--db-instance-identifier mydbinstance \
--feature-name EFS_INTEGRATION \
--role-arn your-role-arn
```
Per Windows:
```
aws rds add-role-to-db-instance ^
--db-instance-identifier mydbinstance ^
--feature-name EFS_INTEGRATION ^
--role-arn your-role-arn
```
Sostituire `your-role-arn` con il ruolo ARN annotato nel passaggio precedente. `EFS_INTEGRATION` deve essere specificato per l'opzione `--feature-name`.
# Aggiunta dell'opzione EFS\$1INTEGRATION
Per utilizzare l'integrazione Amazon RDS per Oracle con Amazon EFS, l'istanza database deve essere associata a un gruppo di opzioni che include l'opzione `EFS_INTEGRATION`.
Più istanze database Oracle che appartengono allo stesso gruppo di opzioni condividono lo stesso file system EFS. Istanze database diverse possono accedere agli stessi dati e l'accesso può essere diviso in diverse directory Oracle. Per ulteriori informazioni, consulta [Trasferimento di file tra RDS per Oracle e un file system Amazon EFS](oracle-efs-integration.transferring.md).
## Console
**Per configurare un gruppo di opzioni per l'integrazione Amazon EFS**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `EFS_INTEGRATION`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `EFS_INTEGRATION` al gruppo di opzioni. È necessario specificare l'ID file system `EFS_ID` e impostare il flag `USE_IAM_ROLE`.
Per ulteriori informazioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Associa il gruppo di opzioni all'istanza database in uno dei seguenti modi:
+ Crea una nuova istanza database Oracle e associa il gruppo di opzioni. Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza database Oracle per associare il gruppo di opzioni. Per informazioni sulla modifica di un'istanza database di Oracle, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## AWS CLI
**Per configurare un gruppo di opzioni per l'integrazione EFS**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `EFS_INTEGRATION`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `EFS_INTEGRATION` al gruppo di opzioni.
Ad esempio, il comando seguente AWS CLI aggiunge l'opzione `EFS_INTEGRATION` a un gruppo opzioni denominato **myoptiongroup**.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name myoptiongroup \
--options "OptionName=EFS_INTEGRATION,OptionSettings=\
[{Name=EFS_ID,Value=fs-1234567890abcdef0},{Name=USE_IAM_ROLE,Value=TRUE}]"
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name myoptiongroup ^
--options "OptionName=EFS_INTEGRATION,OptionSettings=^
[{Name=EFS_ID,Value=fs-1234567890abcdef0},{Name=USE_IAM_ROLE,Value=TRUE}]"
```
1. Associa il gruppo di opzioni all'istanza database in uno dei seguenti modi:
+ Crea una nuova istanza database Oracle e associa il gruppo di opzioni. Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Modifica un'istanza database Oracle per associare il gruppo di opzioni. Per informazioni sulla modifica di un'istanza database di Oracle, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Configurazione delle autorizzazioni del file system Amazon EFS
Per impostazione predefinita, solo l'utente root (UID `0`) dispone delle autorizzazioni di lettura, scrittura ed esecuzione per un file system EFS appena creato. Affinché gli altri utenti possano modificare il file system, l'utente root deve esplicitamente concedere loro l'accesso. L'utente dell'istanza database RDS per Oracle rientra nella categoria `others`. Per ulteriori informazioni, consulta [Working with users, groups, and permissions at the Network File System (NFS) Level](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html) (Utilizzo di utenti, gruppi e autorizzazioni a livello NFS (Network File System) nella *Guida per l'utente di Amazon Elastic File System*.
Per consentire all'istanza database RDS per Oracle di leggere e scrivere file nel file system EFS, procedi come segue:
+ Monta un file system EFS localmente nell'istanza on-premise o Amazon EC2.
+ Configura le autorizzazioni in modo dettagliato.
Ad esempio, per concedere a `other` utenti le autorizzazioni di scrittura nella root del file system EFS, esegui `chmod 777` sulla directory. Per ulteriori informazioni, consulta [Esempio di casi d'uso e autorizzazioni del file system Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/accessing-fs-nfs-permissions.html#accessing-fs-nfs-permissions-ex-scenarios) nella *Guida per l'utente di Amazon Elastic File System*.
# Trasferimento di file tra RDS per Oracle e un file system Amazon EFS
Per trasferire file tra un'istanza RDS per Oracle e un file system Amazon EFS, crea almeno una directory Oracle e configura le autorizzazioni del file system EFS per controllare l'accesso all'istanza database.
**Topics**
+ [Creazione di una directory Oracle](#oracle-efs-integration.transferring.od)
+ [Trasferimento di dati da e verso un file system EFS - Esempi](#oracle-efs-integration.transferring.upload)
## Creazione di una directory Oracle
Per creare una directory Oracle, usa la procedura `rdsadmin.rdsadmin_util.create_directory_efs`. La procedura include i seguenti parametri.
****
| Nome del parametro | Tipo di dati | Default | Campo obbligatorio | Descrizione |
| --- | --- | --- | --- | --- |
| `p_directory_name` | VARCHAR2 | – | Sì | Il nome della directory Oracle. |
| `p_path_on_efs` | VARCHAR2 | – | Sì | Il percorso del file system EFS. Il prefisso del nome del percorso utilizza lo schema`/rdsefs-fsid/`, dove *fsid* è un segnaposto per l'ID del file system EFS. Ad esempio, se il file system EFS è denominato `fs-1234567890abcdef0` e crei una sottodirectory su questo file system denominata `mydir`, puoi specificare il seguente valore: /rdsefs-fs-1234567890abcdef0/mydir
|
Supponi di creare una sottodirectory denominata `/datapump1` nel file system EFS `fs-1234567890abcdef0`. L'esempio seguente crea una directory Oracle `DATA_PUMP_DIR_EFS` che punta alla directory `/datapump1` sul file system EFS. Il valore del percorso del file system per il parametro`p_path_on_efs` è preceduto dalla stringa `/rdsefs-`.
```
BEGIN
rdsadmin.rdsadmin_util.create_directory_efs(
p_directory_name => 'DATA_PUMP_DIR_EFS',
p_path_on_efs => '/rdsefs-fs-1234567890abcdef0/datapump1');
END;
/
```
## Trasferimento di dati da e verso un file system EFS - Esempi
Nell'esempio seguente si usa Oracle Data Pump per esportare la tabella denominata `MY_TABLE` nel file `datapump.dmp`. Questo file si trova in un file system EFS.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(operation => 'EXPORT', job_mode => 'TABLE', job_name=>null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump.dmp',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_dump_file);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump-exp.log',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'NAME_EXPR','IN (''MY_TABLE'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
Nell'esempio seguente si usa Oracle Data Pump per importare la tabella denominata `MY_TABLE` dal file `datapump.dmp`. Questo file si trova in un file system EFS.
```
DECLARE
v_hdnl NUMBER;
BEGIN
v_hdnl := DBMS_DATAPUMP.OPEN(
operation => 'IMPORT',
job_mode => 'TABLE',
job_name => null);
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump.dmp',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_dump_file );
DBMS_DATAPUMP.ADD_FILE(
handle => v_hdnl,
filename => 'datapump-imp.log',
directory => 'DATA_PUMP_DIR_EFS',
filetype => dbms_datapump.ku$_file_type_log_file);
DBMS_DATAPUMP.METADATA_FILTER(v_hdnl,'NAME_EXPR','IN (''MY_TABLE'')');
DBMS_DATAPUMP.START_JOB(v_hdnl);
END;
/
```
Per ulteriori informazioni, consulta [Importazione di dati in Oracle in Amazon RDS](Oracle.Procedural.Importing.md).
# Rimozione dell'opzione EFS\$1INTEGRATION
La procedura da seguire per la rimozione dell’opzione `EFS_INTEGRATION` dipende dal fatto che l’opzione venga rimossa da più istanze database o da una singola istanza.
| Numero di istanze database | Azione | Informazioni correlate |
| --- | --- | --- |
| Più di uno | Rimuovere l’opzione EFS\$1INTEGRATION dal gruppo di opzioni a cui appartengono le istanze database. Questa modifica coinvolge tutte le istanze che utilizzano il gruppo di opzioni. | [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption) |
| Singolo | Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione EFS\$1INTEGRATION. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. | [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md) |
Dopo aver rimosso l’opzione `EFS_INTEGRATION`, puoi facoltativamente eliminare il file system EFS connesso alle istanze database.
# Risoluzione dei problemi di integrazione Amazon EFS
L'istanza database RDS per Oracle monitora la connettività al file system Amazon EFS. Quando il monitoraggio rileva un problema, viene eseguito un tentativo di correzione e la pubblicazione di un evento nella console RDS. Per ulteriori informazioni, consulta [Visualizzazione di eventi Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ListEvents.html).
Utilizza le informazioni contenute in questa sezione per diagnosticare e risolvere problemi comuni quando si utilizza l'integrazione Amazon EFS.
| Notification | Description | Azione |
| --- | --- | --- |
| `The EFS for RDS Oracle instance instance_name isn't available on the primary host. NFS port 2049 of your EFS isn't reachable.` | L'istanza database non è in grado di comunicare con il file system EFS. | Assicurati che siano soddisfatte le seguenti condizioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `The EFS isn't reachable.` | Si è verificato un errore durante l'installazione dell'opzione `EFS_INTEGRATION`. | Assicurati che siano soddisfatte le seguenti condizioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `The associated role with your DB instance wasn't found.` | Si è verificato un errore durante l'installazione dell'opzione `EFS_INTEGRATION`. | Assicurati di aver associato un ruolo IAM all'istanza database RDS per Oracle. |
| `The associated role with your DB instance wasn't found.` | Si è verificato un errore durante l'installazione dell'opzione `EFS_INTEGRATION`. RDS per Oracle è stato ripristinato da uno snapshot database con l’opzione `USE_IAM_ROLE` impostata su `TRUE`. | Assicurati di aver associato un ruolo IAM all'istanza database RDS per Oracle. |
| `The associated role with your DB instance wasn't found.` | Si è verificato un errore durante l'installazione dell'opzione `EFS_INTEGRATION`. RDS for Oracle è stato creato a partire da un all-in-one CloudFormation modello con l'impostazione dell'`USE_IAM_ROLE`opzione di`TRUE`. | Per ovviare a questo problema, effettua le seguenti operazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
| `PLS-00302: component 'CREATE_DIRECTORY_EFS' must be declared` | Questo errore può verificarsi quando si utilizza una versione di RDS per Oracle che non supporta Amazon EFS. | Assicurati di utilizzare l'istanza database RDS per Oracle versione 19.0.0.0.ru-2022-07.rur-2022-07.r1 o successive. |
| `Read access of your EFS is denied. Check your file system policy.` | L'istanza database non è in grado di leggere il file system EFS. | Assicurati che il file system EFS consenta l'accesso in lettura tramite il ruolo IAM o a livello di file system EFS. |
| N/D | L'istanza database non è in grado di scrivere nel file system EFS. | Utilizza le fasi seguenti: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/oracle-efs-integration.troubleshooting.html) |
# Oracle Java Virtual Machine
Amazon RDS supporta Oracle Java Virtual Machine (JVM) tramite l'utilizzo dell'opzione `JVM`. Oracle Java fornisce uno schema SQL e funzioni che facilitano l'utilizzo delle caratteristiche Oracle Java in un database Oracle. Per ulteriori informazioni, consulta l'articolo relativo all'[introduzione a Java in Oracle Database](https://docs.oracle.com/database/121/JJDEV/chone.htm) nella documentazione Oracle. È possibile utilizzare Oracle JVM con tutte le versioni di Oracle Database 21c (21.0.0) e Oracle Database 19c (19.0.0).
## Considerazioni per Oracle JVM
L'implementazione Java in Amazon RDS ha un set di autorizzazioni limitato. L'utente master riveste il ruolo `RDS_JAVA_ADMIN`, che concede un sottoinsieme dei privilegi concessi dal ruolo `JAVA_ADMIN`. Per elencare i privilegi concessi al ruolo `RDS_JAVA_ADMIN`, esegui la query seguente sull'istanza database:
```
SELECT * FROM dba_java_policy
WHERE grantee IN ('RDS_JAVA_ADMIN', 'PUBLIC')
AND enabled = 'ENABLED'
ORDER BY type_name, name, grantee;
```
## Prerequisiti per Oracle JVM
Di seguito sono indicati i prerequisiti per l'utilizzo di Oracle Java:
+ L'istanza database deve appartenere a una classe di dimensioni sufficienti. Oracle Java non è supportato per le classi di istanza database db.t3.small. Per ulteriori informazioni, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
+ L'istanza database deve avere l'opzione **Auto Minor Version Upgrade (Aggiornamento minore automatico della versione)** abilitata. Questa opzione consente all'istanza database di ricevere automaticamente gli aggiornamenti della versione secondaria del motore database quando diventano disponibili. Amazon RDS utilizza questa opzione per aggiornare l'istanza database all'ultimo PSU (Patch Set Update) o RU (Release Update) di Oracle. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Best practice per Oracle JVM
Di seguito sono indicate le best practice per l'utilizzo di Oracle Java:
+ Per la massima sicurezza, è necessario utilizzare l'opzione `JVM` con Secure Sockets Layer (SSL). Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
+ Configurare l'istanza database per limitare l'accesso alla rete. Per ulteriori informazioni, consulta [Scenari per accedere a un'istanza database in un VPC](USER_VPC.Scenarios.md) e [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
+ Aggiorna la configurazione degli endpoint HTTPS al supporto TLSv1 .2 se soddisfi le seguenti condizioni:
+ Si utilizza Oracle Java Virtual Machine (JVM) per connettere un endpoint HTTPS tramite protocolli 1 o 1. TLSv1 TLSv1
+ L'endpoint non supporta il protocollo .2. TLSv1
+ Non hai applicato l'aggiornamento della release di aprile 2021 al tuo Oracle DB.
Aggiornando la configurazione dell'endpoint, assicurati che la connettività della JVM all'endpoint HTTPS continui a funzionare. Per ulteriori informazioni sulle modifiche di TLS in Oracle JRE e JDK, consulta [Oracle JRE and JDK Cryptographic Roadmap](https://java.com/en/jre-jdk-cryptoroadmap.html).
## Aggiunta dell'opzione Oracle JVM
Di seguito è riportato il processo generale per aggiungere l'opzione `JVM` a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Si verificherà una breve interruzione durante l'aggiunta dell'opzione `JVM`. Una volta aggiunta l'opzione, non è necessario riavviare l'istanza database. Non appena il gruppo di opzioni diventa attivo, Oracle Java è disponibile.
**Nota**
Durante questa interruzione, le funzioni di verifica delle password vengono temporaneamente disabilitate. Durante l'interruzione si possono verificare eventi correlati alle funzioni di verifica delle password. Le funzioni di verifica delle password vengono riabilitate prima di rendere disponibile l'istanza database Oracle.
**Per aggiungere l'opzione JVM a un'istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
+ Per **Engine (Motore)** scegliere il motore database utilizzato dall'istanza database (**oracle-ee**, **oracle-se**, **oracle-se1** o **oracle-se2**).
+ In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **JVM** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, applicare il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, applicare il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
1. Concedere le autorizzazioni richieste agli utenti.
L'utente master di Amazon RDS ha le autorizzazioni per utilizzare l'opzione `JVM` per impostazione predefinita. Se altri utenti richiedono queste autorizzazioni, connettersi all'istanza database come utente master in un client SQL e concedere le autorizzazioni a questi utenti.
Nell'esempio seguente le autorizzazioni all'utilizzo dell'opzione `JVM` vengono concesse all'utente `test_proc`.
```
create user test_proc identified by password;
CALL dbms_java.grant_permission('TEST_PROC', 'oracle.aurora.security.JServerPermission', 'LoadClassInPackage.*', '');
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Dopo aver concesso le autorizzazioni, la query seguente dovrebbe restituire un output.
```
select * from dba_java_policy where grantee='TEST_PROC';
```
**Nota**
Il nome utente Oracle rispetta la distinzione tra maiuscole e minuscole e di solito è formato solo da caratteri maiuscoli.
## Rimozione dell'opzione Oracle JVM
Puoi rimuovere l'opzione `JVM` dall'istanza database. Si verificherà una breve interruzione durante la rimozione dell'opzione . Una volta rimossa l'opzione `JVM` non è necessario riavviare la tua istanza database.
**avvertimento**
La rimozione dell'opzione `JVM` può causare la perdita di dati se l'istanza database utilizza i tipi di dati abilitati come parte dell'opzione. Eseguire il backup dei dati prima di procedere. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
Per rimuovere l'opzione `JVM` dall'istanza database, procedi in uno dei seguenti modi:
+ Rimuovere l'opzione `JVM` dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione `JVM`. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle Enterprise Manager
Amazon RDS supporta Oracle Enterprise Manager (OEM). OEM è la linea di prodotti Oracle per la gestione integrata della tecnologia informatica aziendale.
Amazon RDS supporta OEM su CBD o non CBD Oracle Database 19c. Nella seguente tabella sono descritte le opzioni di OEM supportate.
****
| Opzione | ID opzione | Versioni OEM supportate |
| --- | --- | --- |
| [OEM Database Express](Appendix.Oracle.Options.OEM_DBControl.md) | `OEM` | OEM Database Express 19c |
| [OEM Management Agent](Oracle.Options.OEMAgent.md) | `OEM_AGENT` | OEM Cloud Control per 13c |
**Nota**
Puoi utilizzare OEM Database oppure OEM Management Agent, ma non entrambi.
# Oracle Enterprise Manager Database Express
Amazon RDS supporta Oracle Enterprise Manager Database Express (EM Express) tramite l’utilizzo dell’opzione OEM. Amazon RDS supporta EM Express per Oracle Database 19c utilizzando l’architettura CDB o non CDB.
EM Express è uno strumento di gestione dei database basato sul web incluso nel database ed è disponibile solo quando è aperto. Supporta la gestione delle prestazioni chiave e le funzioni di amministrazione di base del database. Per ulteriori informazioni, consulta l’articolo [Introduction to Oracle Enterprise Manager Database Express](https://docs.oracle.com/en/database/oracle/oracle-database/19/admqs/getting-started-with-database-administration.html#GUID-BA75AD46-D22E-4914-A31E-C395CD6A2BBA) nella documentazione di Oracle Database.
**Nota**
EM Express non è supportato nelle classi di istanze database db.t3.small. Per maggiori informazioni sulle classi di istanza database, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
## Impostazioni dell’opzione OEM
Amazon RDS supporta le seguenti impostazioni per l'opzione OEM.
****
| Impostazione opzioni | Valori validi | Descrizione |
| --- | --- | --- |
| **Porta** | Un valore intero. | La porta sull’istanza database RDS per Oracle in ascolto di EM Express. Il valore predefinito è 5500. |
| **Gruppi di sicurezza** | — | Un gruppo di sicurezza che ha accesso a **Port (Porta)**. |
## Passaggio 1: aggiunta dell’opzione OEM
Di seguito è riportato il processo generale per aggiungere l'opzione OEM a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associa il gruppo di opzioni a questa istanza database.
Quando aggiungi l’opzione OEM, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente.
**Per aggiungere l'opzione OEM a un'istanza database**
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine (Motore)** scegliere l'edizione Oracle per l'istanza database.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione OEM al gruppo di opzioni e configurare le impostazioni dell'opzione. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell’opzione OEM](#Appendix.Oracle.Options.OEM_DBControl.Options).
**Nota**
Se aggiungi l’opzione OEM a un gruppo di opzioni esistente già associato a una o più istanze database, si verifica una breve interruzione mentre tutte le istanze database vengono riavviate automaticamente.
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, applicare il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, applicare il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Quando aggiungi l’opzione OEM, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
**Nota**
Puoi anche usare AWS CLI per aggiungere l'opzione OEM. Per alcuni esempi, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
## Passaggio 2: (solo CDB) sblocco dell’account utente DBSNMP
Se l’istanza database utilizza l’architettura CDB, è necessario accedere a EM Express come `DBSNMP`. In un CDB `DBSNMP` è un utente comune. Per impostazione predefinita, questo account è bloccato. Se l’istanza database non utilizza l’architettura CDB, salta questo passaggio.
**Per sbloccare l’account utente DBSNMP in un’istanza CDB**
1. In SQL\$1Plus o in un’altra applicazione Oracle SQL, accedi come utente master all’istanza database.
1. Esegui la seguente procedura memorizzata per sbloccare l’account `DBSNMP`:
```
1. EXEC rdsadmin.rdsadmin_util.reset_oem_agent_password('new_password');
```
Se viene visualizzato un errore per segnalare che la procedura non esiste, riavvia l’istanza CDB per installarla automaticamente. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
## Passaggio 3: accesso a EM Express tramite il browser
Quando accedi EM Express dal browser web, viene visualizzata una finestra di accesso in cui ti viene chiesto di immettere il nome utente e la password.
**Per accedere a EM Express tramite il browser**
1. Identifica l’endpoint e la porta EM Express per l’istanza database Amazon RDS. Per informazioni su come trovare l’endpoint per l’istanza database Amazon RDS, consulta [Esito dell'endpoint dell'istanza database RDS per Oracle](USER_Endpoint.md).
1. Inserisci un URL nella barra di localizzazione del browser utilizzando il seguente formato.
```
https://endpoint.rds.amazonaws.com:port/em
```
Ad esempio, se l’endpoint dell’istanza database Amazon RDS è `mydb.a1bcde234fgh.us-east-1.rds.amazonaws.com` e la porta EM Express è `1158`, utilizza il seguente URL per accedere a EM Express.
```
1. https://mydb.f9rbfa893tft.us-east-1.rds.amazonaws.com:1158/em
```
1. Quando ti vengono richiesti i dati di accesso, esegui la procedura riportata di seguito, a seconda dell’architettura del tuo database:
**Il database è un database non CDB.**
Immetti il nome utente master e la password master dell'istanza database.
**Il database è un CDB.**
Immetti `DBSNMP` per l’utente e la password `DBSNMP`. Lascia vuoto il campo `Container`.
## Modifica delle impostazioni di OEM Database
Dopo avere abilitato OEM Database, puoi modificare l'impostazione dei gruppi di sicurezza dell'opzione.
Non è possibile modificare il numero di porta OEM dopo avere associato il gruppo di opzioni a un'istanza database. Per modificare il numero di porta OEM utilizzato per un'istanza database, procedi come indicato di seguito:
1. Crea un nuovo gruppo di opzioni.
1. Aggiungi l'opzione OEM con il numero di porta al nuovo gruppo di opzioni.
1. Rimuovi il gruppo di opzioni esistente dall'istanza database.
1. Aggiungi il nuovo gruppo di opzioni all'istanza database.
Per ulteriori informazioni su come modificare le impostazioni dell'opzione, consulta [Modifica di un'impostazione di un'opzione](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell’opzione OEM](#Appendix.Oracle.Options.OEM_DBControl.Options).
## Esecuzione di attività OEM Database Express
Puoi utilizzare le procedure Amazon RDS per eseguire determinate attività OEM Database Express. Con queste procedure, puoi eseguire le attività elencate di seguito.
**Nota**
Le attività OEM Database Express vengono eseguite in modo asincrono.
**Topics**
+ [Cambiare il front-end del sito Web per OEM Database Express in Adobe Flash](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToFlash)
+ [Cambiare il front-end del sito Web per OEM Database Express in Oracle JET](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToOracleJET)
### Cambiare il front-end del sito Web per OEM Database Express in Adobe Flash
**Nota**
Questo task è disponibile solo per Oracle Database 19c non-. CDBs
A partire da Oracle Database 19c, Oracle ha dichiarato obsoleta la precedente interfaccia utente OEM Database Express, basata su Adobe Flash. OEM Database Express utilizza ora un'interfaccia creata con Oracle JET. In caso di problemi con la nuova interfaccia, puoi tornare all'interfaccia basata su Flash che è stata dichiarata obsoleta. I problemi che si possono verificare con la nuova interfaccia includono il restare bloccati in una schermata `Loading` dopo aver effettuato l'accesso a OEM Database Express. Potrebbero anche mancare alcune funzionalità importanti che erano presenti nella versione basata su Flash di OEM Database Express.
Per cambiare il front-end del sito Web di OEM Database Express in Adobe Flash, eseguire la procedura Amazon RDS `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash`. Questa procedura equivale al comando SQL `execemx emx`.
Le best practice di sicurezza scoraggiano l'uso di Adobe Flash. Sebbene sia possibile ripristinare l'OEM Database Express basato su Flash, è consigliabile utilizzare i siti Web OEM Database Express basati su Jet, se possibile. Se ripristini l'utilizzo di Adobe Flash e desideri tornare a utilizzare Oracle JET, utilizza la procedura `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet`. Dopo un aggiornamento del database Oracle, una versione più recente di Oracle JET potrebbe risolvere i problemi relativi a JET in OEM Database Express. Per ulteriori informazioni sul passaggio a Oracle JET, consulta [Cambiare il front-end del sito Web per OEM Database Express in Oracle JET](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToOracleJET).
**Nota**
L'esecuzione di questa attività dall'istanza database di origine per una replica di lettura ha anche come conseguenza che i front-end del sito Web di OEM Database Express cambiano in Adobe Flash.
La seguente invocazione di procedura crea un'attività per cambiare il sito Web di OEM Database Express in Adobe Flash e restituire l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash() as TASK_ID from DUAL;
```
È possibile visualizzare il risultato visualizzando il file di output dell'attività.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
Sostituire *`task-id`* con l'ID attività restituito dalla procedura. Per ulteriori informazioni sulla procedura Amazon RDS `rdsadmin.rds_file_util.read_text_file`, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)
È inoltre possibile visualizzare il contenuto del file di output del task in cercando tra le voci Console di gestione AWS di registro nella sezione **Registri ed eventi** il. `task-id`
### Cambiare il front-end del sito Web per OEM Database Express in Oracle JET
**Nota**
Questo task è disponibile solo per Oracle Database 19c non-. CDBs
Per cambiare il front-end del sito Web di OEM Database Express in Adobe Flash, eseguire la procedura Amazon RDS `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet`. Questa procedura equivale al comando SQL `execemx omx`.
Per impostazione predefinita, i siti Web di OEM Database Express per le istanze database di Oracle che eseguono 19c o versioni successive utilizzano Oracle JET. Se è stata utilizzata la procedura `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_flash` per cambiare il front-end del sito Web di OEM di Database Express in Adobe Flash, è possibile tornare a Oracle JET. Per fare ciò, utilizza la procedura `rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet`. Per ulteriori informazioni sul passaggio ad Adobe Flash, consulta [Cambiare il front-end del sito Web per OEM Database Express in Adobe Flash](#Appendix.Oracle.Options.OEM_DBControl.DBTasks.FrontEndToFlash).
**Nota**
L'esecuzione di questa attività dall'istanza database di origine per una replica di lettura ha anche come conseguenza che i front-end del sito Web di OEM Database Express cambiano in Oracle JET.
La seguente invocazione di procedura crea un'attività per cambiare il sito Web di OEM Database Express in Oracle JET e restituire l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_tasks.em_express_frontend_to_jet() as TASK_ID from DUAL;
```
È possibile visualizzare il risultato visualizzando il file di output dell'attività.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-task-id.log'));
```
Sostituire *`task-id`* con l'ID attività restituito dalla procedura. Per ulteriori informazioni sulla procedura Amazon RDS `rdsadmin.rds_file_util.read_text_file`, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles)
È inoltre possibile visualizzare il contenuto del file di output del task in cercando tra le voci Console di gestione AWS di registro nella sezione **Registri ed eventi** il. `task-id`
## Rimozione dell'opzione OEM Database
Puoi rimuovere l'opzione OEM da un'istanza database. Quando rimuovi l’opzione OEM, si verifica una breve interruzione mentre l’istanza viene riavviata automaticamente. Quindi, una volta rimossa l'opzione OEM, non è necessario riavviare l'istanza database.
Per rimuovere l'opzione OEM dall'istanza database, procedi in uno dei seguenti modi:
+ Rimuovi l'opzione OEM dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modifica l'istanza database e specifica un diverso gruppo di opzioni che non comprenda l'opzione OEM. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle Management Agent per Enterprise Manager Cloud Control
Oracle Management Agent (OEM) è un componente software che monitora destinazioni in esecuzione su host e comunica tali informazioni a Oracle Management Service (OMS) di livello intermedio. Amazon RDS supporta Management Agent tramite l'utilizzo dell'opzione `OEM_AGENT`.
Per ulteriori informazioni, consulta [Overview of Oracle Enterprise Manager Cloud Control 12c](http://docs.oracle.com/cd/E24628_01/doc.121/e25353/overview.htm) e [Overview of Oracle Enterprise Manager Cloud Control 13c](http://docs.oracle.com/cd/E63000_01/EMCON/overview.htm#EMCON109) nella documentazione Oracle.
**Topics**
+ [Requisiti per Management Agent](#Oracle.Options.OEMAgent.PreReqs)
+ [Prerequisiti di comunicazione host OMS](#Oracle.Options.OEMAgent.PreReqs.host)
+ [Limitazioni per Management Agent](#Oracle.Options.OEMAgent.limitations)
+ [Impostazioni dell'opzione per Management Agent](#Oracle.Options.OEMAgent.Options)
+ [Abilitazione dell’opzione Management Agent per l’istanza database](#Oracle.Options.OEMAgent.Enable)
+ [Rimozione dell'opzione Management Agent](#Oracle.Options.OEMAgent.Remove)
+ [Esecuzione delle attività di database con Management Agent](#Oracle.Options.OEMAgent.DBTasks)
## Requisiti per Management Agent
Di seguito sono riportati i requisiti generali per l’utilizzo di Management Agent:
+ L’istanza database deve eseguire Oracle Database 19c (19.0.0.0). È possibile utilizzare l’architettura CDB o non CDB.
+ È necessario utilizzare un Oracle Management Service (OMS) configurato per effettuare la connessione all’istanza database. Tieni presenti i seguenti requisiti di OMS:
+ Le versioni 13.5.0.0.v2 e 13.5.0.0.v3 di Management Agent richiedono OMS versione 13.5.0.23 o 24.1.
+ La versione 13.5.0.0.v1 di Management Agent richiede OMS versione 13.5.0.0 o 24.1.
+ Le versioni 13.4.0.9.v1 e 13.4.0.9.v2 di Management Agent richiedono OMS versione 13.4.0.9 o successiva e la patch 32198287.
+ Nella maggior parte dei casi, è necessario configurare il VPC per permettere le connessioni dal tuo OMS all'istanza database. Se non hai familiarità con Amazon Virtual Private Cloud (Amazon VPC), completa le fasi in [Tutorial: crea un VPC da utilizzare con un ) IPv4](CHAP_Tutorials.WebServerDB.CreateVPC.md) prima di continuare.
+ È possibile utilizzare Management Agent con Oracle Enterprise Manager Cloud Control per 12c e 13c. Assicurati di disporre di spazio di storage sufficiente per la release OEM:
+ Almeno 8,5 GiB per OEM 13c Release 5
+ Almeno 8,5 GiB per OEM 13c Release 4
+ Almeno 8,5 GiB per OEM 13c Release 3
+ Almeno 5,5 GiB per OEM 13c Release 2
+ Almeno 4,5 GiB per OEM 13c Release 1
+ Almeno 2,5 GiB per OEM 12c
+ Se stai utilizzando le versioni `OEM_AGENT 13.2.0.0.v3` e `13.3.0.0.v2` di Management Agent e desideri utilizzare la connettività TCPS, segui le istruzioni riportate in [Configuring third party CA certificates for communication with target databases](https://docs.oracle.com/cd/E73210_01/EMSEC/GUID-8337AD48-1A32-4CD5-84F3-256FAE93D043.htm#EMSEC15996) nella documentazione Oracle. Inoltre, aggiorna JDK su OMS seguendo le istruzioni indicate nel documento Oracle contrassegnato dal numero identificativo 2241358.1. Quest’operazione consente a OMS di supportare tutte le suite di cifratura supportate dal database.
**Nota**
La connettività TCPS tra il Management Agent e l'istanza database è supportata solo per Management Agent `OEM_AGENT 13.2.0.0.v3`, `13.3.0.0.v2`, `13.4.0.9.v1` e versioni successive.
## Prerequisiti di comunicazione host OMS
Assicurati che il tuo host OMS e l’istanza database Amazon RDS possano comunicare. Esegui questa operazione:
+ Per effettuare la connessione da Management Agent al tuo host OMS, quando l’host OMS è protetto da un firewall, aggiungi gli indirizzi IP delle istanze database al firewall. Assicurati che il firewall per l’OMS consenta il seguente traffico di rete:
Dall’host OMS all’istanza database
Configura una regola del firewall unidirezionale che consenta il traffico dall’host OMS alla porta del listener del database (per impostazione predefinita, la 1521) e la porta di OEM Agent (per impostazione predefinita, la 3872).
Dall’istanza database all’host OMS
Configura una regola del firewall unidirezionale che consenta il traffico dall’istanza database alla porta HTTP di OMS (per impostazione predefinita, la 4903).
+ Per effettuare la connessione dall'OMS al Management Agent, se l'OMS ha un nome host risolvibile pubblicamente, aggiungi l'indirizzo dell'OMS a un gruppo di sicurezza. Il gruppo di sicurezza deve avere regole in entrata che permettono l'accesso alla porta del listener di database e a quella del Management Agent. Per un esempio su come creare un gruppo di sicurezza e aggiungere regole in entrata, consulta [Tutorial: crea un VPC da utilizzare con un ) IPv4](CHAP_Tutorials.WebServerDB.CreateVPC.md).
+ Per effettuare la connessione dall'OMS al Management Agent, se l'OMS non ha un nome host risolvibile pubblicamente, utilizza uno dei seguenti:
+ Se OMS si trova in un'istanza Amazon Elastic Compute Cloud (Amazon EC2) in un VPC privato, è possibile configurare il peering VPC per effettuare la connessione da OMS a Management Agent. Per ulteriori informazioni, consulta [Un'istanza database in un VPC a cui accede un'istanza EC2 in un VPC diverso](USER_VPC.Scenarios.md#USER_VPC.Scenario3).
+ Se l'OMS è ospitato in locale, è possibile configurare una connessione VPN per permettere l'accesso dall'OMS al Management Agent. Per ulteriori informazioni, consulta l'articolo relativo a [Un'istanza database in un VPC a cui accede un'applicazione client tramite Internet](USER_VPC.Scenarios.md#USER_VPC.Scenario4) o alle [connessioni VPN](https://docs.aws.amazon.com/vpc/latest/userguide/vpn-connections.html).
+ Per connettere OEM Management Agent versione 13.5.0.0 (v1-v3) a un host OMS 24.1, imposta `MINIMUM_TLS_VERSION` per l’utilizzo del protocollo `TLSv1.2` nelle opzioni di configurazione.
## Limitazioni per Management Agent
Di seguito sono riportate alcune delle limitazioni all’utilizzo di Management Agent:
+ Non è possibile fornire immagini personalizzate di Oracle Management Agent.
+ Le attività amministrative come l'esecuzione dei processi e l'applicazione di patch ai database, che richiedono credenziali host, non sono supportate.
+ Non è garantito che i parametri host e l'elenco di processi riflettano lo stato reale del sistema. Pertanto, non è consigliabile utilizzare OEM per monitorare il file system radice o il file system del punto di montaggio. Per ulteriori informazioni sul monitoraggio del sistema operativo, vedere [Monitoraggio dei parametri del sistema operativo con il monitoraggio avanzato](USER_Monitoring.OS.md).
+ L'individuazione automatica non è supportata. È necessario aggiungere manualmente le destinazioni dei database.
+ La disponibilità dei moduli OMS dipende dall'edizione del database. Ad esempio, la diagnosi delle prestazioni del database e il modulo di ottimizzazione sono disponibili solo per Oracle Database Enterprise Edition.
+ Management Agent consuma memoria e risorse di calcolo ulteriori. Se hai problemi di prestazioni dopo aver abilitato l'opzione `OEM_AGENT`, ti consigliamo di aumentare a una classe di istanza database più ampia. Per ulteriori informazioni, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md) e [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ L'utente che esegue il comando `OEM_AGENT` sull’host Amazon RDS non dispone dell'accesso al sistema operativo al log di avvisi. Pertanto, non è possibile raccogliere parametri per `DB Alert Log` e `DB Alert Log Error Status` in OEM.
## Impostazioni dell'opzione per Management Agent
Amazon RDS supporta le seguenti impostazioni per l'opzione Management Agent.
| Impostazione opzioni | Campo obbligatorio | Valori validi | Descrizione |
| --- | --- | --- | --- |
| **Version** (`AGENT_VERSION`) | Sì | `13.5.0.0.v3` `13.5.0.0.v2` `13.5.0.0.v1` `13.4.0.9.v2` `13.4.0.9.v1` `13.3.0.0.v2` `13.3.0.0.v1` `13.2.0.0.v3` `13.2.0.0.v2` `13.2.0.0.v1` `13.1.0.0.v1` | La versione del software Management Agent. La versione minima supportata è la `13.1.0.0.v1`. Il nome dell' AWS CLI opzione è`OptionVersion`. Nelle AWS GovCloud (US) regioni, le versioni 13.1 non sono disponibili. |
| **Porta** (`AGENT_PORT`) | Sì | Un valore intero. | La porta dell'istanza database in ascolto dell'host OMS. Il valore predefinito è 3872. L'host OMS deve appartenere a un gruppo di sicurezza che ha accesso a questa porta. Il nome dell' AWS CLI opzione è`Port`. |
| **Gruppi di sicurezza** | Sì | Gruppi di sicurezza esistenti | Un gruppo di sicurezza che ha accesso a **Port (Porta)**. L'host OMS deve appartenere a questo gruppo di sicurezza. Il nome dell' AWS CLI opzione è `VpcSecurityGroupMemberships` o`DBSecurityGroupMemberships`. |
| **OMS\$1HOST** | Sì | Un valore di stringa, ad esempio *my.example.oms* | Il nome host accessibile pubblicamente o l'indirizzo IP dell'OMS. Il nome dell' AWS CLI opzione è`OMS_HOST`. |
| **OMS\$1PORT** | Sì | Un valore intero. | La porta di caricamento HTTPS sull'host OMS che è in ascolto del Management Agent. Per determinare la porta di caricamento HTTPS, effettuare la connessione all'host OMS ed eseguire il seguente comando (che richiede la password di `SYSMAN`): emctl status oms -details Il nome dell' AWS CLI opzione è`OMS_PORT`. |
| **AGENT\$1REGISTRATION\$1PASSWORD** | Sì | Un valore di stringa. | La password utilizzata dal Management Agent per effettuare l'autenticazione con l'OMS. Consigliamo di creare una password persistente sull'OMS prima di abilitare l'opzione `OEM_AGENT`. Con una password persistente, è possibile condividere un singolo gruppo di opzioni di Management Agent con più database Amazon RDS. Il nome dell' AWS CLI opzione è`AGENT_REGISTRATION_PASSWORD`. |
| **ALLOW\$1TLS\$1ONLY** | No | `true`, `false` (default) | Un valore che configura l'agente OEM per supportare solo il protocollo `TLSv1` mentre l'agente è in ascolto come un server. Questa impostazione non è più supportata. Le versioni 13.1.0.0.v1 e successive di Management Agent supportano la tecnologia Transport Layer Security (TLS) per impostazione predefinita. |
| **MINIMUM\$1TLS\$1VERSION** | No | `TLSv1` (default), `TLSv1.2` | Una valore che specifica la versione TLS minima supportata dall'agente OEM mentre l'agente è in ascolto come un server. Per le versioni dell’agente non supportate, è consentita solo l’impostazione `TLSv1`. Per connettere 13.5.0.0 (v1-v3) a un host OMS 24.1, imposta questa opzione su `TLSv1.2`. |
| **TLS\$1CIPHER\$1SUITE** | No | Per informazioni, consulta [Impostazioni dell'opzione per Management Agent](#Oracle.Options.OEMAgent.Options). | Un valore che specifica la suite di cifratura TLS utilizzata dall'agente OEM mentre l'agente è in ascolto come un server. |
La tabella seguente elenca le suite di crittografia TLS supportate dall'opzione Management Agent.
| Suite di cifratura | Versione Agent supportata | Conformità agli standard FedRAMP |
| --- | --- | --- |
| TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | Tutti | No |
| TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1 SHA256 | 13.1.0.0.v1 e versioni successive | No |
| TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 13.2.0.0.v3 e versioni successive | No |
| TLS\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 | 13.2.0.0.v3 e versioni successive | No |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 13.2.0.0.v3 e versioni successive | Sì |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 13.2.0.0.v3 e versioni successive | Sì |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 | 13.2.0.0.v3 e versioni successive | Sì |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | 13.2.0.0.v3 e versioni successive | Sì |
| TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 | 13.4.0.9.v1 e versioni successive | Sì |
| TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | 13.4.0.9.v1 e versioni successive | Sì |
### Compatibilità dei certificati con le suite di crittografia
RDS per Oracle supporta i certificati RSA ed Elliptic Curve Digital Signature Algorithm (ECDSA). Quando configuri l’opzione OEM Agent per l’istanza database, devi assicurarti che le suite di crittografia specificate nell’impostazione dell’opzione `TLS_CIPHER_SUITE` siano compatibili con il tipo di certificato utilizzato dall’istanza database.
Nella tabella seguente è illustrata la compatibilità tra i tipi di certificato e le suite di crittografia:
| Tipo di certificato | Suite di crittografia compatibili | Suite di crittografia incompatibili |
| --- | --- | --- |
| Certificati RSA (rds-ca-2019, 2048-g1, 4096-g1) rds-ca-rsa rds-ca-rsa | TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 |
| Certificati ECDSA (384-g1) rds-ca-ecc | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | TLS\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 |
Quando specifichi una suite di crittografia nell’impostazione dell’opzione `TLS_CIPHER_SUITE`, assicurati che sia compatibile con il tipo di certificato utilizzato dall’istanza database. Se tenti di associare un gruppo di opzioni a un’opzione OEM Agent che contiene una suite di crittografia incompatibile con il tipo di certificato di un’istanza database, l’operazione avrà esito negativo e verrà visualizzato un messaggio di errore per segnalare l’incompatibilità.
## Abilitazione dell’opzione Management Agent per l’istanza database
Per abilitare l’opzione Management Agent, utilizza la procedura seguente:
**Topics**
+ [Fase 1: aggiungere l’opzione Management Agent a un’istanza database](#Oracle.Options.OEMAgent.Add)
+ [Fase 2: sbloccare l’account utente DBSNMP](#Oracle.Options.OEMAgent.DBSNMP)
+ [Fase 3: aggiungere le destinazioni alla console di Management Agent](#Oracle.Options.OEMAgent.Using)
### Fase 1: aggiungere l’opzione Management Agent a un’istanza database
Per aggiungere l’opzione Management Agent all’istanza database, procedi nel seguente modo:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Se riscontri errori, puoi consultare i documenti di [My Oracle Support](https://support.oracle.com/) per informazioni sulla risoluzione di problemi specifici.
Dopo aver aggiunto l'opzione Management Agent, non è necessario riavviare l'istanza database. Non appena il gruppo di opzioni è attivo, è attivo anche l'agente OEM.
Se l'host OMS utilizza un certificato di terze parti non attendibile, Amazon RDS restituisce il seguente errore.
```
You successfully installed the OEM_AGENT option. Your OMS host is using an untrusted third party certificate.
Configure your OMS host with the trusted certificates from your third party.
```
Se viene restituito questo errore, l'opzione Management Agent non è abilitata finché il problema non viene corretto. Per informazioni sulla correzione del problema, consulta il documento di supporto My Oracle [2202569.1](https://support.oracle.com/epmos/faces/DocContentDisplay?id=2202569.1).
#### Console
**Per aggiungere l’opzione Management Agent all’istanza database**
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine (Motore)** scegliere l'edizione Oracle per l'istanza database.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **OEM\$1AGENT (OEM\$1AGENT)** al gruppo di opzioni e configurare le impostazioni di opzione. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell'opzione per Management Agent](#Oracle.Options.OEMAgent.Options).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
#### AWS CLI
[L'esempio seguente utilizza il comando -group per aggiungere l'opzione a un gruppo di opzioni chiamato. AWS CLI add-option-to-option](https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html) `OEM_AGENT` `myoptiongroup`
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options OptionName=OEM_AGENT,OptionVersion=13.1.0.0.v1,Port=3872,VpcSecurityGroupMemberships=sg-1234567890,OptionSettings=[{Name=OMS_HOST,Value=my.example.oms},{Name=OMS_PORT,Value=4903},{Name=AGENT_REGISTRATION_PASSWORD,Value=password}] \
--apply-immediately
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options OptionName=OEM_AGENT,OptionVersion=13.1.0.0.v1,Port=3872,VpcSecurityGroupMemberships=sg-1234567890,OptionSettings=[{Name=OMS_HOST,Value=my.example.oms},{Name=OMS_PORT,Value=4903},{Name=AGENT_REGISTRATION_PASSWORD,Value=password}] ^
--apply-immediately
```
### Fase 2: sbloccare l’account utente DBSNMP
Management Agent utilizza l’account utente `DBSNMP` per connettersi al database e segnalare i problemi a Oracle Enterprise Manager. In un CDB, `DBSNMP` è un utente comune. Questo account utente è necessario sia per Management Agent sia per OEM Database Express. Per impostazione predefinita, questo account è bloccato. La procedura per sbloccare questo account varia a seconda che il database utilizzi l’architettura non CDB o CDB.
**Per sbloccare l’account utente DBSNMP**
1. In SQL\$1Plus o in un’altra applicazione Oracle SQL, accedi come utente master all’istanza database.
1. A seconda dell’architettura del database, effettua una delle seguenti azioni:
**Il database è un database non CDB.**
Esegui la seguente istruzione SQL:
```
1. ALTER USER dbsnmp IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**Il database è un CDB.**
Esegui la seguente stored procedure per sbloccare l’account `DBSNMP`:
```
1. EXEC rdsadmin.rdsadmin_util.reset_oem_agent_password('new_password');
```
Se viene visualizzato un errore per segnalare che la procedura non esiste, riavvia l’istanza CDB per installarla automaticamente. Per ulteriori informazioni, consulta [Riavvio di un'istanza DB DB](USER_RebootInstance.md).
### Fase 3: aggiungere le destinazioni alla console di Management Agent
Per aggiungere un’istanza database come destinazione, assicurati di conoscere l’endpoint e la porta. Per informazioni su come trovare l’endpoint per l’istanza database Amazon RDS, consulta [Esito dell'endpoint dell'istanza database RDS per Oracle](USER_Endpoint.md). Se il database utilizza l’architettura CDB, aggiungi il container `CDB$ROOT` separatamente come destinazione.
**Per aggiungere le destinazioni alla console di Management Agent**
1. Nella console OMS, selezionare **Setup (Configurazione)**, **Add Target (Aggiungi destinazione)**, **Add Targets Manually (Aggiungi manualmente destinazioni)**.
1. Scegliere **Add Targets Declaratively by Specifying Target Monitoring Properties (Aggiungi destinazioni in modo dichiarativo specificando le proprietà di monitoraggio della destinazione)**.
1. Per **Target Type (Tipo di destinazione)**, scegliere **Database Instance (Istanza database)**.
1. Per **Monitoring Agent (Agente di monitoraggio)** scegliere l'agente con l'ID uguale all'identificatore istanze DB di RDS.
1. Scegliere **Add Manually (Aggiungi manualmente)**.
1. Inserire l’endpoint per l’istanza database Amazon RDS o selezionarlo dall’elenco di nomi host. Verificare che il nome dell'host specificato corrisponda all'endpoint dell'istanza database Amazon RDS.
1. Specificare le seguenti proprietà del database:
+ Immettere un nome in **Target Name (Nome destinazione)**.
+ Immettere un nome in **Database system name (Nome del sistema di database)**.
+ Immettere **dbsnmp** in **Monitor username (Nome utente monitoraggio)**.
+ In **Password monitoraggio**, immettere la password da [Fase 2: sbloccare l’account utente DBSNMP](#Oracle.Options.OEMAgent.DBSNMP).
+ In **Role (Ruolo)** immettere **normal (normale)**.
+ In **Oracle home path (Percorso home di Oracle)** immettere **/oracle**.
+ Per **Listener Machine name (Nome macchina listener)**, viene già visualizzato l'identificatore dell'agente.
+ In **Port (Porta)** immettere la porta del database. La porta RDS predefinita è 1521.
+ In **Database name (Nome del database)** immettere il nome del database. Se il database è un CDB, il nome è `RDSCDB`.
1. Scegliere **Test Connection (Connessione di prova)**.
1. Scegli **Next (Successivo)**. Il database di destinazione viene visualizzato nell'elenco di risorse monitorate.
## Rimozione dell'opzione Management Agent
È possibile rimuovere l'OEM Agent dall'istanza database. Dopo aver rimosso l'opzione OEM Agent, non è necessario riavviare la tua istanza database.
Per rimuovere l'OEM Agent dall'istanza database, procedere in uno dei seguenti modi:
+ Rimuovere l'opzione OEM Agent dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione OEM Agent. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Esecuzione delle attività di database con Management Agent
Puoi utilizzare le procedure Amazon RDS per eseguire alcuni comandi EMCTL in Management Agent. Con queste procedure, puoi eseguire le attività elencate di seguito.
**Nota**
Le attività vengono eseguite in modo asincrono.
**Topics**
+ [Protezione di Management Agent](#Oracle.Options.OEMAgent.DBTasks.SecureAgent)
+ [Ottenere lo stato del Management Agent](#Oracle.Options.OEMAgent.DBTasks.GetAgentStatus)
+ [Riavvio di Management Agent](#Oracle.Options.OEMAgent.DBTasks.RestartAgent)
+ [Elenco delle destinazioni monitorate da Management Agent](#Oracle.Options.OEMAgent.DBTasks.ListTargets)
+ [Elenco dei thread di raccolta monitorati da Management Agent](#Oracle.Options.OEMAgent.DBTasks.ListCollectionThreads)
+ [Cancellazione dello stato di Management Agent](#Oracle.Options.OEMAgent.DBTasks.ClearState)
+ [Configurazione di Management Agent per il caricamento automatico del proprio OMS](#Oracle.Options.OEMAgent.DBTasks.ForceUploadOMS)
+ [Ping dell'OMS](#Oracle.Options.OEMAgent.DBTasks.PingOMS)
+ [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus)
### Protezione di Management Agent
Per proteggere Management Agent, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.secure_oem_agent`. Questa procedura equivale al comando `emctl secure agent`.
La procedura seguente crea un’attività per proteggere Management Agent e restituisce l’ID dell’attività:
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.secure_oem_agent as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Ottenere lo stato del Management Agent
Per ottenere lo stato del Management Agent, eseguire la Amazon RDS procedura `rdsadmin.rdsadmin_oem_agent_tasks.get_status_oem_agent`. Questa procedura equivale al comando `emctl status agent`.
La procedura seguente crea un'attività per ottenere lo stato del Management Agent e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.get_status_oem_agent() as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Riavvio di Management Agent
Per riavviare Management Agent, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.restart_oem_agent`. Questa procedura equivale ai comandi `emctl stop agent` e `emctl start agent`.
La procedura seguente crea un'attività per riavviare Management Agent e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.restart_oem_agent as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Elenco delle destinazioni monitorate da Management Agent
Per elencare le destinazioni monitorate da Management Agent, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.list_targets_oem_agent`. Questa procedura equivale al comando `emctl config agent listtargets`.
La procedura seguente crea un'attività per elencare le destinazioni monitorate dal Management Agent e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.list_targets_oem_agent as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Elenco dei thread di raccolta monitorati da Management Agent
Per elencare tutti i thread di raccolta in esecuzione, pronti e pianificati monitorati dal Management Agent, esegui la procedura Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.list_clxn_threads_oem_agent`. Questa procedura equivale al comando `emctl status agent scheduler`.
La procedura seguente crea un'attività per elencare i thread di raccolta e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.list_clxn_threads_oem_agent() as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Cancellazione dello stato di Management Agent
Per cancellare lo stato di Management Agent, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.clearstate_oem_agent`. Questa procedura equivale al comando `emctl clearstate agent`.
La procedura seguente crea un'attività che cancella lo stato del Management Agent e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.clearstate_oem_agent() as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Configurazione di Management Agent per il caricamento automatico del proprio OMS
Per configurare Management Agent in modo che carichi Oracle Management Server (OMS) a cui è associato, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.upload_oem_agent`. Questa procedura equivale al comando `emclt upload agent`.
Nella procedura seguente viene creata un'attività in cui Management Agent carica l'OMS associato e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.upload_oem_agent() as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Ping dell'OMS
Per eseguire il ping dell'OMS di Management Agent, esegui la procedura di Amazon RDS `rdsadmin.rdsadmin_oem_agent_tasks.ping_oms_oem_agent`. Questa procedura equivale al comando `emctl pingOMS`.
Nella procedura seguente viene creata un'attività che esegue il ping dell'OMS del Management Agent e restituisce l'ID dell'attività.
```
SELECT rdsadmin.rdsadmin_oem_agent_tasks.ping_oms_oem_agent() as TASK_ID from DUAL;
```
Per visualizzare il file di output dell’attività ed esaminare il risultato, consulta [Visualizzazione dello stato di un'attività in corso](#Oracle.Options.OEMAgent.DBTasks.ViewTaskStatus).
### Visualizzazione dello stato di un'attività in corso
È possibile visualizzare lo stato di un'attività in corso in un file bdump. I file bdump si trovano nella directory `/rdsdbdata/log/trace`. Il nome del file bdump ha il formato che segue.
```
dbtask-task-id.log
```
Per monitorare un'attività, sostituisci `task-id` con l'ID di tale attività.
Per visualizzare i contenuti dei file bdump, esegui la procedura di Amazon RDS `rdsadmin.rds_file_util.read_text_file`. La query seguente restituisce i contenuti del file bdump `dbtask-1546988886389-2444.log`.
```
SELECT text FROM table(rdsadmin.rds_file_util.read_text_file('BDUMP','dbtask-1546988886389-2444.log'));
```
Per ulteriori informazioni sulla procedura `rdsadmin.rds_file_util.read_text_file` di Amazon RDS, consulta [Lettura dei file in una directory di istanze database](Appendix.Oracle.CommonDBATasks.Misc.md#Appendix.Oracle.CommonDBATasks.ReadingFiles).
# Oracle Label Security
Amazon RDS supporta Oracle Label Security per la Enterprise Edition di Oracle Database tramite l'uso dell'opzione OLS.
La maggior parte della sicurezza del database controlla l'accesso a livello dell'oggetto. Oracle Label Security fornisce un controllo preciso dell'accesso alle singole righe della tabella. Ad esempio, è possibile usare Label Security per applicare la conformità alle normative con un modello di amministrazione basato sulla policy. È possibile usare le policy di Label Security per controllare l'accesso a dati sensibili e l'acceso limitato solo agli utenti con il livello adeguato di autorizzazioni. Per altre informazioni, consulta l'articolo relativo a [Introduzione a Oracle Label Security](https://docs.oracle.com/database/121/OLSAG/intro.htm#OLSAG001) nella documentazione Oracle.
**Topics**
+ [Requisiti per Oracle Label Security](#Oracle.Options.OLS.PreReqs)
+ [Considerazioni su quando utilizzare Oracle Label Security](#Oracle.Options.OLS.Using)
+ [Aggiunta dell'opzione Oracle Label Security](#Oracle.Options.OLS.Add)
+ [Risoluzione dei problemi](#Oracle.Options.OLS.Troubleshooting)
## Requisiti per Oracle Label Security
Acquisisci familiarità con i seguenti requisiti per Oracle Label Security:
+ L'istanza database deve usare il modello Bring Your Own License (uso di licenze proprie). Per ulteriori informazioni, consulta [Opzioni di licenza per RDS per Oracle](Oracle.Concepts.Licensing.md).
+ È necessario disporre di una licenza valida per Oracle Enterprise Edition con Licenza di aggiornamento software e supporto.
+ La licenza Oracle deve comprendere l'opzione Label Security.
## Considerazioni su quando utilizzare Oracle Label Security
Per usare Oracle Label Security, è possibile creare policy che controllino l'accesso a righe specifiche nelle tabelle. Per altre informazioni, consulta l'articolo relativo a [Creazione di una policy di Oracle Label Security](https://docs.oracle.com/database/121/OLSAG/getstrtd.htm#OLSAG3096) nella documentazione Oracle.
Considera i seguenti aspetti:
+ Oracle Label Security è un'opzione permanente e persistente. Pertanto, non puoi rimuovere l'opzione da un gruppo di opzioni. Se aggiungi Oracle Label Security a un gruppo di opzioni e lo associ all'istanza database, è possibile in seguito associare un gruppo di opzioni diverso all'istanza database, ma anche questo gruppo deve contenere l'opzione Oracle Label Security.
+ Quando utilizzi Label Security, esegui tutte le azioni come ruolo `LBAC_DBA`. All’utente master per l’istanza database viene concesso il ruolo `LBAC_DBA`. È possibile concedere il ruolo `LBAC_DBA` ad altri utenti in modo che possano amministrare le policy di Label Security.
+ Assicurati di concedere l’accesso al pacchetto `OLS_ENFORCEMENT` per tutti i nuovi utenti che richiedono l’accesso a Oracle Label Security. Per concedere l'accesso al pacchetto `OLS_ENFORCEMENT`, connettiti all'istanza database come utente master ed esegui l'istruzione SQL:
```
GRANT ALL ON LBACSYS.OLS_ENFORCEMENT TO username;
```
+ Puoi configurare Label Security tramite Oracle Enterprise Manager (OEM) Cloud Control. Amazon RDS supporta OEM Cloud Control tramite l’opzione Management Agent. Per ulteriori informazioni, consulta [Oracle Management Agent per Enterprise Manager Cloud Control](Oracle.Options.OEMAgent.md).
## Aggiunta dell'opzione Oracle Label Security
La procedura generale per aggiungere l'opzione Label Security a un'istanza database è la seguente:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
**Importante**
Oracle Label Security è un'opzione permanente e persistente.
1. Associare il gruppo di opzioni a questa istanza database.
Una volta aggiunta l'opzione Label Security, non appena il gruppo di opzioni sarà attivo, anche Label Security sarà attiva.
**Per aggiungere l'opzione Label Security a un'istanza database**
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. In **Engine (Motore)** scegliere **oracle-ee**.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **OLS** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
**Importante**
Se aggiungi Label Security a un gruppo di opzioni esistente che è già associato a una o più istanze database, tutte le istanze database vengono riavviate.
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Quando aggiungi l'opzione Label Security a un'istanza database esistente, si verifica una breve interruzione mentre l'istanza database viene automaticamente riavviata. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Risoluzione dei problemi
Di seguito sono elencati i problemi che si potrebbero riscontrare quando si usa Oracle Label Security.
****
| Problema | Suggerimenti sulla risoluzione dei problemi |
| --- | --- |
| Quando cerchi di creare una policy, comparirà un messaggio di errore simile al seguente: `insufficient authorization for the SYSDBA package`. | Un problema noto con la funzionalità Oracle Label Security impedisce agli utenti con nomi utente di 16 o 24 caratteri di eseguire i comandi di Label Security. È possibile creare un nuovo utente con un numero diverso di caratteri, garantire LBAC\$1DBA al nuovo utente, accedere come nuovo utente ed eseguire i comandi OLS come nuovo utente. Per altre informazioni, contatta il supporto Oracle. |
# Oracle Locator
Amazon RDS supporta Oracle Locator tramite l'utilizzo dell'opzione `LOCATOR`. Oracle Locator offre funzionalità che sono solitamente richieste per il supporto di applicazioni Internet e wireless basate su servizi e di soluzioni GIS basate su partner. Oracle Locator è un sottoinsieme limitato di Oracle Spatial. Per ulteriori informazioni, consulta [Oracle Locator](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#SPATL340) nella documentazione di Oracle.
**Importante**
Se utilizzi Oracle Locator, Amazon RDS aggiorna automaticamente la tua istanza database alla versione più recente di Oracle PSU, nel casi vi siano vulnerabilità della sicurezza con un punteggio del Common Vulnerability Scoring System (CVSS) di 9\$1 o altre vulnerabilità della sicurezza annunciate.
## Versioni di database supportate per Oracle Locator
RDS per Oracle supporta Oracle Locator per Oracle Database 19c. Oracle Locator non è supportato per Oracle Database 21c, ma la sua funzionalità è disponibile nell'opzione Oracle Spatial. In precedenza, l'opzione Spatial richiedeva licenze aggiuntive. Oracle Locator rappresentava un sottoinsieme di funzionalità Oracle Spatial e non richiedeva licenze aggiuntive. Nel 2019, Oracle ha annunciato che tutte le funzionalità di Oracle Spatial sono state incluse nelle licenze Enterprise Edition e Standard Edition 2 senza costi aggiuntivi. Di conseguenza, l'opzione Oracle Spatial non richiedeva più licenze aggiuntive. Per ulteriori informazioni, consulta [Machine Learning, Spatial e Graph - Nessuna licenza richiesta\$1](https://blogs.oracle.com/database/post/machine-learning-spatial-and-graph-no-license-required) nel blog Oracle Database Insider.
## Prerequisiti per Oracle Locator
Di seguito sono indicati i prerequisiti per l'utilizzo di Oracle Locator:
+ L'istanza database deve appartenere a una classe sufficiente. Oracle Locator non è supportato per le classi di istanza database db.t3.small. Per ulteriori informazioni, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
+ L'istanza database deve avere l'opzione **Auto Minor Version Upgrade (Aggiornamento minore automatico della versione)** abilitata. Questa opzione consente all'istanza database di ricevere automaticamente gli aggiornamenti secondari della versione del motore del database quando vengono resi disponibili ed è obbligatoria per tutte le opzioni che installano la Java Virtual Machine (JVM) Oracle. Amazon RDS utilizza questa opzione per aggiornare l'istanza database all'ultimo PSU (Patch Set Update) o RU (Release Update) di Oracle. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Best Practice per Oracle Locator
Di seguito sono indicate le best practice per l'utilizzo di Oracle Locator:
+ Per la massima sicurezza, è necessario utilizzare l'opzione `LOCATOR` con Secure Sockets Layer (SSL). Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
+ Configurare l'istanza database per limitare l'accesso all'istanza database. Per ulteriori informazioni, consulta [Scenari per accedere a un'istanza database in un VPC](USER_VPC.Scenarios.md) e [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
## Aggiunta dell'opzione Oracle Locator
Di seguito è riportato il processo generale per aggiungere l'opzione `LOCATOR` a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Se Oracle Java Virtual Machine *non* è installato nell'istanza database, durante l'aggiunta dell'opzione `LOCATOR` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta aggiunta l'opzione, non è necessario riavviare l'istanza database. Non appena il gruppo di opzioni è attivo, Oracle Locator è disponibile.
**Nota**
Durante questa interruzione, le funzioni di verifica delle password vengono temporaneamente disabilitate. Durante l'interruzione si possono verificare eventi correlati alle funzioni di verifica delle password. Le funzioni di verifica delle password vengono riabilitate prima di rendere disponibile l'istanza database Oracle.
**Per aggiungere l'opzione `LOCATOR` a un'istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. In **Engine (Motore)** selezionare l'edizione Oracle per l'istanza database.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **LOCATOR** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Utilizzo di Oracle Locator
L'opzione Oracle Locator può essere utilizzata immediatamente dopo l'abilitazione. Utilizza solo le caratteristiche di Oracle Locator. Non usare le caratteristiche di Oracle Spatial se non disponi di un'apposita licenza.
Per un elenco delle caratteristiche supportate da Oracle Locator, consulta [Features Included with Locator](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#GUID-EC6DEA23-8FD7-4109-A0C1-93C0CE3D6FF2__CFACCEEG) nella documentazione di Oracle.
Per un elenco delle caratteristiche non supportate da Oracle Locator, consulta [Features Not Included with Locator](https://docs.oracle.com/database/121/SPATL/sdo_locator.htm#GUID-EC6DEA23-8FD7-4109-A0C1-93C0CE3D6FF2__CFABACEA) nella documentazione di Oracle.
## Rimozione dell'opzione Oracle Locator
Dopo aver eliminato tutti gli oggetti che utilizzano i tipi di dati forniti dall'opzione `LOCATOR`, è possibile rimuovere l'opzione da un'istanza DB. Se Oracle Java Virtual Machine *non* è installata nell'istanza database, durante la rimozione dell'opzione `LOCATOR` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta rimossa l'opzione `LOCATOR` non è necessario riavviare la tua istanza database.
**Per eliminare l'opzione `LOCATOR`**
1. Eseguire il backup dei dati.
**avvertimento**
Se l'istanza utilizza tipi di dati abilitati come parte dell'opzione e se si rimuove l'opzione `LOCATOR`, è possibile perdere i dati. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
1. Verificare se gli oggetti esistenti fanno riferimento ai tipi di dati o alle feature dell'opzione `LOCATOR`.
Se esistono opzioni `LOCATOR`, l'istanza può rimanere bloccata quando si applica il nuovo gruppo di opzioni che non dispone dell'opzione `LOCATOR`. È possibile identificare gli oggetti utilizzando le seguenti query:
```
SELECT OWNER, SEGMENT_NAME, TABLESPACE_NAME, BYTES/1024/1024 mbytes
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE '%TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT DISTINCT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE='SDO_GEOMETRY'
AND OWNER <> 'MDSYS')
ORDER BY 1,2,3,4;
SELECT OWNER, TABLE_NAME, COLUMN_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE = 'SDO_GEOMETRY'
AND OWNER <> 'MDSYS'
ORDER BY 1,2,3;
```
1. Eliminare gli oggetti che fanno riferimento ai tipi di dati o alle feature dell'opzione `LOCATOR`.
1. Scegliere una delle seguenti operazioni:
+ Rimuovere l'opzione `LOCATOR` dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione `LOCATOR`. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle native network encryption
Amazon RDS supporta Native Network Encryption (NNE) di Oracle. Con l’opzione `NATIVE_NETWORK_ENCRYPTION`, puoi crittografare i dati quando vengono spostati da e verso un’istanza database. Amazon RDS supporta NNE per tutte le edizioni di Oracle Database.
Una descrizione dettagliata di NNE di Oracle non rientra nell'ambito di questa guida, ma è necessario conoscere i vantaggi e gli svantaggi di ogni algoritmo e chiave prima di scegliere una soluzione per la distribuzione. Per informazioni su algoritmi e chiavi disponibili mediante la crittografia di rete nativa di Oracle, consulta [Configuring Network Data Encryption](http://www.oracle.com/webfolder/technetwork/tutorials/obe/db/11g/r2/prod/security/network_encrypt/ntwrkencrypt.htm) nella documentazione di Oracle. Per ulteriori informazioni sulla sicurezza AWS, consulta il [Centro di Sicurezza AWS](https://aws.amazon.com/security).
**Nota**
Puoi utilizzare Secure Sockets Layer o Native Network Encryption, ma non entrambi. Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
**Topics**
+ [Impostazioni dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION](Oracle.Options.NNE.Options.md)
+ [Aggiunta dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION](Oracle.Options.NNE.Add.md)
+ [Impostazione dei valori NNE in sqlnet.ora](Oracle.Options.NNE.Using.md)
+ [Modifica delle impostazioni dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION](Oracle.Options.NNE.ModifySettings.md)
+ [Rimozione dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION](Oracle.Options.NNE.Remove.md)
# Impostazioni dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION
È possibile specificare i requisiti di crittografia sia sul server che sul client. L'istanza database può fungere da client quando, ad esempio, utilizza un database link per connettersi a un altro database. È possibile evitare di forzare la crittografia sul lato server. Ad esempio, è possibile che non si desideri forzare tutte le comunicazioni client a utilizzare la crittografia perché il server lo richiede. In questo caso, è possibile forzare la crittografia sul lato client utilizzando le opzioni `SQLNET.*CLIENT`.
Amazon RDS supporta le seguenti impostazioni per l’opzione `NATIVE_NETWORK_ENCRYPTION`.
**Nota**
Quando si utilizzano virgole per separare i valori per un'impostazione di opzione, non inserire uno spazio dopo la virgola.
****
| Impostazione opzioni | Valori validi | Valori predefiniti | Description |
| --- | --- | --- | --- |
| `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` | `TRUE`, `FALSE` | `TRUE` | Il comportamento del server quando un client che utilizza una crittografia non sicura tenta di connettersi al database. Se `TRUE`, i client possono connettersi anche se non sono stati sottoposti a patch con la PSU di luglio 2021. Se l'impostazione è `FALSE`, i client possono connettersi al database solo quando vengono sottoposti a patch con la PSU di luglio 2021. Prima di impostare `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS` su `FALSE`, assicurati che siano soddisfatte le seguenti condizioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) |
| `SQLNET.ALLOW_WEAK_CRYPTO` | `TRUE`, `FALSE` | `TRUE` | Il comportamento del server quando un client che utilizza una crittografia non sicura tenta di connettersi al database. Le seguenti crittografie sono considerate non sicure: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) Se l'impostazione è `TRUE`, i client possono connettersi quando utilizzano crittografie precedenti non sicure. Se l'impostazione è `FALSE`, il database impedisce ai client di connettersi quando utilizzano crittografie precedenti non sicure. Prima di impostare `SQLNET.ALLOW_WEAK_CRYPTO` su `FALSE`, assicurati che siano soddisfatte le seguenti condizioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) |
| `SQLNET.CRYPTO_CHECKSUM_CLIENT` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | Il comportamento dell'integrità dei dati quando un'istanza database si connette al client, oppure un server che agisce come client. Quando un'istanza database utilizza un collegamento di database, agisce come un client. `Requested` indica che il client non richiede che l'istanza database eseguire un checksum. |
| `SQLNET.CRYPTO_CHECKSUM_SERVER` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | Il comportamento dell'integrità dei dati quando un client, oppure un server che agisce come client, si connette all'istanza database. Quando un'istanza database utilizza un collegamento di database, agisce come un client. `Requested` indica che l'istanza database non richiede al client di eseguire un checksum. |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | `SHA256`, `SHA384`, `SHA512` | Un elenco di algoritmi di checksum. È possibile specificare un valore o un elenco di valori separato da virgole. Se si utilizza una virgola, non inserire uno spazio dopo la virgola, altrimenti verrà visualizzato un errore `InvalidParameterValue`. Questo parametro e `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER ` deve avere una crittografia comune. |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | Un elenco di algoritmi di checksum. È possibile specificare un valore o un elenco di valori separato da virgole. Se si utilizza una virgola, non inserire uno spazio dopo la virgola, altrimenti verrà visualizzato un errore `InvalidParameterValue`. Questo parametro e `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` deve avere una crittografia comune. |
| `SQLNET.ENCRYPTION_CLIENT` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | Il comportamento della crittografia del client quando un client, oppure un server che agisce come client, si connette all'istanza database. Quando un'istanza database utilizza un collegamento di database, agisce come un client. `Requested` indica che il client non richiede la crittografia del traffico dal server. |
| `SQLNET.ENCRYPTION_SERVER` | `Accepted`, `Rejected`, `Requested`, `Required` | `Requested` | Il comportamento della crittografia del server quando un client, oppure un server che agisce come client, si connette all'istanza database. Quando un'istanza database utilizza un collegamento di database, agisce come un client. `Requested` indica che l'istanza database non richiede la crittografia del traffico dal client. |
| `SQLNET.ENCRYPTION_TYPES_CLIENT` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | Un elenco degli algoritmi di crittografia utilizzati dal client. Il client tenta di decrittografare l'input del server eseguendo ciascun algoritmo in sequenza, fino alla corretta esecuzione di un algoritmo o fino alla fine dell'elenco. Amazon RDS utilizza il seguente elenco predefinito di Oracle. RDS inizia con `RC4_256` e procede in sequenza scorrendo l'elenco. Puoi cambiare l'ordine o limitare gli algoritmi che l'istanza database accetterà. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) È possibile specificare un valore o un elenco di valori separato da virgole. Se si utilizza una virgola, non inserire uno spazio dopo la virgola; in caso contrario, viene visualizzato un errore `InvalidParameterValue`. Questo parametro e `SQLNET.SQLNET.ENCRYPTION_TYPES_SERVER` deve avere una crittografia comune. |
| `SQLNET.ENCRYPTION_TYPES_SERVER` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | `RC4_256`, `AES256`, `AES192`, `3DES168`, `RC4_128`, `AES128`, `3DES112`, `RC4_56`, `DES`, `RC4_40`, `DES40` | Un elenco degli algoritmi di crittografia utilizzati dall'istanza database. L'istanza database utilizza ogni algoritmo, nell'ordine, per tentare di decrittografare l'input del client fino alla corretta esecuzione di un algoritmo o fino alla fine dell'elenco. Amazon RDS utilizza il seguente elenco predefinito di Oracle. Puoi cambiare l'ordine o limitare gli algoritmi che il client accetterà. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.NNE.Options.html) È possibile specificare un valore o un elenco di valori separato da virgole. Se si utilizza una virgola, non inserire uno spazio dopo la virgola; in caso contrario, viene visualizzato un errore `InvalidParameterValue`. Questo parametro e `SQLNET.SQLNET.ENCRYPTION_TYPES_SERVER` deve avere una crittografia comune. |
# Aggiunta dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION
Di seguito è riportata la procedura generale per aggiungere l’opzione `NATIVE_NETWORK_ENCRYPTION` a un’istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Quando il gruppo di opzioni è attivo, NNE è attiva.
**Per aggiungere l'opzione NATIVE\$1NETWORK\$1ENCRYPTION a un'istanza DB utilizzando Console di gestione AWS**
1. Per **Engine (Motore)**, scegliere l'edizione di Oracle da utilizzare. NNE è supportato in tutte le edizioni.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l’opzione **NATIVE\$1NETWORK\$1ENCRYPTION** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
**Nota**
Una volta aggiunta l’opzione **NATIVE\$1NETWORK\$1ENCRYPTION**, non è necessario riavviare le istanze database. Non appena il gruppo di opzioni è attivo, NNE è attiva.
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Una volta aggiunta l’opzione **NATIVE\$1NETWORK\$1ENCRYPTION**, non è necessario riavviare l’istanza database. Non appena il gruppo di opzioni è attivo, NNE è attiva. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Impostazione dei valori NNE in sqlnet.ora
Con crittografia di rete nativa di Oracle, puoi impostare la crittografia di rete sul lato server e sul lato client. Il client è il computer utilizzato per connettersi all'istanza database. È possibile specificare le seguenti impostazioni client in slqnet.ora:
+ `SQLNET.ALLOW_WEAK_CRYPTO`
+ `SQLNET.ALLOW_WEAK_CRYPTO_CLIENTS`
+ `SQLNET.CRYPTO_CHECKSUM_CLIENT`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT`
+ `SQLNET.ENCRYPTION_CLIENT`
+ `SQLNET.ENCRYPTION_TYPES_CLIENT`
Per informazioni, consulta [Configuring Network Data Encryption and Integrity for Oracle Servers and Clients](http://docs.oracle.com/cd/E11882_01/network.112/e40393/asoconfg.htm) nella documentazione di Oracle.
Talvolta, l'istanza database rifiuta una richiesta di connessione da un'applicazione. Ad esempio, un rifiuto può verificarsi quando gli algoritmi di crittografia sul client e sul server non corrispondono. Per testare crittografia di rete nativa di Oracle, aggiungi le seguenti righe al file sqlnet.ora sul client:
```
DIAG_ADR_ENABLED=off
TRACE_DIRECTORY_CLIENT=/tmp
TRACE_FILE_CLIENT=nettrace
TRACE_LEVEL_CLIENT=16
```
Quando si esegue un tentativo di connessione, le righe precedenti generano un file di traccia sul client denominato `/tmp/nettrace*`. Il file di traccia contiene informazioni sulla connessione. Per ulteriori informazioni sui problemi relativi alla connessione quando si utilizza NNE, consulta [About Negotiating Encryption and Integrity](http://docs.oracle.com/cd/E11882_01/network.112/e40393/asoconfg.htm#autoId12) nella documentazione di Oracle Database.
# Modifica delle impostazioni dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION
Dopo aver abilitato l'opzione `NATIVE_NETWORK_ENCRYPTION`, puoi modificarne le impostazioni. Attualmente, è possibile modificare le impostazioni delle `NATIVE_NETWORK_ENCRYPTION` opzioni solo con l'API AWS CLI o RDS. Non puoi utilizzare la console. L’esempio seguente modifica due impostazioni nell’opzione.
```
aws rds add-option-to-option-group \
--option-group-name my-option-group \
--options "OptionName=NATIVE_NETWORK_ENCRYPTION,OptionSettings=[{Name=SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER,Value=SHA256},{Name=SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER,Value=SHA256}]" \
--apply-immediately
```
Per informazioni su come modificare le impostazioni dell'opzione utilizzando la CLI, consulta [AWS CLI](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption.CLI). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION](Oracle.Options.NNE.Options.md).
**Topics**
+ [Modifica dei valori CRYPTO\$1CHECKSUM\$1\$1](#Oracle.Options.NNE.ModifySettings.checksum)
+ [Modifica delle impostazioni ALLOW\$1WEAK\$1CRYPTO\$1](#Oracle.Options.NNE.ModifySettings.encryption)
## Modifica dei valori CRYPTO\$1CHECKSUM\$1\$1
Se modifichi le impostazioni dell’opzione **NATIVE\$1NETWORK\$1ENCRYPTION**, assicurati che le seguenti impostazioni dell’opzione abbiano almeno una crittografia comune:
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER`
+ `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT`
L'esempio seguente mostra uno scenario in cui si modifica `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER`. La configurazione è valida perché sia `CRYPTO_CHECKSUM_TYPES_CLIENT` che `CRYPTO_CHECKSUM_TYPES_SERVER` utilizzano `SHA256`.
| Impostazione opzioni | Valori prima della modifica | Valori dopo la modifica |
| --- | --- | --- |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512` | Nessuna modifica |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | `SHA256`, `SHA384`, `SHA512`, `SHA1`, `MD5` | SHA1,MD5,SHA256 |
Per un altro esempio, si supponga di voler modificare `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` dalla sua impostazione di default a `SHA1,MD5`. In questo caso, assicurati di impostare `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` a `SHA1` o `MD5`. Questi algoritmi non sono inclusi nei valori di default per `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT`.
## Modifica delle impostazioni ALLOW\$1WEAK\$1CRYPTO\$1
Per impostare le opzioni `SQLNET.ALLOW_WEAK_CRYPTO*` dal valore di default `FALSE`, accertati che siano soddisfatte le seguenti condizioni:
+ `SQLNET.ENCRYPTION_TYPES_SERVER` e `SQLNET.ENCRYPTION_TYPES_CLIENT` hanno un metodo di crittografia sicuro corrispondente. Un metodo è considerato sicuro se non è `DES`, `3DES` oppure `RC4` (tutte le lunghezze di chiave).
+ `SQLNET.CHECKSUM_TYPES_SERVER` e `SQLNET.CHECKSUM_TYPES_CLIENT` hanno un metodo di checksum sicuro corrispondente. Un metodo è considerato sicuro se non è `MD5`.
+ Il client viene sottoposto a patch con la PSU di luglio 2021. Se non è stato sottoposto a patch, il client perde la connessione e riceve l’errore `ORA-12269`.
Il seguente esempio mostra impostazioni NNE di esempio. Supponiamo di voler impostare `SQLNET.ENCRYPTION_TYPES_SERVER` e `SQLNET.ENCRYPTION_TYPES_CLIENT` su FALSE, bloccando così connessioni non sicure. Le impostazioni dell'opzione checksum soddisfano i prerequisiti perché entrambe hanno `SHA256`. Tuttavia, `SQLNET.ENCRYPTION_TYPES_CLIENT` e `SQLNET.ENCRYPTION_TYPES_SERVER` utilizzano i metodi di crittografia `DES`, `3DES` e `RC4`, che non sono sicuri. Pertanto, per impostare l’opzione `SQLNET.ALLOW_WEAK_CRYPTO*` su `FALSE`, imposta prima `SQLNET.ENCRYPTION_TYPES_SERVER` e `SQLNET.ENCRYPTION_TYPES_CLIENT` su un metodo di crittografia sicuro come `AES256`.
| Impostazione opzioni | Valori |
| --- | --- |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_CLIENT` | `SHA256`, `SHA384`, `SHA512` |
| `SQLNET.CRYPTO_CHECKSUM_TYPES_SERVER` | SHA1,MD5,SHA256 |
| `SQLNET.ENCRYPTION_TYPES_CLIENT` | `RC4_256`, `3DES168`, `DES40` |
| `SQLNET.ENCRYPTION_TYPES_SERVER` | `RC4_256`, `3DES168`, `DES40` |
# Rimozione dell’opzione NATIVE\$1NETWORK\$1ENCRYPTION
Puoi rimuovere NNE da un'istanza database.
Per rimuovere l'opzione `NATIVE_NETWORK_ENCRYPTION` dall'istanza database, procedi in uno dei seguenti modi:
+ Per rimuovere l’opzione da più istanze database, rimuovi `NATIVE_NETWORK_ENCRYPTION` dal gruppo di opzioni a cui appartengono le istanze. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Una volta rimossa l’opzione `NATIVE_NETWORK_ENCRYPTION`, non è necessario riavviare le istanze database. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Per rimuovere l’opzione da una singola istanza database, modifica l’istanza e specifica un gruppo di opzioni diverso che non comprenda l’opzione `NATIVE_NETWORK_ENCRYPTION`. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Una volta rimossa l'opzione `NATIVE_NETWORK_ENCRYPTION` non è necessario riavviare la tua istanza database. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle OLAP
Amazon RDS supporta Oracle OLAP tramite l'utilizzo dell'opzione `OLAP`. Questa opzione fornisce OLAP (OnLine Analytical Processing) per le istanze database di Oracle. È possibile utilizzare Oracle OLAP per analizzare grandi quantità di dati creando oggetti e cubi dimensionali in conformità con lo standard OLAP. Per ulteriori informazioni, consulta la [documentazione di Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/olaug/index.html).
**Importante**
Se utilizzi Oracle OLAP, Amazon RDS aggiorna automaticamente la tua istanza database all'Oracle PSU più recente in presenza di vulnerabilità della sicurezza con un punteggio Common Vulnerability Scoring System (CVSS) pari a 9\$1 o altre vulnerabilità della sicurezza annunciate.
Amazon RDS supporta Oracle OLAP per la Enterprise Edition di Oracle Database 19c e versioni successive.
## Prerequisiti per Oracle OLAP
Di seguito sono indicati i prerequisiti per l'utilizzo di Oracle OLAP:
+ È necessario disporre di una licenza Oracle OLAP da Oracle. Per ulteriori informazioni, consulta [Informazioni sulle licenze](https://docs.oracle.com/en/database/oracle/oracle-database/19/dblic/Licensing-Information.html#GUID-B6113390-9586-46D7-9008-DCC9EDA45AB4) nella documentazione Oracle.
+ L'istanza database deve essere di una classe di istanza sufficiente. Oracle OLAP non è supportato per le classi di istanza database db.t3.small. Per ulteriori informazioni, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
+ L'istanza database deve avere l'opzione **Auto Minor Version Upgrade (Aggiornamento minore automatico della versione)** abilitata. Questa opzione consente all'istanza database di ricevere automaticamente gli aggiornamenti secondari della versione del motore del database quando vengono resi disponibili ed è obbligatoria per tutte le opzioni che installano la Java Virtual Machine (JVM) Oracle. Amazon RDS utilizza questa opzione per aggiornare l'istanza database all'ultimo PSU (Patch Set Update) o RU (Release Update) di Oracle. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
+ L'istanza database non deve avere un utente denominato `OLAPSYS`. In tal caso, l'installazione dell'opzione OLAP non va a buon fine.
## Best practice per Oracle OLAP
Di seguito sono indicate le best practice per l'utilizzo di Oracle OLAP:
+ Per la massima sicurezza, è necessario utilizzare l'opzione `OLAP` con Secure Sockets Layer (SSL). Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
+ Configurare l'istanza database per limitare l'accesso all'istanza database. Per ulteriori informazioni, consulta [Scenari per accedere a un'istanza database in un VPC](USER_VPC.Scenarios.md) e [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
## Aggiunta dell'opzione Oracle OLAP
Di seguito è riportato il processo generale per aggiungere l'opzione `OLAP` a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Se Oracle Java Virtual Machine *non* è installato nell'istanza database, durante l'aggiunta dell'opzione `OLAP` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta aggiunta l'opzione, non è necessario riavviare l'istanza database. Non appena il gruppo di opzioni diventa attivo, Oracle OLAP è disponibile.
**Per aggiungere l'opzione OLAP a un'istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
+ Per **Engine (Motore)**, scegliere l'edizione Oracle per l'istanza database.
+ In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **OLAP** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, applicare il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, applicare il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Utilizzo di Oracle OLAP
Dopo che è stata abilitata, è possibile iniziare a utilizzare immediatamente l'opzione Oracle OLAP. Per un elenco di funzionalità supportate per Oracle OLAP, consulta [la documentazione di Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/olaug/overview.html#GUID-E2056FE4-C623-4D29-B7D8-C4762F941966).
## Rimozione dell'opzione Oracle OLAP
Dopo aver eliminato tutti gli oggetti che utilizzano i tipi di dati forniti dall'opzione `OLAP`, è possibile rimuovere l'opzione da un'istanza DB. Se Oracle Java Virtual Machine *non* è installata nell'istanza database, durante la rimozione dell'opzione `OLAP` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta rimossa l'opzione `OLAP` non è necessario riavviare la tua istanza database.
**Per eliminare l'opzione `OLAP`**
1. Eseguire il backup dei dati.
**avvertimento**
Se l'istanza utilizza tipi di dati abilitati come parte dell'opzione e se si rimuove l'opzione `OLAP`, è possibile perdere i dati. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
1. Verificare se gli oggetti esistenti fanno riferimento ai tipi di dati o alle feature dell'opzione `OLAP`.
1. Eliminare gli oggetti che fanno riferimento ai tipi di dati o alle feature dell'opzione `OLAP`.
1. Scegliere una delle seguenti operazioni:
+ Rimuovere l'opzione `OLAP` dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione `OLAP`. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle Secure Sockets Layer
Puoi abilitare la crittografia SSL per un’istanza database RDS per Oracle aggiungendo l’opzione Oracle SSL al gruppo di opzioni associato all’istanza database. Amazon RDS utilizza una seconda porta, come richiesto da Oracle, per le connessioni SSL. Questo approccio rende possibile allo stesso tempo sia testo in chiaro che comunicazioni con crittografia SSL tra un'istanza database e SQL\$1Plus. Ad esempio, è possibile utilizzare la porta con testo in chiaro per comunicare con altre risorse all'interno di un VPC mentre utilizzi la porta con crittografia SSL per comunicare con risorse all'esterno del VPC.
**Nota**
È possibile utilizzare SSL o Native Network Encryption (NNE) sulla stessa istanza database RDS per Oracle. Se utilizzi la crittografia SSL, assicurati di disabilitare qualsiasi altro metodo di crittografia della connessione. Per ulteriori informazioni, consulta [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md).
SSL/TLS e NNE non fanno più parte di Oracle Advanced Security. In RDS per Oracle, puoi utilizzare la crittografia SSL con tutte le edizioni con licenza delle seguenti versioni del database:
+ Oracle Database 21c (21.0.0)
+ Oracle Database 19c (19.0.0)
**Topics**
+ [Versioni TLS per l'opzione SSL di Oracle](#Appendix.Oracle.Options.SSL.TLS)
+ [Suite di cifratura per l'opzione Oracle SSL](#Appendix.Oracle.Options.SSL.CipherSuites)
+ [Supporto FIPS](#Appendix.Oracle.Options.SSL.FIPS)
+ [Compatibilità dei certificati con le suite di crittografia](#Appendix.Oracle.Options.SSL.CertificateCompatibility)
+ [Aggiunta dell'opzione SSL](Appendix.Oracle.Options.SSL.OptionGroup.md)
+ [Configurazione di SQL\$1Plus per l'utilizzo di SSL con un'istanza database RDS per Oracle](Appendix.Oracle.Options.SSL.ClientConfiguration.md)
+ [Connessione a un'istanza database RDS per Oracle tramite SSL](Appendix.Oracle.Options.SSL.Connecting.md)
+ [Configurazione di una connessione SSL su JDBC](Appendix.Oracle.Options.SSL.JDBC.md)
+ [Applicazione di una corrispondenza DN con connessione SSL](Appendix.Oracle.Options.SSL.DNMatch.md)
+ [Risoluzione dei problemi relativi alle connessioni SSL](Appendix.Oracle.Options.SSL.troubleshooting.md)
## Versioni TLS per l'opzione SSL di Oracle
Amazon RDS for Oracle supporta Transport Layer Security (TLS) versioni 1.0 e 1.2. Quando aggiungi una nuova opzione SSL di Oracle, imposta `SQLNET.SSL_VERSION` su un valore valido in modo esplicito. Di seguito sono indicati i valori consentiti per questa impostazione dell’opzione:
+ `"1.0"`: i client possono connettersi all'istanza database solo tramite TLS versione 1.0. Per le opzioni SSL di Oracle esistenti, `SQLNET.SSL_VERSION` è impostato su `"1.0"` automaticamente. Puoi modificare questa impostazione, se necessario.
+ `"1.2"` – I client possono connettersi all'istanza database solo tramite TLS 1.2.
+ `"1.2 or 1.0"` – I client possono connettersi all'istanza database tramite TLS 1.2 o 1.0.
## Suite di cifratura per l'opzione Oracle SSL
Amazon RDS for Oracle supporta suite di cifratura SSL multiple. Come impostazione predefinita, l’opzione Oracle SSL è configurata per utilizzare la suite di cifratura `SSL_RSA_WITH_AES_256_CBC_SHA`. Per specificare una suite di cifratura diversa da adottare nelle connessioni SSL, usare l’impostazione dell’opzione `SQLNET.CIPHER_SUITE`.
Puoi specificare valori multipli per `SQLNET.CIPHER_SUITE`. Questa tecnica è utile se disponi di collegamenti al database tra le istanze database e decidi di aggiornare le suite di crittografia.
Nella tabella seguente viene indicato il supporto SSL di RDS per Oracle in tutte le edizioni di Oracle Database 19c e 21c.
| Suite di crittografia (SQLNET.CIPHER\$1SUITE) | Supporto della versione TLS (SQLNET.SSL\$1VERSION) | Supporto FIPS | Conformità agli standard FedRAMP |
| --- | --- | --- | --- |
| SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA (predefinito) | 1.0 e 1.2 | Sì | No |
| SSL\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 | 1.2 | Sì | No |
| SSL\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Sì | No |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1GCM\$1 SHA256 | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 | 1.2 | Sì | Sì |
| TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | 1.2 | Sì | Sì |
## Supporto FIPS
RDS per Oracle consente di utilizzare lo standard Federal Information Processing Standard (FIPS) per 140-2. FIPS 140-2 è uno standard del governo degli Stati Uniti che definisce i requisiti di sicurezza del modulo crittografico. Attiva lo standard FIPS impostando `FIPS.SSLFIPS_140` su `TRUE` per l'opzione Oracle SSL. Quando FIPS 140-2 è configurato per SSL, le librerie crittografiche eseguono la crittografia dei dati tra il client e l'istanza database Oracle.
I client devono utilizzare la suite di crittografia conforme con FIPS. Quando si stabilisce una connessione, il client e l'istanza database RDS per Oracle negoziano quale suite di cifratura utilizzare durante la trasmissione dei messaggi in entrambe le direzioni. Nella tabella in [Suite di cifratura per l'opzione Oracle SSL](#Appendix.Oracle.Options.SSL.CipherSuites) vengono illustrate le suite di crittografia SSL conformi a FIPS per ogni versione TLS. Per ulteriori informazioni, consulta la pagina relativa alle [impostazioni FIPS 140-2 del database Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/12.2/dbseg/oracle-database-fips-140-settings.html#GUID-DDBEB3F9-B216-44BB-8C18-43B5E468CBBB) nella documentazione del database Oracle.
## Compatibilità dei certificati con le suite di crittografia
RDS per Oracle supporta i certificati RSA ed ECDSA (Elliptic Curve Digital Signature Algorithm). Quando configuri SSL per l’istanza database, devi assicurarti che le suite di crittografia specificate nell’impostazione dell’opzione `SQLNET.CIPHER_SUITE` siano compatibili con il tipo di certificato utilizzato dall’istanza database.
La tabella seguente mostra la compatibilità tra i tipi di certificato e le suite di crittografia:
| Tipo di certificato | Suite di crittografia compatibili | Suite di crittografia incompatibili |
| --- | --- | --- |
| Certificati RSA (rds-ca-2019, 2048-g1, 4096-g1) rds-ca-rsa rds-ca-rsa | SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 SSL\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1GCM\$1 SHA256 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA | TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 |
| Certificati ECDSA (384-g1) rds-ca-ecc | TLS\$1ECDHE\$1ECDSA\$1WITH\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1ECDSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 | SSL\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA SSL\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA256 SSL\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1GCM\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1GCM\$1 SHA256 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1256\$1CBC\$1 SHA384 TLS\$1ECDHE\$1RSA\$1CON\$1AES\$1128\$1CBC\$1 SHA256 TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1256\$1CBC\$1SHA TLS\$1ECDHE\$1RSA\$1WITH\$1AES\$1128\$1CBC\$1SHA |
Quando specifichi più suite di crittografia nell’impostazione dell’opzione `SQLNET.CIPHER_SUITE`, assicurati di includere almeno una suite di crittografia compatibile con il tipo di certificato utilizzato dall’istanza database. Se utilizzi un gruppo di opzioni con più istanze database con tipi di certificati diversi, includi almeno una suite di crittografia per ogni tipo di certificato.
Se tenti di associare un gruppo di opzioni a un’opzione SSL che contiene solo suite di crittografia incompatibili con il tipo di certificato di un’istanza database, l’operazione avrà esito negativo e verrà visualizzato un messaggio di errore che indica l’incompatibilità.
# Aggiunta dell'opzione SSL
Per utilizzare SSL, l'istanza database RDS per Oracle deve essere associata a un gruppo di opzioni che include l'opzione `SSL`.
## Console
**Per aggiungere l'opzione SSL a un gruppo di opzioni**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `SSL`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `SSL` al gruppo di opzioni.
Se si desidera utilizzare solo suite di crittografia conformi a FIPS per le connessioni SSL, impostare l'opzione `FIPS.SSLFIPS_140` su `TRUE`. Per informazioni sullo standard FIPS, consulta [Supporto FIPS](Appendix.Oracle.Options.SSL.md#Appendix.Oracle.Options.SSL.FIPS).
Per informazioni sull'aggiunta di un'opzione a un gruppo di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Crea una nuova istanza database RDS per Oracle e associarvi il gruppo opzioni oppure modificare un'istanza database RDS per Oracle per associare il gruppo opzioni a essa.
Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
Per informazioni sulla modifica di un'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## AWS CLI
**Per aggiungere l'opzione SSL a un gruppo di opzioni**
1. Creare un nuovo gruppo di opzioni o identificare un gruppo opzioni esistente a cui è possibile aggiungere l'opzione `SSL`.
Per informazioni sulla creazione di un gruppo di opzioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione `SSL` al gruppo di opzioni.
Specificare le seguenti impostazioni delle opzioni:
+ `Port` – Il numero di porta SSL
+ `VpcSecurityGroupMemberships` – Il gruppo di sicurezza VPC per cui è abilitata l'opzione
+ `SQLNET.SSL_VERSION` – La versione TLS utilizzabile dal client per connettersi all'istanza database
Ad esempio, il comando seguente AWS CLI aggiunge l'opzione `SSL` a un gruppo opzioni denominato `ora-option-group`.
**Example**
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group --option-group-name ora-option-group \
--options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
```
Per Windows:
```
aws rds add-option-to-option-group --option-group-name ora-option-group ^
--options 'OptionName=SSL,Port=2484,VpcSecurityGroupMemberships="sg-68184619",OptionSettings=[{Name=SQLNET.SSL_VERSION,Value=1.0}]'
```
1. Crea una nuova istanza database RDS per Oracle e associarvi il gruppo opzioni oppure modificare un'istanza database RDS per Oracle per associare il gruppo opzioni a essa.
Per informazioni sulla creazione di un'istanza database, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
Per informazioni sulla modifica di un'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Configurazione di SQL\$1Plus per l'utilizzo di SSL con un'istanza database RDS per Oracle
Prima di connetterti a un'istanza database RDS per Oracle che utilizza l'opzione SSL di Oracle, devi configurare SQL\$1Plus.
**Nota**
Per concedere l'accesso all'istanza database dai client appropriati, verifica che i gruppi di sicurezza siano configurati correttamente. Per ulteriori informazioni, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md). Inoltre, queste istruzioni si riferiscono a SQL\$1Plus e ad altri client che usano direttamente una home directory Oracle. Per le connessioni JDBC, consulta [Configurazione di una connessione SSL su JDBC](Appendix.Oracle.Options.SSL.JDBC.md).
**Per configurare SQL\$1Plus in modo che utilizzi SSL per connettersi a un'istanza database RDS per Oracle**
1. Imposta la variabile di ambiente `ORACLE_HOME` sulla posizione della home directory di Oracle.
Il percorso della home directory di Oracle dipende dall'installazione. Nell'esempio seguente viene impostata la variabile di ambiente `ORACLE_HOME`.
```
prompt>export ORACLE_HOME=/home/user/app/user/product/19.0.0/dbhome_1
```
Per informazioni sull'impostazione delle variabili di ambiente di Oracle, consulta [Variabili di ambiente di SQL\$1Plus](http://docs.oracle.com/database/121/SQPUG/ch_two.htm#SQPUG331) nella documentazione di Oracle e la guida di installazione di Oracle per il tuo sistema operativo.
1. Aggiungi `$ORACLE_HOME/lib` alla variabile di ambiente `LD_LIBRARY_PATH`.
Nell'esempio seguente viene impostata la variabile di ambiente LD\$1LIBRARY\$1PATH.
```
prompt>export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib
```
1. Crea una directory per il wallet Oracle nel percorso `$ORACLE_HOME/ssl_wallet`.
Nell'esempio seguente viene creata la directory per il wallet Oracle.
```
prompt>mkdir $ORACLE_HOME/ssl_wallet
```
1. Scarica il file .pem del pacchetto di certificati che funziona per tutti Regioni AWS e inserisci il file nella directory ssl\$1wallet. Per informazioni, consulta [](UsingWithRDS.SSL.md).
1. Nella directory `$ORACLE_HOME/network/admin`, modifica o crea il file `tnsnames.ora` e includi la voce seguente.
```
net_service_name =
(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS =
(PROTOCOL = TCPS)
(HOST = endpoint)
(PORT = ssl_port_number)
)
)
(CONNECT_DATA =
(SID = database_name)
)
(SECURITY =
(SSL_SERVER_CERT_DN = "C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=endpoint")
)
)
```
1. Nella stessa directory, modifica o crea il file sqlnet.ora e includi i parametri seguenti.
**Nota**
Per comunicare con le entità tramite una connessione protetta TLS, Oracle richiede un wallet con i certificati necessari per l'autenticazione. È possibile utilizzare l'utility ORAPKI di Oracle per creare e gestire i wallet Oracle, come mostrato nel fase 7. Per ulteriori informazioni, consulta [Setting Up Oracle Wallet Using ORAPKI](https://docs.oracle.com/cd/E92519_02/pt856pbr3/eng/pt/tsvt/task_SettingUpOracleWalletUsingORAPKI.html) nella documentazione Oracle.
```
WALLET_LOCATION = (SOURCE = (METHOD = FILE) (METHOD_DATA = (DIRECTORY = $ORACLE_HOME/ssl_wallet)))
SSL_CLIENT_AUTHENTICATION = FALSE
SSL_VERSION = 1.0
SSL_CIPHER_SUITES = (SSL_RSA_WITH_AES_256_CBC_SHA)
SSL_SERVER_DN_MATCH = ON
```
**Nota**
È possibile impostare `SSL_VERSION` su un valore più alto se supportato dall'istanza database.
1. Esegui il comando seguenti per creare il wallet Oracle.
```
prompt>orapki wallet create -wallet $ORACLE_HOME/ssl_wallet -auto_login_only
```
1. Estrai ogni certificato nel file bundle .pem in un file .pem separato utilizzando un’utilità del sistema operativo.
1. Aggiungi ogni certificato al tuo wallet utilizzando comandi `orapki` separati, sostituendo `certificate-pem-file` con il nome di file assoluto del file .pem.
```
prompt>orapki wallet add -wallet $ORACLE_HOME/ssl_wallet -trusted_cert -cert
certificate-pem-file -auto_login_only
```
Per ulteriori informazioni, consulta [Rotazione del certificato SSL/TLS](UsingWithRDS.SSL-certificate-rotation.md).
# Connessione a un'istanza database RDS per Oracle tramite SSL
Dopo aver configurato SQL\$1Plus per l'uso di SSL come descritto in precedenza, puoi connetterti all'istanza database RDS per Oracle con l'opzione SSL. Facoltativamente, puoi innanzitutto esportare il valore `TNS_ADMIN` che punta alla directory contenente i file tnsnames.ora e sqlnet.ora. In questo modo, SQL\$1Plus può trovare questi file in modo coerente. Nell'esempio seguente viene esportato il valore `TNS_ADMIN`.
```
export TNS_ADMIN=${ORACLE_HOME}/network/admin
```
Effettua la connessione all'istanza database. Ad esempio, puoi connetterti tramite SQL\$1Plus e un ** in un file tnsnames.ora.
```
sqlplus mydbuser@net_service_name
```
Puoi anche connetterti all'istanza database con SQL\$1Plus senza utilizzare un file tnsnames.ora tramite il comando seguente.
```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCPS)(HOST = endpoint) (PORT = ssl_port_number))(CONNECT_DATA = (SID = database_name)))'
```
Puoi anche connetterti all'istanza database RDS per Oracle senza utilizzare SSL. Il comando seguente, ad esempio, consente la connessione all'istanza database sulla porta con testo in chiaro senza codifica SSL.
```
sqlplus 'mydbuser@(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = endpoint) (PORT = port_number))(CONNECT_DATA = (SID = database_name)))'
```
Se desideri chiudere l'accesso alla porta Transmission Control Protocol (TCP), crea un gruppo di sicurezza senza ingressi con indirizzo IP e aggiungilo all'istanza. In questo modo vengono chiuse le connessioni sulla porta TCP, ma continuano a essere permesse quelle sulla porta SSL specificate dagli indirizzi IP compresi nell'intervallo consentito dal gruppo di sicurezza dell'opzione SSL.
# Configurazione di una connessione SSL su JDBC
Per utilizzare una connessione SSL su JDBC, devi creare un keystore, approvare il certificato CA root di Amazon RDS e utilizzare il frammento di codice specificato di seguito.
Per creare il keystore in formato JKS, puoi utilizzare il comando seguente. Per ulteriori informazioni sulla creazione del keystore, consulta [Creating a keystore](https://docs.oracle.com/cd/E35822_01/server.740/es_admin/src/tadm_ssl_jetty_keystore.html) nella documentazione Oracle. Per informazioni di riferimento, vedi [keytool](https://docs.oracle.com/javase/8/docs/technotes/tools/windows/keytool.html) nel *riferimento strumenti della piattaforma Java, Standard Edition.*
```
keytool -genkey -alias client -validity 365 -keyalg RSA -keystore clientkeystore
```
Esegui la procedura seguente per approvare il certificato CA root di Amazon RDS.
**Per approvare il certificato CA root di Amazon RDS**
1. Scarica il file .pem del bundle di certificati che funziona per tutte le Regioni AWS e inseriscilo nella directory ssl\$1wallet.
Per ulteriori informazioni sul download dei certificati, consultare [](UsingWithRDS.SSL.md).
1. Estrai ogni certificato nel file .pem in un file separato utilizzando un’utilità del sistema operativo.
1. Converti ogni certificato in formato.der utilizzando un comando `openssl` separato, sostituendo *certificate-pem-file* con il nome del file .pem del certificato (senza l’estensione.pem).
```
openssl x509 -outform der -in certificate-pem-file.pem -out certificate-pem-file.der
```
1. Importa ogni certificato nel keystore utilizzando il comando seguente.
```
keytool -import -alias rds-root -keystore clientkeystore.jks -file certificate-pem-file.der
```
Per ulteriori informazioni, consulta [Rotazione del certificato SSL/TLS](UsingWithRDS.SSL-certificate-rotation.md).
1. Verificare che il keystore sia stato creato correttamente.
```
keytool -list -v -keystore clientkeystore.jks
```
Inserire la password del keystore quando richiesto.
L'esempio di codice seguente mostra come impostare la connessione SSL utilizzando JDBC.
```
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
public class OracleSslConnectionTest {
private static final String DB_SERVER_NAME = "dns-name-provided-by-amazon-rds";
private static final Integer SSL_PORT = "ssl-option-port-configured-in-option-group";
private static final String DB_SID = "oracle-sid";
private static final String DB_USER = "user-name";
private static final String DB_PASSWORD = "password";
// This key store has only the prod root ca.
private static final String KEY_STORE_FILE_PATH = "file-path-to-keystore";
private static final String KEY_STORE_PASS = "keystore-password";
public static void main(String[] args) throws SQLException {
final Properties properties = new Properties();
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))(CONNECT_DATA=(SID=%s)))",
DB_SERVER_NAME, SSL_PORT, DB_SID);
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
properties.put("oracle.jdbc.J2EE13Compliant", "true");
properties.put("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
properties.put("javax.net.ssl.trustStoreType", "JKS");
properties.put("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
final Connection connection = DriverManager.getConnection(connectionString, properties);
// If no exception, that means handshake has passed, and an SSL connection can be opened
}
}
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
# Applicazione di una corrispondenza DN con connessione SSL
Puoi utilizzare il parametro `SSL_SERVER_DN_MATCH` di Oracle per applicare il nome distinto (DN) in modo che vi sia corrispondenza tra il server del database e il nome del relativo servizio. Se applichi la verifica delle corrispondenze, SSL fa in modo che il certificato provenga dal server. Se non esegui tale verifica, SSL esegue il controllo ma consente la connessione, indipendentemente dall'esistenza di una corrispondenza. Se non applichi la verifica, consenti virtualmente al server di simulare la propria identità.
Per applicare la corrispondenza DN, aggiungi la relativa proprietà e utilizza la stringa di connessione specificata di seguito.
Per applicare la corrispondenza DN, aggiungi tale proprietà alla connessione client.
```
properties.put("oracle.net.ssl_server_dn_match", "TRUE");
```
Utilizza la stringa di connessione seguente per applicare la corrispondenza DN quando utilizzi SSL.
```
final String connectionString = String.format(
"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=%s)(PORT=%d))" +
"(CONNECT_DATA=(SID=%s))" +
"(SECURITY = (SSL_SERVER_CERT_DN =
\"C=US,ST=Washington,L=Seattle,O=Amazon.com,OU=RDS,CN=%s\")))",
DB_SERVER_NAME, SSL_PORT, DB_SID, DB_SERVER_NAME);
```
# Risoluzione dei problemi relativi alle connessioni SSL
Quando esegui le query sul database è possibile ricevere l'errore `ORA-28860`.
```
ORA-28860: Fatal SSL error
28860. 00000 - "Fatal SSL error"
*Cause: An error occurred during the SSL connection to the peer. It is likely that this side sent data which the peer rejected.
*Action: Enable tracing to determine the exact cause of this error.
```
Questo errore si verifica quando il client tenta di connettersi utilizzando una versione di TLS non supportata dal server. Per evitare questo errore, modifica sqlnet.ora e imposta `SSL_VERSION` sulla versione TLS corretta. Per ulteriori informazioni, consulta il documento My Oracle Support [2748438.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=2748438.1).
# Oracle Spatial
Amazon RDS supporta Oracle Spatial tramite l'utilizzo dell'opzione `SPATIAL`. Oracle Spatial offre uno schema SQL e funzioni che semplificano le operazioni di storage, recupero, aggiornamento ed esecuzione di query per le raccolte di dati spaziali in un database Oracle. Per ulteriori informazioni, consulta la pagina [Spatial Concepts](http://docs.oracle.com/database/121/SPATL/spatial-concepts.htm#SPATL010) nella documentazione Oracle. Amazon RDS supporta Oracle Spatial in tutte le edizioni di tutte le versioni supportate.
## Come funzionano gli Spatial Patch Bundles () SPBs
Ogni trimestre, RDS per Oracle rilascia nuove versioni secondarie per tutti i motori principali supportati. Una versione del motore Release Update (RU) incorpora le correzioni di bug di Oracle includendo le patch RU per il trimestre specificato. Una versione del motore Spatial Patch Bundle (SPB) contiene le patch RU e le patch specifiche di Oracle Spatial. Ad esempio, 19.0.0.0.ru-2025-01.spb-1.r1 è una versione secondaria del motore che contiene le patch RU nella versione del motore 19.0.0.0.ru-2025-01.rur-2025-01.r1 più le patch spaziali. SPBs sono supportati solo per Oracle Database 19c.
SPBs funzionano allo stesso modo di RUs, sebbene abbiano nomi diversi. Un RU utilizza il formato di denominazione 19.0.0.0.ru-2025-01.rur-2025-01.r1. Un nome di SPB include il testo “spb”, come in 19.0.0.0.ru-2025-01.spb-1.r1. In genere, un SPB viene rilasciato 2-3 settimane dopo il corrispondente RU trimestrale. Ad esempio, 19.0.0.0.ru-2025-01.spb-1.r1 viene rilasciato dopo 19.0.0.0.ru-2025-01.rur-2025-01.r1.
RDS per Oracle dispone di percorsi separati per gli aggiornamenti automatici delle versioni secondarie di RUs and. SPBs Se l’istanza database utilizza un RU, RDS aggiorna automaticamente l’istanza a un RU. Se l’istanza database utilizza un SPB, RDS aggiorna automaticamente l’istanza a un SPB.
Per ulteriori informazioni su RUs and SPBs, vedere. [Aggiornamenti a una versione secondaria Oracle](USER_UpgradeDBInstance.Oracle.Minor.md) *Per un elenco di quelli supportati RUs e SPBs per Oracle Database 19c, consulta [Amazon RDS for Oracle Database 19c (19.0.0.0) nelle note di rilascio di Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html) for Oracle.*
## Prerequisiti per Oracle Spatial
Di seguito sono indicati i prerequisiti per l'utilizzo di Oracle Spatial:
+ Assicurati che l'istanza DB sia di una classe di istanza sufficiente. Oracle Spatial non è supportato per le classi di istanza database db.t3.small. Per ulteriori informazioni, consulta [Classi di istanza database RDS per Oracle](Oracle.Concepts.InstanceClasses.md).
+ Assicurarsi che l'istanza del DB abbia abilitato l’**aggiornamento automatico della versione minore**. Questa opzione consente all'istanza database di ricevere automaticamente gli aggiornamenti secondari della versione del motore del database quando vengono resi disponibili ed è obbligatoria per tutte le opzioni che installano la Java Virtual Machine (JVM) Oracle. Amazon RDS utilizza questa opzione per aggiornare l'istanza database all'ultimo PSU (Patch Set Update) o RU (Release Update) di Oracle. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Best practice per Oracle Spatial
Di seguito sono indicate le best practice per l'utilizzo di Oracle Spatial:
+ Per la massima sicurezza, è necessario utilizzare l'opzione `SPATIAL` con Secure Sockets Layer (SSL). Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
+ Configurare l'istanza database per limitare l'accesso all'istanza database. Per ulteriori informazioni, consulta [Scenari per accedere a un'istanza database in un VPC](USER_VPC.Scenarios.md) e [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md).
## Aggiunta dell'opzione Oracle Spatial
Di seguito è riportato il processo generale per aggiungere l'opzione `SPATIAL` a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Se Oracle Java Virtual Machine *non* è installato nell'istanza database, durante l'aggiunta dell'opzione `SPATIAL` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta aggiunta l'opzione, non è necessario riavviare l'istanza database. Non appena il gruppo di opzioni è attivo, Oracle Spatial è disponibile.
**Nota**
Durante questa interruzione, le funzioni di verifica delle password vengono temporaneamente disabilitate. Durante l'interruzione si possono verificare eventi correlati alle funzioni di verifica delle password. Le funzioni di verifica delle password vengono riabilitate prima di rendere disponibile l'istanza database Oracle.
**Per aggiungere l'opzione `SPATIAL` a un'istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine (Motore)**, scegliere l'edizione Oracle per l'istanza database.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **SPATIAL** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Rimozione dell'opzione Oracle Spatial
Dopo aver rimosso tutti gli oggetti che utilizzano i tipi di dati forniti dall'opzione `SPATIAL`, è possibile eliminare l'opzione da un'istanza DB. Se Oracle Java Virtual Machine *non* è installata nell'istanza database, durante la rimozione dell'opzione `SPATIAL` si verifica una breve interruzione. Se Oracle Java Virtual Machine è già installata nell'istanza database, non si verificherà alcuna interruzione. Una volta rimossa l'opzione `SPATIAL` non è necessario riavviare la tua istanza database.
**Per eliminare l'opzione `SPATIAL`**
1. Eseguire il backup dei dati.
**avvertimento**
Se l'istanza utilizza tipi di dati abilitati come parte dell'opzione e se si rimuove l'opzione `SPATIAL`, è possibile perdere i dati. Per ulteriori informazioni, consulta [Backup, ripristino ed esportazione dei dati](CHAP_CommonTasks.BackupRestore.md).
1. Verificare se gli oggetti esistenti fanno riferimento ai tipi di dati o alle feature dell'opzione `SPATIAL`.
Se esistono opzioni `SPATIAL`, l'istanza può rimanere bloccata quando si applica il nuovo gruppo di opzioni che non dispone dell'opzione `SPATIAL`. È possibile identificare gli oggetti utilizzando le seguenti query:
```
SELECT OWNER, SEGMENT_NAME, TABLESPACE_NAME, BYTES/1024/1024 mbytes
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE '%TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT DISTINCT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE='SDO_GEOMETRY'
AND OWNER <> 'MDSYS')
ORDER BY 1,2,3,4;
SELECT OWNER, TABLE_NAME, COLUMN_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE = 'SDO_GEOMETRY'
AND OWNER <> 'MDSYS'
ORDER BY 1,2,3;
```
1. Eliminare gli oggetti che fanno riferimento ai tipi di dati o alle feature dell'opzione `SPATIAL`.
1. Scegliere una delle seguenti operazioni:
+ Rimuovere l'opzione `SPATIAL` dal gruppo di opzioni a cui appartiene. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Modificare l'istanza database e specificare un diverso gruppo di opzioni che non comprenda l'opzione `SPATIAL`. Questa modifica coinvolge una singola istanza database. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle SQLT
Amazon RDS supporta Oracle SQLTXPLAIN (SQLT) attraverso l'utilizzo dell'opzione SQLT. È possibile utilizzare SQLT con qualsiasi edizione di Oracle Database 19c e successive.
L'istruzione `EXPLAIN PLAN` di Oracle può stabilire il piano di esecuzione di un'istruzione SQL. Può verificare se l'ottimizzatore di Oracle sceglie un determinato piano di esecuzione, come un loop nidificato. Consente inoltre di comprendere le decisioni dell'ottimizzatore, ad esempio il motivo della scelta di loop nidificati rispetto a un hash join. Pertanto, `EXPLAIN PLAN` aiuta a comprendere le prestazioni dell'istruzione.
SQLT è un'utilità di Oracle che produce un rapporto. Tale rapporto include statistiche e metadati degli oggetti, parametri di inizializzazione correlati all'ottimizzatore e altre informazioni che possono essere utilizzate da un amministratore del database per modificare un'istruzione SQL e migliorarne le prestazioni. SQLT produce un rapporto HTML con collegamenti ipertestuali a tutte le relative sezioni.
A differenza dei rapporti di Automatic Workload Repository o Statspack, SQLT agisce sulle singole istruzioni SQL. SQLT è una raccolta di file SQL, PL/SQL e SQL\$1Plus che consente di raccogliere, archiviare e visualizzare i dati delle prestazioni.
Di seguito sono indicate le versioni Oracle supportate per ogni versione di SQLT.
****
| Versione SQLT | Oracle Database 21c | Oracle Database 19c |
| --- | --- | --- |
| 2018-07-25.v1 | Supportato | Supportato |
| 2018-03-31.v1 | Non supportato | Non supportato |
| 2016-04-29.v1 | Non supportato | Non supportato |
Per il download e le istruzioni per l'accesso di SQLT:
+ Accedere all'account My Oracle Support e aprire i documenti seguenti:
+ Per scaricare SQLT: [Document 215187.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=215187.1)
+ Per istruzioni per l'utilizzo di SQLT: [Document 1614107.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1614107.1)
+ Per le domande frequenti su SQLT: [Document 1454160.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=1454160.1)
+ Per informazioni sulla lettura dell'output di SQLT: [Document 1456176.1](https://support.oracle.com/epmos/main/downloadattachmentprocessor?parent=DOCUMENT&sourceId=1456176.1&attachid=1456176.1:58&clickstream=yes)
+ Per l'interpretazione del report principale: [Documento 1922234.1](https://support.oracle.com/epmos/faces/DocumentDisplay?parent=DOCUMENT&sourceId=215187.1&id=1922234.1)
Amazon RDS non supporta i seguenti metodi SQLT:
+ `XPLORE`
+ `XHUME`
## Prerequisiti di SQLT
Di seguito sono indicati i prerequisiti per l'utilizzo di SQLT:
+ Devi rimuovere gli utenti e ruoli richiesti da SQLT, se esistenti.
L'opzione SQLT crea i seguenti utenti e ruoli in un'istanza database:
+ `SQLTXPLAIN`Utente
+ `SQLTXADMIN`Utente
+ `SQLT_USER_ROLE`Ruolo
Se nell'istanza database sono presenti uno o più di tali utenti o ruoli, accedi all'istanza database con un client SQL ed eliminali con le seguenti istruzioni:
```
DROP USER SQLTXPLAIN CASCADE;
DROP USER SQLTXADMIN CASCADE;
DROP ROLE SQLT_USER_ROLE CASCADE;
```
+ Devi rimuovere gli spazi tabelle richiesti da SQLT, se esistenti.
L'opzione SQLT crea i seguenti spazi tabelle in un'istanza database:
+ `RDS_SQLT_TS`
+ `RDS_TEMP_SQLT_TS`
Se nell'istanza database sono presenti tali spazi tabelle, accedi all'istanza database con un client SQL ed eliminali con le seguenti istruzioni:
## Impostazioni dell'opzione SQLT
SQLT può essere utilizzata con caratteristiche con licenza fornite da Oracle Tuning Pack e da Oracle Diagnostics Pack. Oracle Tuning Pack include SQL Tuning Advisor, mentre Oracle Diagnostics Pack include Automatic Workload Repository. Le impostazioni SQLT consentono di abilitare o disabilitare l'accesso a tali caratteristiche da SQLT.
Amazon RDS supporta le seguenti impostazioni per l'opzione SQLT.
****
| Impostazione opzioni | Valori validi | Valore predefinito | Descrizione |
| --- | --- | --- | --- |
| `LICENSE_PACK` | `T`, `D`, `N` | `N` | Gli Oracle Management Pack a cui desideri accedere con SQLT. Immetti uno dei seguenti valori: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/Oracle.Options.SQLT.html) Amazon RDS non fornisce licenze per i seguenti Oracle Management Pack. Se specifichi che desideri utilizzare un pacchetto non incluso nell'istanza database, puoi utilizzare SQLT con tale istanza database. Tuttavia, SQLT non sarà in grado di accedere al pacchetto e il rapporto SQLT non includerà i relativi dati. Ad esempio, se specifichi `T`, ma l'istanza database non include Oracle Tuning Pack, SQLT opererà sull'istanza database, ma il rapporto generato non includerà i dati relativi a Oracle Tuning Pack. |
| `VERSION` | `2016-04-29.v1` `2018-03-31.v1` `2018-07-25.v1` | `2016-04-29.v1` | Versione di SQLT da installare. Per Oracle Database 19c e 21c, l'unica versione supportata è `2018-07-25.v1`. Questa è la versione predefinita per queste versioni. |
## Aggiunta dell'opzione SQLT
Di seguito è riportato il processo generale per aggiungere l'opzione SQLT a un'istanza database:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione SQLT al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Una volta aggiunta l'opzione SQLT, non appena il gruppo di opzioni sarà attivo, anche SQLT sarà attivo.
**Per aggiungere l'opzione SQLT a un'istanza database**
1. Determinare il gruppo di opzioni che si vuole usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine (Motore)**, scegliere l'edizione di Oracle da utilizzare. L'opzione SQLT è supportata in tutte le edizioni.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **SQLT** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
1. (Opzionale) Verificare l'installazione SQLT in ciascuna istanza database dell'opzione SQLT.
1. Utilizzare un client SQL per effettuare la connessione all'istanza database come utente master.
Per informazioni sulla connessione a un'istanza database Oracle con un client SQL, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Eseguire la seguente query:
```
SELECT sqltxplain.sqlt$a.get_param('tool_version') sqlt_version FROM DUAL;
```
La query restituisce la versione corrente dell'opzione SQLT in Amazon RDS. `12.1.160429` è un esempio di versione di SQLT disponibile in Amazon RDS.
1. Modificare le password degli utenti creati dall'opzione SQLT.
1. Utilizzare un client SQL per effettuare la connessione all'istanza database come utente master.
1. Eseguire la seguente istruzione SQL per modificare la password dell'utente `SQLTXADMIN`:
```
ALTER USER SQLTXADMIN IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Eseguire la seguente istruzione SQL per modificare la password dell'utente `SQLTXPLAIN`:
```
ALTER USER SQLTXPLAIN IDENTIFIED BY new_password ACCOUNT UNLOCK;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
**Nota**
Per aggiornare SQLT, dovrai disinstallare la versione precedente di SQLT e installare quella nuova. Pertanto, durante l'aggiornamento di SQLT, tutti i metadati SQLT potrebbero andare perduti. Anche l'aggiornamento di una versione principale di un database la disinstallazione e la reinstallazione di SQLT. Un esempio di aggiornamento di una versione principale è quello da Oracle Database 19c a Oracle Database 21c.
## Uso di SQLT
SQLT funziona con l'utilità Oracle SQL\$1Plus.
**Per utilizzare SQLT**
1. Scaricare il file .zip di SQLT da [Document 215187.1](https://support.oracle.com/epmos/faces/DocumentDisplay?id=215187.1) nel sito My Oracle Support.
**Nota**
Non è possibile scaricare SQLT 12.1.160429 dal sito My Oracle Support. Oracle ha dichiarato obsoleta questa versione precedente.
1. Decomprimere il file .zip di SQLT.
1. Dal prompt dei comandi, portarsi sulla directory `sqlt/run` del file system.
1. Dal prompt dei comandi, aprire SQL\$1Plus ed effettuare la connessione all'istanza database come utente master.
Per informazioni sulla connessione a un'istanza database Oracle con SQL\$1Plus, consulta [Connessione all'istanza database Oracle](USER_ConnectToOracleInstance.md).
1. Ottenere l'ID SQL di un'istruzione SQL:
```
SELECT SQL_ID FROM V$SQL WHERE SQL_TEXT='sql_statement';
```
L'output è simile a quello riportato di seguito:
```
SQL_ID
-------------
chvsmttqjzjkn
```
1. Analizzare un'istruzione SQL con SQLT:
```
START sqltxtract.sql sql_id sqltxplain_user_password
```
Ad esempio, per l'ID SQL `chvsmttqjzjkn`, immettere quanto segue:
```
START sqltxtract.sql chvsmttqjzjkn sqltxplain_user_password
```
SQLT genera un rapporto e le risorse correlate come un file. zip nella directory in cui è stato eseguito il comando SQLT.
1. (Opzionale) Per consentire agli utenti dell'applicazione di diagnosticare le istruzioni SQL con SQLT, concedere `SQLT_USER_ROLE` a ciascun utente con la seguente istruzione:
```
GRANT SQLT_USER_ROLE TO application_user_name;
```
**Nota**
Oracle sconsiglia l'esecuzione di SQLT con l'utente `SYS` o con utenti che dispongono del ruolo `DBA`. La best practice prevede l'esecuzione della diagnostica SQLT con l'account dell'utente dell'applicazione, concedendo `SQLT_USER_ROLE` a tale utente.
## Aggiornamento dell'opzione SQLT
Con Amazon RDS for Oracle puoi aggiornare l'opzione SQLT dalla versione attuale a una versione successiva. Per aggiornare l'opzione SQLT, completa le fasi 1–3 in [Uso di SQLT](#Oracle.Options.SQLT.Using) per la nuova versione di SQLT. Inoltre, se hai concesso privilegi per la versione precedente di SQLT nella fase 7 di questa sezione, assegnali di nuovo per la nuova versione di SQLT.
L'aggiornamento dell'opzione SQLT causa la perdita dei metadati della versione precedente di SQLT. Lo schema e gli oggetti correlati della versione di SQLT precedente vengono eliminati e viene installata la versione più recente. Per ulteriori informazioni sulle modifiche nella versione più recente di SQLT, consulta il [Documento 1614201.1](https://support.oracle.com/epmos/faces/DocumentDisplay?parent=DOCUMENT&sourceId=215187.1&id=1614201.1) nel sito My Oracle Support.
**Nota**
I downgrade di versione non sono supportati.
## Modifica delle impostazioni SQLT
Dopo avere abilitato SQLT, puoi modificare le impostazioni `LICENSE_PACK` e `VERSION` dell'opzione.
Per ulteriori informazioni su come modificare le impostazioni dell'opzione, consulta [Modifica di un'impostazione di un'opzione](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption). Per ulteriori informazioni su ciascuna impostazione, consulta [Impostazioni dell'opzione SQLT](#Oracle.Options.SQLT.Options).
## Rimozione dell'opzione SQLT
Puoi rimuovere SQLT da un'istanza database.
Per rimuovere SQLT da un'istanza database, esegui una delle seguenti procedure:
+ Per rimuovere SQLT da più istanze database, rimuovi l'opzione SQLT dal gruppo di opzioni a cui appartengono le istanze database. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Per rimuovere SQLT da una singola istanza database, modifica l'istanza database e specifica un gruppo di opzioni diverso che non comprenda l'opzione SQLT. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
# Oracle Statspack
L'opzione Oracle Statspack consente di installare e abilitare le statistiche sulle prestazioni di Oracle Statspack. Oracle Statspack è una raccolta di script SQL, PL/SQL e SQL\$1Plus che consente di raccogliere, archiviare e visualizzare i dati delle prestazioni. Per informazioni sull'utilizzo di Oracle Statspack, consulta la sezione [Oracle Statspack](http://docs.oracle.com/cd/E13160_01/wli/docs10gr3/dbtuning/statsApdx.html) della documentazione di Oracle.
**Nota**
Oracle Statspack non è più supportato da Oracle ed è stato sostituito dal più avanzato Automatic Workload Repository (AWR). AWR è disponibile soltanto per i clienti con Oracle Enterprise Edition che abbiano acquistato il Diagnostics Pack. È possibile utilizzare Oracle Statspack con qualsiasi motore Oracle DB su Amazon RDS. Non è possibile eseguire Oracle Statspack sulle repliche di lettura Amazon RDS.
## Impostazione di Oracle Statspack
Per eseguire gli script Statspack, è necessario aggiungere l'opzione Statspack.
**Per impostare Oracle Statspack**
1. In un client SQL, accedere al DB Oracle con un account amministrativo.
1. Eseguire una delle seguenti azioni, a seconda che Statspack sia installato o meno:
+ Se Statspack è installato e l'account `PERFSTAT` è associato a Statspack, andare al passaggio 4.
+ Se Statspack non è installato e l'account `PERFSTAT` esiste, eliminare l'account come segue:
```
DROP USER PERFSTAT CASCADE;
```
In caso contrario, il tentativo di aggiungere l'opzione Statspack genera un errore e `RDS-Event-0058`.
1. Aggiungere l'opzione Statspack a un gruppo di opzioni. Per informazioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
Amazon RDS installa automaticamente gli script Statspack sull'istanza database e quindi imposta l'account `PERFSTAT`.
1. Reimpostare la password utilizzando la seguente istruzione SQL, sostituendo *pwd* con la nuova password:
```
ALTER USER PERFSTAT IDENTIFIED BY pwd ACCOUNT UNLOCK;
```
È possibile accedere utilizzando l'account utente `PERFSTAT` ed eseguire gli script Statspack.
1. Concedi il privilegio `CREATE JOB` all’account `PERFSTAT` utilizzando l’istruzione seguente:
```
GRANT CREATE JOB TO PERFSTAT;
```
1. Assicurarsi che gli eventi di attesa inattivi nella tabella `PERFSTAT.STATS$IDLE_EVENT` siano popolati.
A causa del bug Oracle 28523746, gli eventi di attesa per inattività in `PERFSTAT.STATS$IDLE_EVENT` potrebbero non essere popolati. Per assicurarsi che tutti gli eventi inattivi siano disponibili, eseguire l'istruzione seguente:
```
INSERT INTO PERFSTAT.STATS$IDLE_EVENT (EVENT)
SELECT NAME FROM V$EVENT_NAME WHERE WAIT_CLASS='Idle'
MINUS
SELECT EVENT FROM PERFSTAT.STATS$IDLE_EVENT;
COMMIT;
```
## Generazione di report Statspack
Un report Statspack confronta due snapshot.
**Per generare report Statspack**
1. In un client SQL, accedere al DB Oracle con l'account `PERFSTAT`.
1. Creare uno snapshot utilizzando una delle seguenti tecniche:
+ Creare manualmente uno snapshot Statspack.
+ Creare un processo che accetti uno snapshot Statspack dopo un determinato intervallo di tempo. Ad esempio, il processo seguente crea uno snapshot Statspack ogni ora:
```
VARIABLE jn NUMBER;
exec dbms_job.submit(:jn, 'statspack.snap;',SYSDATE,'TRUNC(SYSDATE+1/24,''HH24'')');
COMMIT;
```
1. Visualizzare gli snapshot utilizzando la seguente query:
```
SELECT SNAP_ID, SNAP_TIME FROM STATS$SNAPSHOT ORDER BY 1;
```
1. Eseguire la procedura `rdsadmin.rds_run_spreport` Amazon RDS, sostituendo *begin\$1snap* e *end\$1snap* con gli ID snapshot:
```
exec rdsadmin.rds_run_spreport(begin_snap,end_snap);
```
Il comando seguente, ad esempio, crea un report basato sull'intervallo compreso tra gli snapshot 1 e 2 di Statspack:
```
exec rdsadmin.rds_run_spreport(1,2);
```
Il nome del file del report Statspack include il numero dei due snapshot. Ad esempio, il file di report creato utilizzando gli snapshot 1 e 2 di Statspack sarà denominato `ORCL_spreport_1_2.lst`.
1. Monitorare l'output per eventuali errori.
Oracle Statspack esegue controlli prima di eseguire il report. Pertanto, è possibile visualizzare anche messaggi di errore nell'output del comando. Ad esempio, è possibile provare a generare un report basato su un intervallo non valido, in cui il valore iniziale dello snapshot Statspack è maggiore del valore finale. In questo caso, l'output mostra il messaggio di errore, ma il motore DB non genera un file di errore.
```
exec rdsadmin.rds_run_spreport(2,1);
*
ERROR at line 1:
ORA-20000: Invalid snapshot IDs. Find valid ones in perfstat.stats$snapshot.
```
Se si utilizza un numero non valido per uno snapshot Statspack, l'output mostra un errore. Ad esempio, se si tenta di generare un report per gli snapshot 1 e 50, ma lo snapshot 50 non esiste, verrà visualizzato un errore.
```
exec rdsadmin.rds_run_spreport(1,50);
*
ERROR at line 1:
ORA-20000: Could not find both snapshot IDs
```
1. (Opzionale)
Per recuperare il report, chiamare le procedure del file di traccia, come spiegato in [Utilizzo di file di traccia Oracle](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Concepts.Oracle.WorkingWithTracefiles).
In alternativa, scaricare il report Statspack dalla console RDS. Vai alla sezione **Log** dei dettagli dell’istanza database e scegli **Scarica**: Il seguente esempio mostra `trace/ORCL_spreport_1_2.lst`
![\[Mostra un elenco di file di log Oracle nella console RDS. Il seguente file di traccia è cerchiato: trace/ORCL_spreport_1_2.lst.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/statspack1.png)
Se si verifica un errore durante la generazione di un report, il motore di database utilizza le stesse convenzioni di denominazione di un report ma con estensione `.err`. Se, ad esempio, si verifica un errore durante la creazione di un report basato sugli snapshot 1 e 7 di Statspack, il file di report sarà denominato `ORCL_spreport_1_7.err`. È possibile scaricare il rapporto errori utilizzando le stesse tecniche di un report snapshot standard.
## Rimozione delle istantanee Statspack
Utilizza il seguente comando per rimuovere un intervallo di istantanee Statspack:
```
exec statspack.purge(begin snap, end snap);
```
# Fuso orario Oracle
Per modificare il fuso orario del sistema utilizzato dall'istanza database Oracle, utilizzare l'opsione del fuso orario. Ad esempio, potrebbe essere necessario modificare il fuso orario di un'istanza di database in modo che sia compatibile con un ambiente locale o con un'applicazione legacy. L'opzione del fuso orario modifica il fuso orario a livello di host. La modifica del fuso orario influisce su tutti i valori e su tutte le colonne della data, inclusi `SYSDATE` e `SYSTIMESTAMP`.
L'opzione del fuso orario è diversa dal comando `rdsadmin_util.alter_db_time_zone`. Il comando `alter_db_time_zone` modifica il fuso orario solo per determinati tipi di dati. L'opzione del fuso orario modifica il fuso orario per tutte le colonne e i valori della data. Per ulteriori informazioni su `alter_db_time_zone`, consulta [Impostazione del fuso orario del database](Appendix.Oracle.CommonDBATasks.TimeZoneSupport.md). Per ulteriori informazioni sulle considerazioni per l'aggiornamento, consulta [Considerazioni sul fuso orario](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.DST).
## Restrizioni per l’impostazione del fuso orario
L'opzione del fuso orario è permanente e persistente. Pertanto, non è possibile completare le seguenti operazioni:
+ Rimuovi l’opzione da un gruppo di opzioni dopo aver aggiunto l’opzione di fuso orario.
+ Non è possibile eliminare il gruppo di opzioni da un'istanza database dopo averlo aggiunto.
+ Non è possibile sostituire l'impostazione del fuso orario dell'opzione con un altro fuso orario.
## Raccomandazioni per l’impostazione del fuso orario
Prima di aggiungere l'opzione del fuso orario al database di produzione, si consiglia vivamente di procedere come segue:
+ Acquisisci uno snapshot dell'istanza database. Se imposti accidentalmente il fuso orario in modo errato, dovrai ripristinare l'istanza database alle impostazioni del fuso orario precedente. Per ulteriori informazioni, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
+ Aggiungi l'opzione del fuso orario a un'istanza database di prova. L'aggiunta dell'opzione del fuso orario può causare problemi con le tabelle che utilizzano la data di sistema per aggiungere date o orari. Analizza i dati e le applicazioni dell’istanza di prova. In questo modo puoi valutare l’impatto della modifica del fuso orario sull’istanza di produzione.
Se l’istanza database utilizza il gruppo di opzioni predefinite, segui la procedura indicata di seguito:
1. Acquisisci uno snapshot dell'istanza database.
1. Aggiungi l'opzione del fuso orario all'istanza database.
Se l’istanza database al momento utilizza un gruppo di opzioni non predefinito, segui la procedura indicata di seguito:
1. Acquisisci uno snapshot dell'istanza database.
1. Crea un nuovo gruppo di opzioni.
1. Aggiungi l’opzione del fuso orario, insieme a tutte le altre opzioni attualmente associate al gruppo di opzioni esistente.
Ciò impedisce la disinstallazione delle opzioni esistenti mentre si abilita l’opzione del fuso orario.
1. Aggiungi il gruppo di opzioni all'istanza database.
## Impostazioni dell'opzione del fuso orario
Amazon RDS supporta le seguenti impostazioni per l'opzione del fuso orario.
****
| Impostazione opzioni | Valori validi | Descrizione |
| --- | --- | --- |
| `TIME_ZONE` | Uno dei fusi orari disponibili. Per l'elenco completo, consulta [Fusi orari disponibili](#Appendix.Oracle.Options.Timezone.Zones). | Il nuovo fuso orario per l'istanza di database. |
## Aggiunta dell'opzione del fuso orario
Completa la procedura seguente per aggiungere l’opzione del fuso orario all’istanza database:
1. Passaggio consigliato: acquisisci uno snapshot dell’istanza database.
1. Esegui una di queste attività:
+ Crea un nuovo gruppo di opzioni da zero. Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
+ Copia un gruppo di opzioni esistente utilizzando l'API AWS CLI o. Per ulteriori informazioni, consulta [Copia di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy).
+ Riutilizza un gruppo esistente di opzioni non predefinite. Una best practice consiste nell’utilizzare un gruppo di opzioni che non è attualmente associato ad alcuna snapshot o istanza database.
1. Aggiungi la nuova opzione al gruppo di opzioni del passaggio precedente.
1. Se il gruppo di opzioni attualmente associato all’istanza database ha delle opzioni abilitate, aggiungile al nuovo gruppo di opzioni. Questa strategia impedisce la disinstallazione delle opzioni esistenti mentre si abilita la nuova opzione.
1. Aggiungi il nuovo gruppo di opzioni all’istanza database.
Quando aggiungi l'opzione del fuso orario, si verifica una breve interruzione mentre l'istanza di database viene automaticamente riavviata.
### Console
**Per aggiungere l’opzione di fuso orario a un gruppo di opzioni e associarla all’istanza database**
1. Nella console RDS, scegli **Gruppi di opzioni**.
1. Scegli il nome del gruppo di opzioni a cui vuoi aggiungere l’opzione.
1. Scegliere **Add option (Aggiungi opzione)**.
1. Per **Nome opzione**, scegli **Fuso orario**, quindi configura le impostazioni dell’opzione.
1. Associa il gruppo di opzioni a un’istanza database nuova o esistente:
+ Per una nuova istanza database, applicare il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, applicare il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Quando aggiungi la nuova opzione a un’istanza database esistente, si verifica una breve interruzione mentre l’istanza database viene riavviata automaticamente. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### AWS CLI
L'esempio seguente utilizza il comando AWS CLI [add-option-to-option-group](https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html) per aggiungere l'`Timezone`opzione e l'impostazione dell'`TIME_ZONE`opzione a un gruppo di opzioni chiamato`myoptiongroup`. Il fuso orario è impostato su `Africa/Cairo`.
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=Timezone,OptionSettings=[{Name=TIME_ZONE,Value=Africa/Cairo}]" \
--apply-immediately
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=Timezone,OptionSettings=[{Name=TIME_ZONE,Value=Africa/Cairo}]" ^
--apply-immediately
```
## Modifica delle impostazioni del fuso orario
L'opzione del fuso orario è permanente e persistente. Non è possibile rimuovere l'opzione da un gruppo di opzioni dopo averla aggiunta. Non è possibile eliminare il gruppo di opzioni da un'istanza di database dopo averlo aggiunto. Non è possibile sostituire l'impostazione del fuso orario dell'opzione con un altro fuso orario. Se imposti il fuso orario in modo errato, ripristina uno snapshot dell'istanza di database precedente all'aggiunta dell'opzione del fuso orario.
## Rimozione dell'opzione del fuso orario
L'opzione del fuso orario è permanente e persistente. Non è possibile rimuovere l'opzione da un gruppo di opzioni dopo averla aggiunta. Non è possibile eliminare il gruppo di opzioni da un'istanza di database dopo averlo aggiunto. Per rimuovere l'opzione del fuso orario, ripristina uno snapshot dell'istanza di database precedente all'aggiunta dell'opzione del fuso orario.
## Fusi orari disponibili
È possibile utilizzare i seguenti valori per l'opzione del fuso orario.
****
| Zona | Time zone (Fuso orario) |
| --- | --- |
| Africa | Africa/Cairo, Africa/Casablanca, Africa/Harare, Africa/Lagos, Africa/Luanda, Africa/Monrovia, Africa/Nairobi, Africa/Tripoli, Africa/Windhoek |
| America | America/Araguaina, America/Argentina/Buenos\$1Aires, America/Asuncion, America/Bogota, America/Caracas, America/Chicago, America/Chihuahua, America/Cuiaba, America/Denver, America/Detroit, America/Fortaleza, America/Godthab, America/Guatemala, America/Halifax, America/Lima, America/Los\$1Angeles, America/Manaus, America/Matamoros, America/Mexico\$1City, America/Monterrey, America/Montevideo, America/New\$1York, America/Phoenix, America/Santiago, America/Sao\$1Paulo, America/Tijuana, America/Toronto |
| Asia | Asia/Amman, Asia/Ashgabat, Asia/Baghdad, Asia/Baku, Asia/Bangkok, Asia/Beirut, Asia/Calcutta, Asia/Damascus, Asia/Dhaka, Asia/Hong\$1Kong, Asia/Irkutsk, Asia/Jakarta, Asia/Jerusalem, Asia/Kabul, Asia/Karachi, Asia/Kathmandu, Asia/Kolkata, Asia/Krasnoyarsk, Asia/Magadan, Asia/Manila, Asia/Muscat, Asia/Novosibirsk, Asia/Rangoon, Asia/Riyadh, Asia/Seoul, Asia/Shanghai, Asia/Singapore, Asia/Taipei, Asia/Tehran, Asia/Tokyo, Asia/Ulaanbaatar, Asia/Vladivostok, Asia/Yakutsk, Asia/Yerevan |
| Atlantico | Atlantic/Azores, Atlantic/Cape\$1Verde |
| Australia | Australia/Adelaide, Australia/Brisbane, Australia/Darwin, Australia/Eucla, Australia/Hobart, Australia/Lord\$1Howe, Australia/Perth, Australia/Sydney |
| Brasile | Brazil/DeNoronha, Brazil/East |
| Canada | Canada/Newfoundland, Canada/Saskatchewan |
| ecc | Ecc./GMT-3 |
| Europa | Europe/Amsterdam, Europe/Athens, Europe/Berlin, Europe/Dublin, Europe/Helsinki, Europe/Kaliningrad, Europe/London, Europe/Madrid, Europe/Moscow, Europe/Paris, Europe/Prague, Europe/Rome, Europe/Sarajevo |
| Pacifico | Pacific/Apia, Pacific/Auckland, Pacific/Chatham, Pacific/Fiji, Pacific/Guam, Pacific/Honolulu, Pacific/Kiritimati, Pacific/Marquesas, Pacific/Samoa, Pacific/Tongatapu, Pacific/Wake |
| US | US/Alaska, US/Central, US/East-Indiana, US/Eastern, US/Pacific |
| UTC | UTC |
# Aggiornamento automatico dei file di fuso orario Oracle
Con l’opzione `TIMEZONE_FILE_AUTOUPGRADE`, è possibile aggiornare il file di fuso orario corrente alla versione più recente dell’istanza database RDS per Oracle.
**Topics**
+ [Panoramica dei file di fuso orario di Oracle](Appendix.Oracle.Options.Timezone-file-autoupgrade.tz-overview.md)
+ [Strategie per aggiornare il file del fuso orario](Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.md)
+ [Tempo di inattività durante l'aggiornamento del file di fuso orario](Appendix.Oracle.Options.Timezone-file-autoupgrade.considerations.md)
+ [Preparazione all'aggiornamento del file di fuso orario](Appendix.Oracle.Options.Timezone-file-autoupgrade.preparing.md)
+ [Aggiunta dell'opzione di aggiornamento automatico del file di fuso orario](Appendix.Oracle.Options.Timezone-file-autoupgrade.adding.md)
+ [Controllo dei dati dopo l'aggiornamento del file di fuso orario](Appendix.Oracle.Options.Timezone-file-autoupgrade.checking.md)
# Panoramica dei file di fuso orario di Oracle
Un *file di fuso orario* di Oracle Database include le seguenti informazioni:
+ Differenza rispetto all'ora UTC (Coordinated Universal Time)
+ Tempi di transizione per l'ora legale
+ Abbreviazioni per ora standard e ora legale
Oracle Database fornisce più versioni dei file di fuso orario. Quando si crea un database Oracle in un ambiente On-Premise, si sceglie la versione del file di fuso orario. Per ulteriori informazioni, consulta [Choosing a Time Zone File](https://docs.oracle.com/en/database/oracle/oracle-database/19/nlspg/datetime-data-types-and-time-zone-support.html#GUID-805AB986-DE12-4FEA-AF56-5AABCD2132DF) (Scelta di un file di fuso orario) in *Oracle Database Globalization Support Guide* (Guida al supporto per la globalizzazione di Oracle Database).
Se le regole per l'ora legale cambiano, Oracle pubblica nuovi file di fuso orario e Oracle rilascia questi nuovi file di fuso orario indipendentemente dalla pianificazione delle revisioni trimestrali Release Updates (RUs) e Release Update (). RURs I file del fuso orario si trovano sull'host del database nella directory `$ORACLE_HOME/oracore/zoneinfo/`. I nomi dei file del fuso orario utilizzano il formato DSTv*version*, ad esempio. DSTv35
## In che modo il file di fuso orario influisce sul trasferimento dei dati
In Oracle Database, il tipo di dati `TIMESTAMP WITH TIME ZONE` memorizza i dati di timestamp e fuso orario. Dati con il tipo di dati `TIMESTAMP WITH TIME ZONE` utilizzano le regole nella versione del file di fuso orario associato. L’aggiornamento del file di fuso orario pertanto influisce sui dati `TIMESTAMP WITH TIME ZONE` esistenti.
Possono verificarsi problemi quando si trasferiscono i dati tra database che utilizzano versioni diverse del file del fuso orario. Se, ad esempio, importi i dati da un database di origine con una versione di file di fuso orario superiore a quella del database di destinazione, viene visualizzato l’errore `ORA-39405` relativo a problemi con il database. In precedenza si ovviava all'errore utilizzando una delle seguenti tecniche:
+ Crea un'istanza database RDS per Oracle con il file di fuso orario desiderato, esporta i dati dal database di origine e quindi importali nel nuovo database.
+ Utilizza AWS DMS o la replica logica per migrare i dati.
## Aggiornamenti automatici con l'opzione TIMEZONE\$1FILE\$1AUTOUPGRADE
Quando il gruppo di opzioni collegato all’istanza database di RDS per Oracle include l’opzione `TIMEZONE_FILE_AUTOUPGRADE`, RDS aggiorna automaticamente i file del fuso orario. Assicurandoti che i database Oracle utilizzino la stessa versione del file di fuso orario, eviti tecniche manuali e dispendiose in termini di tempo per spostare i dati tra ambienti diversi. L'`TIMEZONE_FILE_AUTOUPGRADE`opzione è supportata sia per i database container (CDBs) che per quelli non-. CDBs
Quando aggiungi l'opzione `TIMEZONE_FILE_AUTOUPGRADE` al gruppo di opzioni, puoi scegliere se aggiungerla immediatamente o durante la finestra di manutenzione. Dopo che l'istanza DB ha applicato la nuova opzione, RDS verifica se è possibile installare un file più recente. DSTv *version* L'obiettivo DSTv *version* dipende da quanto segue:
+ La versione secondaria del motore attualmente in esecuzione sulla tua istanza database
+ La versione secondaria del motore a cui desideri aggiornare la tua istanza database
Ad esempio, la versione corrente del file del fuso orario potrebbe essere DSTv33. Quando RDS applica l'aggiornamento al gruppo di opzioni, potrebbe determinare che DSTv34 è attualmente disponibile nel file system dell'istanza DB. RDS aggiornerà quindi automaticamente il file del fuso orario. DSTv34
Per trovare le versioni dell'ora legale disponibili negli aggiornamenti di rilascio RDS supportati, consulta le patch nelle [Note di rilascio per Amazon Relational Database Service (Amazon RDS) per Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html). Ad esempio, la [versione 19.0.0.0.ru-2022-10.rur-2022-10.r1 elenca la patch 34533061](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2022-10.rur-2022-10.r1): RDBMS - UPDATE - C. DSTV39 TZDATA2022
# Strategie per aggiornare il file del fuso orario
L’aggiornamento del motore database e l’aggiunta dell’opzione `TIMEZONE_FILE_AUTOUPGRADE` a un gruppo di opzioni sono operazioni separate. L’aggiunta dell’opzione `TIMEZONE_FILE_AUTOUPGRADE` avvia l’aggiornamento del file di fuso orario se ne è disponibile uno più recente. I seguenti comandi vengono eseguiti (vengono visualizzate solo le opzioni pertinenti) immediatamente oppure nella finestra di manutenzione successiva:
+ Aggiorna il motore database solo utilizzando il seguente comando dell’interfaccia CLI RDS:
```
modify-db-instance --engine-version name ...
```
+ Aggiungi l’opzione`TIMEZONE_FILE_AUTOUPGRADE` solo utilizzando il seguente comando dell’interfaccia CLI:
```
add-option-to-option-group --option-group-name name --options OptionName=TIMEZONE_FILE_AUTOUPGRADE ...
```
+ Aggiorna il motore database e aggiungi un nuovo gruppo di opzioni all’istanza utilizzando il seguente comando dell’interfaccia CLI:
```
modify-db-instance --engine-version name --option-group-name name ...
```
La strategia di aggiornamento varia a seconda se desideri aggiornare contemporaneamente il database e il file di fuso orario oppure eseguire solo una di queste operazioni. Tieni presente che se aggiorni il gruppo di opzioni e successivamente aggiorni il motore database utilizzando operazioni API separate, è possibile che l’aggiornamento del file del fuso orario sia in esecuzione mentre aggiorni il motore database.
Per gli esempi in questa sezione si assume quanto riportato di seguito:
+ Non hai ancora aggiunto `TIMEZONE_FILE_AUTOUPGRADE` al gruppo di opzioni associato all’istanza database.
+ L'istanza DB utilizza la versione del database 19.0.0.0.ru-2019-07.rur-2019-07.r1 e il file del fuso orario. DSTv33
+ Il file system dell'istanza DB include il file. DSTv34
+ L'aggiornamento di rilascio 19.0.0.0.ru-2022-10.rur-2022-10.r1 include. DSTv35
Per aggiornare il file di fuso orario, è possibile utilizzare le seguenti strategie.
**Topics**
+ [Aggiornamento del file di fuso orario senza aggiornare il motore](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.no-upgrade)
+ [Aggiornamento della versione del file del fuso e del motore di database](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.upgrade)
+ [Aggiornamento della versione del motore di database senza aggiornare il file del fuso orario](#Appendix.Oracle.Options.Timezone-file-autoupgrade.strategies.upgrade-only)
## Aggiornamento del file di fuso orario senza aggiornare il motore
In questo scenario, il database utilizza il file system dell'istanza DB, ma è disponibile. DSTv33 DSTv34 Desideri aggiornare il file del fuso orario utilizzato dall'istanza DB da DSTv33 a DSTv34, ma non vuoi aggiornare il tuo motore a una nuova versione secondaria, che include DSTv35.
In un comando `add-option-to-option-group`, aggiungi `TIMEZONE_FILE_AUTOUPGRADE` al gruppo di opzioni utilizzato dall’istanza database. Specifica se vuoi aggiungere l'opzione immediatamente o durante la finestra di manutenzione. Dopo aver applicato l’opzione `TIMEZONE_FILE_AUTOUPGRADE`, RDS effettua le seguenti operazioni:
1. Verifica la presenza di una nuova versione dell’ora legale.
1. Determina che DSTv34 è disponibile nel file system.
1. Aggiorna immediatamente il file di fuso orario.
## Aggiornamento della versione del file del fuso e del motore di database
In questo scenario, il database utilizza DSTv33, ma DSTv34 è disponibile nel file system dell'istanza DB. Desideri aggiornare il tuo motore DB alla versione secondaria 19.0.0.0.ru-2022-10.rur-2022-10.r1, che include e aggiorna il file del fuso orario durante l'aggiornamento del motore. DSTv35 DSTv35 Pertanto, il tuo obiettivo è saltare e aggiornare i file del fuso orario direttamente in. DSTv34 DSTv35
Per aggiornare contemporaneamente il motore e il file di fuso orario, esegui `modify-db-instance` con le opzioni `--option-group-name` e `--engine-version`. Puoi eseguire il comando immediatamente o durante la finestra di manutenzione. `In --option-group-name`, specifica un gruppo di opzioni che includa l’opzione `TIMEZONE_FILE_AUTOUPGRADE`. Esempio:
```
aws rds modify-db-instance
--db-instance-identifier my-instance \
--engine-version new-version \
----option-group-name og-with-timezone-file-autoupgrade \
--apply-immediately
```
RDS inizia ad aggiornare il motore alla versione 19.0.0.0.ru-2022-10.rur-2022-10.r1. Dopo aver applicato l'`TIMEZONE_FILE_AUTOUPGRADE`opzione, RDS verifica la presenza di una nuova versione DST, verifica che DSTv35 sia disponibile in 19.0.0.0.ru-2022-10.rur-2022-10.r1 e avvia immediatamente l'aggiornamento a. DSTv35
Per aggiornare immediatamente il motore e quindi aggiornare il file del fuso orario, esegui le operazioni in sequenza:
1. Aggiorna il tuo motore database solo utilizzando il seguente comando dell’interfaccia CLI:
```
aws rds modify-db-instance \
--db-instance-identifier my-instance \
--engine-version new-version \
--apply-immediately
```
1. Aggiungi l’opzione `TIMEZONE_FILE_AUTOUPGRADE` al gruppo di opzioni collegato all’istanza utilizzando il seguente comando dell’interfaccia CLI:
```
aws rds add-option-to-option-group \
--option-group-name og-in-use-by-your-instance \
--options OptionName=TIMEZONE_FILE_AUTOUPGRADE \
--apply-immediately
```
## Aggiornamento della versione del motore di database senza aggiornare il file del fuso orario
In questo scenario, il database utilizza il file system dell'istanza DB, ma è disponibile nel file system dell'istanza DB. DSTv33 DSTv34 Desiderate aggiornare il motore di database alla versione 19.0.0.0.ru-2022-10.rur-2022-10.r1, che include ma mantiene il file del fuso orario. DSTv35 DSTv33 Puoi scegliere questa strategia per i seguenti motivi:
+ I tuoi dati non utilizzano il tipo di dati `TIMESTAMP WITH TIME ZONE`.
+ I tuoi dati utilizzano il tipo di dati `TIMESTAMP WITH TIME ZONE`, ma i dati non sono interessati dalle modifiche del fuso orario.
+ Si desidera posticipare l'aggiornamento del file di fuso orario perché non è possibile tollerare il tempo di inattività aggiuntivo.
La strategia dipende da quale delle seguenti condizioni sono vere:
+ L'istanza database non è associata a un gruppo di opzioni che include `TIMEZONE_FILE_AUTOUPGRADE`. Nel comando `modify-db-instance` non specificare un nuovo gruppo di opzioni in modo che RDS non aggiorni il file di fuso orario.
+ L’istanza database è attualmente associata a un gruppo di opzioni che include `TIMEZONE_FILE_AUTOUPGRADE`. In un unico comando `modify-db-instance`, associa l’istanza database a un gruppo di opzioni che non include `TIMEZONE_FILE_AUTOUPGRADE` e aggiorna il motore database a 19.0.0.0.ru-2022-10.rur-2022-10.r1.
# Tempo di inattività durante l'aggiornamento del file di fuso orario
Quando RDS aggiorna il file di fuso orario, i dati che utilizzano `TIMESTAMP WITH TIME ZONE` potrebbero cambiare e in questo caso, è opportuno tenere in considerazione il tempo di inattività.
**avvertimento**
Se aggiungi l'opzione `TIMEZONE_FILE_AUTOUPGRADE`, l'aggiornamento del motore potrebbe avere tempi di inattività prolungati. L'aggiornamento dei dati del fuso orario per un database di grandi dimensioni potrebbe richiedere ore o addirittura giorni.
La durata dell'aggiornamento del file di fuso orario dipende da fattori come i seguenti:
+ La quantità di dati `TIMESTAMP WITH TIME ZONE` nel database
+ La configurazione dell'istanza database
+ La classe dell’istanza database
+ La configurazione dell’archivio
+ La configurazione del database
+ Le impostazioni dei parametri di database
Possono verificarsi ulteriori tempi di inattività quando si eseguono le seguenti operazioni:
+ Aggiungere l'opzione al gruppo di opzioni quando l'istanza database utilizza un file di fuso orario non aggiornato
+ Aggiornare il modulo di gestione di database Oracle quando la nuova versione del motore contiene una nuova versione del file di fuso orario
**Nota**
Durante l'aggiornamento del file di fuso orario, RDS per Oracle chiama `PURGE DBA_RECYCLEBIN`.
# Preparazione all'aggiornamento del file di fuso orario
L'aggiornamento di un file di fuso orario prevede due fasi distinte: preparazione e aggiornamento. Anche se non richiesto, è fortemente consigliabile eseguire la fase di preparazione. In questo passaggio, scopri quali dati saranno interessati dall'esecuzione della PL/SQL procedura`DBMS_DST.FIND_AFFECTED_TABLES`. Per ulteriori informazioni sulla finestra di preparazione, consulta [Aggiornamento del file di fuso orario e del timestamp con dati di fuso orario](https://docs.oracle.com/en/database/oracle/oracle-database/19/nlspg/datetime-data-types-and-time-zone-support.html#GUID-B0ACDB2E-4B49-4EB4-B4CC-9260DAE1567A) nella documentazione di Oracle Database.
**Per preparare l'aggiornamento del file di fuso orario**
1. Connettersi al database Oracle usando un client SQL.
1. Determinare la versione corrente del file di fuso orario utilizzata.
```
SELECT * FROM V$TIMEZONE_FILE;
```
1. Determinare la versione più recente del file di fuso orario disponibile nell'istanza database.
```
SELECT DBMS_DST.GET_LATEST_TIMEZONE_VERSION FROM DUAL;
```
1. Determinare la dimensione totale delle tabelle con colonne di tipo `TIMESTAMP WITH LOCAL TIME ZONE` o `TIMESTAMP WITH TIME ZONE`.
```
SELECT SUM(BYTES)/1024/1024/1024 "Total_size_w_TSTZ_columns_GB"
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE 'TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE LIKE 'TIMESTAMP%TIME ZONE');
```
1. Determinare i nomi e le dimensioni dei segmenti con colonne di tipo `TIMESTAMP WITH LOCAL TIME ZONE` o `TIMESTAMP WITH TIME ZONE`.
```
SELECT OWNER, SEGMENT_NAME, SUM(BYTES)/1024/1024/1024 "SEGMENT_SIZE_W_TSTZ_COLUMNS_GB"
FROM DBA_SEGMENTS
WHERE SEGMENT_TYPE LIKE 'TABLE%'
AND (OWNER, SEGMENT_NAME) IN
(SELECT OWNER, TABLE_NAME
FROM DBA_TAB_COLUMNS
WHERE DATA_TYPE LIKE 'TIMESTAMP%TIME ZONE')
GROUP BY OWNER, SEGMENT_NAME;
```
1. Eseguire la fase di preparazione.
+ La procedura `DBMS_DST.CREATE_AFFECTED_TABLE` crea una tabella per l'archiviazione dei dati interessati. Passare il nome di questa tabella alla procedura `DBMS_DST.FIND_AFFECTED_TABLES`. Per ulteriori informazioni, consulta [Procedura CREATE\$1AFFECTED\$1TABLE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-C53BAABA-914A-404C-9CD5-823257BE0B00) nella documentazione del database Oracle.
+ La procedura `CREATE_ERROR_TABLE` crea una tabella per registrare gli errori. Per ulteriori informazioni, consulta [Procedura CREATE\$1ERROR\$1TABLE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-6A7EA024-B02D-4486-B1D6-EF6ABF5DE507) nella documentazione del database Oracle.
Nell'esempio seguente vengono create le tabelle dei dati e degli errori interessati e vengono trovate tutte le tabelle interessate.
```
EXEC DBMS_DST.CREATE_ERROR_TABLE('my_error_table')
EXEC DBMS_DST.CREATE_AFFECTED_TABLE('my_affected_table')
EXEC DBMS_DST.BEGIN_PREPARE(new_version);
EXEC DBMS_DST.FIND_AFFECTED_TABLES('my_affected_table', TRUE, 'my_error_table');
EXEC DBMS_DST.END_PREPARE;
SELECT * FROM my_affected_table;
SELECT * FROM my_error_table;
```
1. Eseguire una query sulle tabelle interessate e di errore.
```
SELECT * FROM my_affected_table;
SELECT * FROM my_error_table;
```
# Aggiunta dell'opzione di aggiornamento automatico del file di fuso orario
Quando aggiungi l'opzione, il gruppo di opzioni si trova in una delle seguenti condizioni:
+ Un gruppo di opzioni esistente è attualmente collegato ad almeno un'istanza database. Quando aggiungi l'opzione, tutte le istanze database che utilizzano il gruppo di opzioni si riavviano automaticamente. Questo riavvio causa una breve interruzione.
+ Un gruppo di opzioni esistente non è collegato a un'istanza database. Dovrai aggiungere l'opzione e quindi associare il gruppo di opzioni esistente alle istanze database esistenti o a una nuova istanza database.
+ Crei un nuovo gruppo di opzioni e aggiungi l'opzione. Dovrai associare il nuovo gruppo di opzioni alle istanze database esistenti o a una nuova istanza database.
## Console
**Per aggiungere l'opzione del file di fuso orario a un'istanza di database**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione scegliere **Option groups (Gruppi di opzioni)**.
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. Per **Engine** (Motore), scegli la versione Oracle Database per l'istanza database.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Selezionare il gruppo di opzioni che si vuole modificare, quindi scegliere **Add Option (Aggiungi opzione)**.
1. Nella finestra **Add option (Aggiungi opzione)** eseguire queste operazioni:
1. Scegli **TIMEZONE\$1FILE\$1AUTOUPGRADE**.
1. Per abilitare l'opzione in tutte le istanze database associate non appena viene aggiunta, per **Apply Immediately (Applica immediatamente)** scegliere **Yes (Sì)**. Se si sceglie **No** (impostazione predefinita), l'opzione viene abilitata per ogni istanza database associata durante la finestra di manutenzione successiva.
1. Dopo aver selezionato le impostazioni desiderate, selezionare **Add Option (Aggiungi opzione)**.
## AWS CLI
L'esempio seguente utilizza il comando AWS CLI [add-option-to-option-group](https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html) per aggiungere l'`TIMEZONE_FILE_AUTOUPGRADE`opzione a un gruppo di opzioni chiamato. `myoptiongroup`
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=TIMEZONE_FILE_AUTOUPGRADE" \
--apply-immediately
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=TIMEZONE_FILE_AUTOUPGRADE" ^
--apply-immediately
```
# Controllo dei dati dopo l'aggiornamento del file di fuso orario
Si consiglia di controllare i dati dopo aver aggiornato il file del fuso orario. Durante la fase di preparazione, RDS per Oracle crea automaticamente le tabelle riportate di seguito:
+ `rdsadmin.rds_dst_affected_tables` – Elenca le tabelle che contengono dati interessati dall'aggiornamento
+ `rdsadmin.rds_dst_error_table` – Elenca gli errori generati durante l'aggiornamento
Queste tabelle sono indipendenti da tutte le tabelle create nella finestra di preparazione. Per visualizzare i risultati dell'aggiornamento, eseguire una query sulle tabelle come indicato di seguito.
```
SELECT * FROM rdsadmin.rds_dst_affected_tables;
SELECT * FROM rdsadmin.rds_dst_error_table;
```
Per ulteriori informazioni sullo schema per i dati interessati e le tabelle di errore, consulta [Procedura FIND\$1AFFECTED\$1TABLE](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_DST.html#GUID-1F977505-671C-4D5B-8570-86956F136199) nella documentazione Oracle.
# Oracle Transparent Data Encryption
Amazon RDS supporta Oracle Transparent Data Encryption (TDE), una caratteristica dell'opzione Oracle Advanced Security disponibile in Oracle Enterprise Edition. Tale caratteristica consente la crittografia automatica dei dati prima che vengano trascritti nello storage e la loro decriptazione automatica durante la lettura dallo storage. Questa opzione è supportata solo per il modello per uso di licenze proprie (BYOL).
TDE è utile negli scenari in cui è necessario crittografare dati sensibili se i file di dati e i backup si ottengono da una terza parte. TDE è utile anche quando è necessario rispettare le normative relative alla sicurezza.
Una spiegazione dettagliata di TDE in Oracle Database esula dallo scopo di questa guida. Per informazioni, consulta le seguenti risorse di Oracle Database:
+ [Introduction to Transparent Data Encryption](https://docs.oracle.com/en/database/oracle/oracle-database/19/asoag/introduction-to-transparent-data-encryption.html#GUID-62AA9447-FDCD-4A4C-B563-32DE04D55952) nella documentazione di Oracle Database
+ [Oracle advanced security](https://www.oracle.com/security/database-security/) nella documentazione di Oracle Database
+ [Oracle advanced security Transparent Data Encryption best practices](https://www.oracle.com/br/a/tech/docs/technical-resources/twp-transparent-data-encryption-bestpractices.pdf) che è un whitepaper di Oracle
Per ulteriori informazioni sull’utilizzo di TDE con RDS per Oracle, consulta i seguenti blog:
+ [Oracle Database Encryption Options on Amazon RDS](https://aws.amazon.com/blogs/apn/oracle-database-encryption-options-on-amazon-rds/)
+ [Esegui la migrazione di un'istanza DB Amazon RDS for Oracle compatibile con TDE su più account con tempi di inattività ridotti utilizzando AWS DMS](https://aws.amazon.com/blogs/database/migrate-a-cross-account-tde-enabled-amazon-rds-for-oracle-db-instance-with-reduced-downtime-using-aws-dms/)
## Modalità di crittografia di TDE
Oracle Transparent Data Encryption supporta due modalità di crittografia: la crittografia TDE degli spazi tabelle e la crittografia TDE delle colonne. La crittografia TDE degli spazi tabelle si utilizza per crittografare intere tabelle di un'applicazione. La crittografia TDE delle colonne si utilizza per crittografare singole informazioni che contengono dati sensibili. Puoi anche applicare una soluzione di crittografia ibrida che utilizza sia la codifica TDE degli spazi tabelle che quella delle colonne.
**Nota**
Amazon RDS gestisce Oracle Wallet e la chiave principale di TDE per l'istanza database. Non dovrai impostare la chiave crittografica con il comando `ALTER SYSTEM set encryption key`.
Una volta abilitata l’opzione `TDE`, puoi verificare lo stato di Oracle Wallet utilizzando il comando seguente:
```
SELECT * FROM v$encryption_wallet;
```
Per creare uno spazio tabelle crittografato, utilizza il comando seguente:
```
CREATE TABLESPACE encrypt_ts ENCRYPTION DEFAULT STORAGE (ENCRYPT);
```
Utilizza il comando seguente per specificare l'algoritmo di crittografia:
```
CREATE TABLESPACE encrypt_ts ENCRYPTION USING 'AES256' DEFAULT STORAGE (ENCRYPT);
```
Le istruzioni precedenti per la crittografia di un tablespace sono le stesse che utilizzeresti su un database Oracle on-premises.
## Restrizioni per l’opzione TDE
L’opzione TDE è permanente e persistente. Dopo aver associato l’istanza database a un gruppo di opzioni con l’opzione TDE abilitata, non puoi eseguire le azioni indicate di seguito:
+ Disabilita l’opzione `TDE` nel gruppo di opzioni attualmente associato.
+ Associa l’istanza database a un gruppo di opzioni diverso che non include l’opzione `TDE`.
+ Condividi uno snapshot di database che utilizza l’opzione `TDE`. Per ulteriori informazioni sulla condivisione di snapshot DB, consulta [Condivisione di uno snapshot DB per Amazon RDS](USER_ShareSnapshot.md).
Per ulteriori informazioni sulle opzioni persistenti e permanenti, consulta [Opzioni persistenti e permanenti](USER_WorkingWithOptionGroups.md#Overview.OptionGroups.Permanent).
## Determinare se l’istanza database utilizza TDE
Potresti voler stabilire se l’istanza database è associata a un gruppo di opzioni con l’opzione `TDE` abilitata. [Per visualizzare il gruppo di opzioni a cui è associata un'istanza DB, utilizza la console RDS, il [describe-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)AWS CLI comando o l'operazione API Descrivi. DBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html)
## Aggiunta dell’opzione TDE
Per rimuovere l’opzione `TDE` con un’istanza database, completa i passaggi seguenti.
1. Passaggio consigliato: acquisisci uno snapshot dell’istanza database.
1. Esegui una di queste attività:
+ Crea un nuovo gruppo di opzioni da zero. Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
+ Copia un gruppo di opzioni esistente utilizzando l'API AWS CLI or. Per ulteriori informazioni, consulta [Copia di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy).
+ Riutilizza un gruppo esistente di opzioni non predefinite. Una best practice consiste nell’utilizzare un gruppo di opzioni che non è attualmente associato ad alcuna snapshot o istanza database.
1. Aggiungi la nuova opzione al gruppo di opzioni del passaggio precedente.
1. Se il gruppo di opzioni attualmente associato all’istanza database ha delle opzioni abilitate, aggiungile al nuovo gruppo di opzioni. Questa strategia impedisce la disinstallazione delle opzioni esistenti mentre si abilita la nuova opzione.
1. Aggiungi il nuovo gruppo di opzioni all’istanza database.
### Console
**Per aggiungere l’opzione TDE a un gruppo di opzioni e associarla all’istanza database**
1. Nella console RDS, scegli **Gruppi di opzioni**.
1. Scegli il nome del gruppo di opzioni a cui vuoi aggiungere l’opzione.
1. Scegliere **Add option (Aggiungi opzione)**.
1. Per **Nome opzione**, scegli **TDE**, quindi configura le impostazioni dell’opzione.
1. Scegliere **Add option (Aggiungi opzione)**.
**Importante**
Se aggiungi l’opzione **TDE** a un gruppo di opzioni che è già associato a una o più istanze database, si verifica una breve interruzione mentre tutte le istanze database vengono riavviate automaticamente.
Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Associa il gruppo di opzioni a un’istanza database nuova o esistente:
+ Per una nuova istanza database, applicare il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, applicare il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. L’istanza database non viene riavviata come parte di questa operazione. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### AWS CLI
Nell'esempio seguente, utilizzate il comando AWS CLI [add-option-to-option-group](https://docs.aws.amazon.com/cli/latest/reference/rds/add-option-to-option-group.html) per aggiungere l'`TDE`opzione a un gruppo di opzioni chiamato`myoptiongroup`. Per ulteriori informazioni, consulta [Nozioni di base: Flink 1.13.2](https://docs.aws.amazon.com/managed-flink/latest/java/earlier.html#getting-started-1-13).
Per Linux, macOS o Unix:
```
aws rds add-option-to-option-group \
--option-group-name "myoptiongroup" \
--options "OptionName=TDE" \
--apply-immediately
```
Per Windows:
```
aws rds add-option-to-option-group ^
--option-group-name "myoptiongroup" ^
--options "OptionName=TDE" ^
--apply-immediately
```
## Copia i dati in un’istanza database che non include l’opzione TDE
Non puoi rimuovere l’opzione TDE da un’istanza database né associarla a un gruppo di opzioni che non comprenda l’opzione TDE. Per migrare i dati su un’istanza che non include l’opzione TDE, procedi come segue:
1. Decrittografa tutti i dati sull’istanza database.
1. Copia i dati in una nuova istanza database non associata a un gruppo di opzioni con l’opzione `TDE` abilitata.
1. Elimina l’istanza database originale.
Per la nuova istanza, puoi utilizzare lo stesso nome dell’istanza database precedente.
## Considerazioni sull’utilizzo di TDE con Oracle Data Pump
Puoi utilizzare Oracle Data Pump per importare o esportare file dump crittografati. Amazon RDS supporta la modalità di crittografia delle password `(ENCRYPTION_MODE=PASSWORD)` per Oracle Data Pump. Amazon RDS non supporta la modalità di crittografia trasparente `(ENCRYPTION_MODE=TRANSPARENT)` per Oracle Data Pump. Per ulteriori informazioni, consulta [Importazione utilizzando Oracle Data Pump](Oracle.Procedural.Importing.DataPump.md).
# UTL\$1MAIL di Oracle
Amazon RDS supporta UTL\$1MAIL di Oracle attraverso l'uso dell'opzione UTL\$1MAIL e di server SMTP. Puoi inviare un messaggio e-mail direttamente dal database usando il pacchetto UTL\$1MAIL. Amazon RDS supporta UTL\$1MAIL per le seguenti versioni di Oracle:
+ Oracle Database 21c (21.0.0.0), tutte le versioni
+ Oracle Database 19c (19.0.0.0), tutte le versioni
Di seguito trovi alcune delle limitazioni all'utilizzo di UTL\$1MAIL:
+ UTL\$1MAIL non supporta il protocollo Transport Layer Security (TLS) e le e-mail non vengono pertanto crittografate.
Per connetterti in modo sicuro a risorse SSL/TLS remote creando e caricando wallet Oracle personalizzati, segui le istruzioni in [Configurazione dell'accesso UTL\$1HTTP utilizzando certificati e un portafoglio Oracle](Oracle.Concepts.ONA.md).
I certificati specifici necessari per il wallet variano in base al servizio. Per i servizi AWS, sono in genere disponibili nel [repository di Amazon Trust Services](https://www.amazontrust.com/repository/).
+ UTL\$1MAIL non supporta l'autenticazione con i server SMTP.
+ È possibile inviare un solo allegato in una e-mail.
+ Non è possibile inviare allegati di dimensioni maggiori di 32 K.
+ È possibile utilizzare solo le codifiche di caratteri ASCII ed EBCDIC (Extended Binary Coded Decimal Interchange Code).
+ La porta SMTP (25) è soggetta a throttling in base alle policy del proprietario dell'interfaccia di rete elastica.
Quando abiliti UTL\$1MAIL, il privilegio di esecuzione è concesso solo all'utente master dell'istanza database. Se necessario, l'utente master può concedere il privilegio di esecuzione ad altri utenti, per consentire loro di utilizzare UTL\$1MAIL.
**Importante**
Ti consigliamo di abilitare la funzionalità di controllo integrata di Oracle per tenere traccia dell'utilizzo delle procedure di UTL\$1MAIL.
## Prerequisiti per UTL\$1MAIL di Oracle
Di seguito sono indicati i prerequisiti per l'utilizzo di UTL\$1MAIL di Oracle:
+ Uno o più server SMTP e i corrispondenti indirizzi IP o nomi DNS (Domain Name Server) pubblici o privati. Per ulteriori informazioni sui nomi DNS privati risolti tramite un server DNS personalizzato, consulta [Impostazione di un server DNS personalizzato](Appendix.Oracle.CommonDBATasks.System.md#Appendix.Oracle.CommonDBATasks.CustomDNS).
## Aggiunta dell'opzione UTL\$1MAIL di Oracle
La procedura generale per aggiungere l'opzione UTL\$1MAIL di Oracle a un'istanza database è la seguente:
1. Creare un nuovo gruppo di opzioni oppure copiare o modificare un gruppo di opzioni esistente.
1. Aggiungere l'opzione al gruppo di opzioni.
1. Associare il gruppo di opzioni a questa istanza database.
Dopo essere stata aggiunta, l'opzione UTL\$1MAIL diventa attiva non appena il gruppo di opzioni è attivo.
**Per aggiungere l'opzione UTL\$1MAIL a un'istanza database**
1. Determinare il gruppo di opzioni che si desidera usare. È possibile creare un nuovo gruppo di opzioni oppure usare un gruppo di opzioni esistente. Se si desidera usare un gruppo di opzioni esistente, puoi passare alla fase successiva. In caso contrario, creare un gruppo di opzioni database personalizzato con le seguenti impostazioni:
1. In **Engine (Motore)** scegliere l'edizione di Oracle che si desidera utilizzare.
1. In **Major engine version (Versione principale del motore)**, scegliere la versione dell'istanza database.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Aggiungere l'opzione **UTL\$1MAIL** al gruppo di opzioni. Per ulteriori informazioni sull'aggiunta di opzioni, consulta [Aggiunta di un'opzione a un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption).
1. Applicare il gruppo di opzioni a un'istanza database nuova o esistente:
+ Per una nuova istanza database, si applica il gruppo di opzioni quando viene avviata l'istanza. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
+ Per un'istanza database esistente, viene applicato il gruppo di opzioni modificando l'istanza e collegando il nuovo gruppo di opzioni. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Utilizzo di UTL\$1MAIL di Oracle
Dopo aver abilitato l'opzione UTL\$1MAIL, dovrai configurare il server SMTP per poter iniziare a utilizzarlo.
Per configurare il server SMTP, è necessario impostare il parametro SMTP\$1OUT\$1SERVER su un indirizzo IP o un nome DNS pubblico valido. Per il parametro SMTP\$1OUT\$1SERVER, puoi specificare un elenco separato da virgole di indirizzi di più server. Se il primo server non è disponibile, UTL\$1MAIL prova a utilizzare il server successivo e così via.
È possibile impostare il parametro SMTP\$1OUT\$1SERVER predefinito per un'istanza database utilizzando un [gruppo di parametri database](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html). Puoi impostare il parametro SMTP\$1OUT\$1SERVER per una sessione eseguendo il codice riportato di seguito sul database nell'istanza database.
```
1. ALTER SESSION SET smtp_out_server = mailserver.domain.com:25;
```
Quando l'opzione UTL\$1MAIL è abilitata e SMTP\$1OUT\$1SERVER è configurato, potrai inviare e-mail tramite la procedura `SEND`. Per ulteriori informazioni, consulta [UTL\$1MAIL](http://docs.oracle.com/cd/B19306_01/appdev.102/b14258/u_mail.htm#BABFJJBD) nella documentazione di Oracle.
## Rimozione dell'opzione UTL\$1MAIL di Oracle
È possibile rimuovere l'opzione UTL\$1MAIL di Oracle da un'istanza database.
Per rimuovere UTL\$1MAIL da un'istanza database, procedi in uno dei seguenti modi:
+ Per rimuovere l'opzione UTL\$1MAIL da più istanze database, rimuovila dal gruppo di opzioni a cui le istanze appartengono. Questa modifica coinvolge tutte le istanze database che usano il gruppo di opzioni. Per ulteriori informazioni, consulta [Rimozione di un'opzione da un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption).
+ Per rimuovere l'opzione UTL\$1MAIL da una singola istanza database, modifica l'istanza database e specifica un gruppo di opzioni diverso che non comprenda l'opzione UTL\$1MAIL. È possibile specificare il gruppo di opzioni predefinito (vuoto) o un gruppo di opzioni personalizzato diverso. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
## Risoluzione dei problemi
Di seguito sono elencati i problemi che si potrebbero riscontrare quando si utilizza UTL\$1MAIL con Amazon RDS.
+ Throttling. La porta SMTP (25) è soggetta a throttling in base alle policy del proprietario dell'interfaccia di rete elastica. Se riesci a inviare e-mail utilizzando UTL\$1MAIL e viene visualizzato l'errore `ORA-29278: SMTP transient error: 421 Service not available`, è possibile che sia in corso il throttling. Se la distribuzione di posta elettronica è soggetta a throttling, ti consigliamo di implementare un algoritmo di backoff. Per ulteriori informazioni sugli algoritmi di backoff, consulta [Ripetizione dei tentativi in caso di errore e backoff esponenziale in AWS](https://docs.aws.amazon.com/general/latest/gr/api-retries.html) e il post [Come gestire un errore di superamento della frequenza massima in uscita con conseguente throttling](https://aws.amazon.com/blogs/ses/how-to-handle-a-throttling-maximum-sending-rate-exceeded-error/).
È possibile richiedere che venga rimosso il throttling. Per ulteriori informazioni, leggi [Come rimuovere il throttling sulla porta 25 per l'istanza EC2](https://aws.amazon.com/premiumsupport/knowledge-center/ec2-port-25-throttle/).
# Oracle XML DB
Oracle XML DB aggiunge un supporto XML nativo all'istanza database. Con XML DB puoi archiviare e recuperare XML strutturato o non strutturato e dati relazionali. Il server del protocollo XML DB non è supportato su RDS per Oracle.
XML DB è preinstallato su Oracle Database 12c e versioni successive. Pertanto, non è necessario utilizzare un gruppo di opzioni per installare esplicitamente XML DB come funzionalità aggiuntiva.
Per informazioni su come configurare e utilizzare XML DB, consulta [Oracle XML DB Developer’s Guide](https://docs.oracle.com/en/database/oracle/oracle-database/19/adxdb/) nella documentazione di Oracle Database.
# Aggiornamento del motore di database RDS per Oracle
Quando Amazon RDS supporta una nuova versione di Oracle Database, puoi effettuare l'aggiornamento delle istanze database alla nuova versione. Per informazioni sulle versioni di Oracle disponibili in Amazon RDS, consulta le [https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html).
**Importante**
I database RDS per Oracle 11g, 12c e 18c non sono più supportati. Se sono stati conservati snapshot di database Oracle 11g, 12c o 18c, sarà possibile aggiornarli a una versione successiva. Per ulteriori informazioni, consulta [Aggiornamento di uno shapshot DB Oracle](USER_UpgradeDBSnapshot.Oracle.md).
**Topics**
+ [Panoramica sugli aggiornamenti del motore di database Oracle](USER_UpgradeDBInstance.Oracle.Overview.md)
+ [Aggiornamenti a una versione principale Oracle](USER_UpgradeDBInstance.Oracle.Major.md)
+ [Aggiornamenti a una versione secondaria Oracle](USER_UpgradeDBInstance.Oracle.Minor.md)
+ [Considerazioni sugli aggiornamenti per Oracle Database](USER_UpgradeDBInstance.Oracle.OGPG.md)
+ [Verifica di un aggiornamento del database Oracle](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md)
+ [Aggiornamento della versione di un’istanza database RDS per Oracle](USER_UpgradeDBInstance.Oracle.Upgrading.md)
+ [Aggiornamento di uno shapshot DB Oracle](USER_UpgradeDBSnapshot.Oracle.md)
# Panoramica sugli aggiornamenti del motore di database Oracle
Prima di aggiornare l’istanza database RDS per Oracle, prova a familiarizzare con i seguenti concetti chiave.
**Topics**
+ [Aggiornamenti delle versioni principali e secondarie](#USER_UpgradeDBInstance.Oracle.Overview.versions)
+ [Date di supporto e upgrade obbligatori per RDS per Oracle](#Aurora.VersionPolicy.MajorVersionLifetime)
+ [Gestione della versione del motore Oracle.](#Oracle.Concepts.Patching)
+ [Snapshot automatici durante gli aggiornamenti del motore](#USER_UpgradeDBInstance.Oracle.Overview.snapshots)
+ [Aggiornamenti Oracle in una implementazione multi-AZ](#USER_UpgradeDBInstance.Oracle.Overview.multi-az)
+ [Aggiornamenti Oracle delle repliche di lettura](#USER_UpgradeDBInstance.Oracle.Overview.read-replicas)
## Aggiornamenti delle versioni principali e secondarie
Le versioni principali sono versioni di Oracle Database che vengono rilasciate ogni 1-2 anni. Oracle Database 19c e Oracle Database 21c sono le versioni principali.
Ogni trimestre, RDS per Oracle rilascia nuove versioni secondarie per tutti i motori principali supportati. Una versione del motore Release Update (RU) incorpora le correzioni di bug di Oracle includendo le patch RU per il trimestre specificato. Ad esempio, 21.0.0.0.ru-2024-10.rur-2024-10.r1 è una versione secondaria di Oracle Database 21c che incorpora l’RU di ottobre 2024.
Una versione del motore Spatial Patch Bundle (SPB) contiene patch RU e patch specifiche di Oracle Spatial. Ad esempio, 19.0.0.0.ru-2025-01.spb-1.r1 è una versione secondaria del motore che contiene le patch RU della versione del motore 19.0.0.0.ru-2025-01.rur-2025-01.r1 e le patch di Spatial. In genere, RDS for Oracle viene rilasciato SPBs 2—3 settimane dopo la RU corrispondente. Per una spiegazione delle differenze tra RUs e SPBs, vedere. [Release Updates (RUs) e Spatial Patch Bundles () SPBs](USER_UpgradeDBInstance.Oracle.Minor.md#RUs-and-SPBs) Per informazioni sui supporti RUs e SPBs, consulta le [note di rilascio per Amazon Relational Database Service (Amazon RDS)](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes) per Oracle.
RDS per Oracle supporta i seguenti aggiornamenti a un’istanza database.
| Tipo di aggiornamento | Compatibilità delle applicazioni | Metodi di aggiornamento | Percorso di aggiornamento di esempio |
| --- | --- | --- | --- |
| Versione principale | Un aggiornamento della versione principale può introdurre modifiche che non sono compatibili con le applicazioni esistenti. | Solo manuale | Da Oracle Database 19c a Oracle Database 21c |
| Versione secondaria | Un aggiornamento della versione secondaria include solo modifiche compatibili con le versioni precedenti delle applicazioni esistenti. | Automatico o manuale | Da 21.0.0.0.ru-2023-07.rur-2022-07.r1 a 21.0.0.0.ru-2023-10.rur-2022-10.r1 |
**Importante**
Quando aggiorni il motore database, si verifica un’interruzione. Il tempo di interruzione dipende dalla versione del motore e dalle dimensioni dell’istanza database.
Accertati di testare in modo approfondito qualsiasi aggiornamento per verificare che le tue applicazioni funzionino correttamente prima di applicare l’aggiornamento ai database di produzione. Per ulteriori informazioni, consulta [Verifica di un aggiornamento del database Oracle](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md).
## Date di supporto e upgrade obbligatori per RDS per Oracle
Le versioni database di RDS per Oracle hanno date di supporto previste. *Quando una versione principale o secondaria di un motore RDS for Oracle DB si avvicina alla data di scadenza, RDS avvia gli aggiornamenti obbligatori, noti anche come aggiornamenti forzati. end-of-support* RDS pubblica le seguenti informazioni:
+ Un consiglio per iniziare ad aggiornare manualmente le istanze dalle versioni obsolete alle versioni supportate
+ Una data dopo la quale non è più possibile creare istanze nelle versioni non supportate
+ Una data in cui RDS inizia ad aggiornare automaticamente le istanze alle versioni supportate durante le finestre di manutenzione
+ Una data in cui RDS inizia ad aggiornare automaticamente le istanze alle versioni supportate al di fuori delle finestre di manutenzione
**Importante**
Gli aggiornamenti forzati possono avere conseguenze impreviste per gli stack. CloudFormation Se si fa affidamento su RDS per aggiornare automaticamente le istanze database, è possibile che si verifichino problemi con CloudFormation.
Questa sezione contiene i seguenti argomenti:
**Topics**
+ [Date di supporto previste per le versioni principali di RDS per Oracle](#oracle-major-support-dates)
+ [Date di supporto per le versioni secondarie di RDS per Oracle](#oracle-minor-support-dates)
### Date di supporto previste per le versioni principali di RDS per Oracle
Le versioni principali di RDS per Oracle restano disponibili almeno fino alla data di fine del supporto per la versione di rilascio di Oracle Database corrispondente. È possibile utilizzare le date seguenti per pianificare i cicli di test e aggiornamento. Queste date rappresentano la prima data in cui potrebbe essere richiesto un aggiornamento a una versione più recente. Se Amazon estende il supporto per una versione RDS per Oracle più a lungo di quanto inizialmente previsto, questa tabella verrà aggiornata in base alla nuova data.
**Nota**
È possibile visualizzare le versioni principali dei database Oracle eseguendo il AWS CLI comando [describe-db-major-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-major-engine-versions.html) o utilizzando l'operazione [Descrivi DBMajor EngineVersions](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBMajorEngineVersions.html) RDS API.
| Versione principale di Oracle Database | Data prevista per l’aggiornamento a una versione più recent |
| --- | --- |
| Oracle Database 19c | 31 dicembre 2029 con BYOL Premier Support (senza commissioni per Extended Support) 31 dicembre 2032 con BYOL Extended Support (costo aggiuntivo) o un contratto di licenza illimitato 31 dicembre 2029 con licenza inclusa (LI) |
| Oracle Database 21c | 31 luglio 2027 (non disponibile per Extended Support) |
RDS invia una notifica con almeno 12 mesi prima della necessità di aggiornamento a una nuova versione principale. La notifica descrive in dettaglio il processo di aggiornamento, inclusi la tempistica di alcune fasi cardine importanti, l’impatto sulle istanze database e le operazioni consigliate. Si consiglia di testare accuratamente le applicazioni con le nuove versioni di RDS per Oracle prima di eseguire un aggiornamento della versione principale del database.
Dopo questo periodo di notifica preventiva, un aggiornamento automatico alla versione principale successiva potrebbe essere applicato a qualsiasi istanza database RDS per Oracle che esegue ancora la versione precedente. In tal caso, l’aggiornamento viene avviato durante le finestre di manutenzione pianificata.
Per ulteriori informazioni, consultare [Pianificazione dei rilasci delle versioni correnti del database](https://support.oracle.com/knowledge/Oracle%20Database%20Products/742060_1.html) in My Oracle Support.
### Date di supporto per le versioni secondarie di RDS per Oracle
In alcuni casi, interrompiamo il supporto per le versioni secondarie delle versioni principali di RDS for Oracle. RDS ti avvisa almeno 6 mesi prima della necessità di eseguire l'aggiornamento a una versione secondaria più recente. La notifica descrive il processo di aggiornamento, inclusa la tempistica dei traguardi importanti, l'effetto sulle istanze DB che eseguono la versione secondaria obsoleta e le azioni consigliate. Si consiglia di testare a fondo le applicazioni con le nuove versioni di RDS for Oracle prima di aggiornare il database a una nuova versione secondaria.
Per ulteriori informazioni sulle versioni secondarie obsolete e non supportate, consulta le [note di rilascio per Amazon Relational Database Service (Amazon](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html) RDS) per Oracle.
## Gestione della versione del motore Oracle.
Con la gestione della versione del motore del database è possibile controllare quando e come applicare una patch o un aggiornamento al motore database. Grazie a questa funzionalità, si ottiene la flessibilità necessaria per mantenere la compatibilità con le versioni delle patch del motore database. Puoi inoltre testare nuove versioni delle patch di RDS per Oracle per assicurarti che funzionino con l’applicazione prima di implementarle in produzione. Inoltre, si aggiornano le versioni secondo le proprie condizioni e timeline.
**Nota**
Amazon RDS aggrega periodicamente le patch ufficiali del database Oracle mediante una versione del motore del database specifica per Amazon RDS. Per visualizzare un elenco delle patch di Oracle contenute in una versione del motore Amazon RDS specifica di Oracle, visita le [https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html).
## Snapshot automatici durante gli aggiornamenti del motore
Quando aggiorni un’istanza database Oracle, gli snapshot offrono protezione contro i problemi di aggiornamento. Se il periodo di retention dei backup per l’istanza database è maggiore di 0, durante l’aggiornamento Amazon RDS esegue i seguenti snapshot DB:
1. Uno snapshot DB relativo all’istanza database prima delle modifiche legate all’aggiornamento. Se l’aggiornamento non riesce, potrai ripristinare questa snapshot e creare un’istanza database che esegue la versione precedente.
1. Una copia snapshot dell’istanza database dopo il completamento dell’aggiornamento.
**Nota**
Per cambiare il periodo di retention dei backup, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
Dopo un aggiornamento, non è possibile ripristinare la versione precedente del motore. Tuttavia, è possibile creare una nuova istanza database Oracle ripristinando lo snapshot pre-aggiornamento.
## Aggiornamenti Oracle in una implementazione multi-AZ
Se la tua istanza database è in un’implementazione Multi-AZ, Amazon RDS aggiorna sia le repliche principali sia le repliche standby. Se non sono necessari aggiornamenti del sistema operativo, gli aggiornamenti primari e standby vengono eseguiti contemporaneamente. Le istanze non sono disponibili fino al completamento dell’aggiornamento.
Se sono necessari aggiornamenti del sistema operativo in una implementazione Multi-AZ, Amazon RDS applica gli aggiornamenti quando richiedi l’aggiornamento del database. Amazon RDS esegue le seguenti operazioni:
1. Aggiorna il sistema operativo sull’istanza database di standby corrente.
1. Effettua il failover dell’istanza database primaria sull’istanza database di standby.
1. Aggiorna la versione del database sulla nuova istanza database primaria, che in precedenza era l’istanza di standby. Il database primario non è disponibile durante l’aggiornamento.
1. Aggiorna il sistema operativo sulla nuova istanza database di standby, che in precedenza era l’istanza database primaria.
1. Aggiorna la versione del database sulla nuova istanza database di standby.
1. Effettua il failover della nuova istanza database primaria sull’istanza database primaria originale e la nuova istanza database in standby sull’istanza database in standby originale. Quindi, Amazon RDS riporta la configurazione di replica allo stato originale.
## Aggiornamenti Oracle delle repliche di lettura
La versione del motore di Oracle DB dell’istanza database di origine e tutte le relative repliche di lettura devono essere uguali. Amazon RDS esegue l’aggiornamento nelle seguenti fasi:
1. Aggiorna l’istanza database di origine. Le repliche di lettura sono disponibili in questa fase.
1. Aggiorna le repliche di lettura in parallelo, indipendentemente dalle finestre di manutenzione della replica. Il DB di origine è disponibile in questa fase.
Per gli aggiornamenti delle versioni principali delle repliche di lettura tra regioni, Amazon RDS esegue operazioni aggiuntive:
+ Genera automaticamente un gruppo di opzioni per la versione di destinazione
+ Copia tutte le opzioni e le impostazioni delle opzioni dal gruppo di opzioni originale al nuovo gruppo di opzioni
+ Associa la replica aggiornata di lettura tra regioni al nuovo gruppo di opzioni
# Aggiornamenti a una versione principale Oracle
Per eseguire un aggiornamento a una versione principale, modificare l'istanza database manualmente. Gli aggiornamenti a una versione principale non si verificano in modo automatico.
**Importante**
Accertati di testare in modo approfondito qualsiasi aggiornamento per verificare che le tue applicazioni funzionino correttamente prima di applicare l’aggiornamento ai database di produzione. Per ulteriori informazioni, consulta [Verifica di un aggiornamento del database Oracle](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md).
**Topics**
+ [Versioni supportate per gli aggiornamenti principali](#USER_UpgradeDBInstance.Oracle.Major.supported-versions)
+ [Classi di istanza supportate per gli aggiornamenti principali](#USER_UpgradeDBInstance.Oracle.Major.instance-classes)
+ [Raccolta delle statistiche prima degli aggiornamenti principali](#USER_UpgradeDBInstance.Oracle.Major.gathering-stats)
+ [Consentire gli aggiornamenti principali](#USER_UpgradeDBInstance.Oracle.Major.allowing-upgrades)
## Versioni supportate per gli aggiornamenti principali
Amazon RDS supporta i seguenti aggiornamenti di una versione principale.
****
| Versione corrente | Aggiornamenti supportati |
| --- | --- |
| 19.0.0.0 utilizzando l'architettura CDB | 21,0,0 |
Un aggiornamento della versione principale di Oracle Database deve eseguire l'aggiornamento a un Release Update (RU) rilasciato nello stesso mese o successivamente. I downgrade delle versioni principali non sono supportati per le versioni di Oracle Database.
## Classi di istanza supportate per gli aggiornamenti principali
In alcuni casi, l'istanza database Oracle corrente potrebbe essere in esecuzione su una classe di istanza database che non è supportata per la versione verso cui si sta eseguendo l'aggiornamento. In questo caso, prima di eseguire l'aggiornamento, esegui la migrazione dell'istanza database a una classe di istanza database supportata. Per ulteriori informazioni sulle classi di istanze database supportate per ogni versione ed edizione di Amazon RDS for Oracle, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
## Raccolta delle statistiche prima degli aggiornamenti principali
Prima di effettuare l'aggiornamento a una versione principale, Oracle consiglia di raccogliere statistiche di ottimizzazione sull'istanza database che si sta aggiornando. Questa azione può ridurre i tempi di inattività dell'istanza database durante l'aggiornamento.
Per raccogliere le statistiche dell'ottimizzatore, connettersi all'istanza database come utente principale ed eseguire la procedura `DBMS_STATS.GATHER_DICTIONARY_STATS`, come nel seguente esempio.
```
EXEC DBMS_STATS.GATHER_DICTIONARY_STATS;
```
Per ulteriori informazioni, consulta la sezione relativa alla [Procedura GATHER\$1DICTIONARY\$1STATS](https://docs.oracle.com/en/database/oracle/oracle-database/19/arpls/DBMS_STATS.html?source=%3Aso%3Atw%3Aor%3Aawr%3Aodv%3A%3A#GUID-867989C7-ADFC-4464-8981-437CEA7F331E) nella documentazione di Oracle.
## Consentire gli aggiornamenti principali
Un aggiornamento della versione principale del motore potrebbe non essere compatibile con l'applicazione in uso. L'aggiornamento è irreversibile. Se si specifica una versione principale per il EngineVersion parametro diversa dalla versione principale corrente, è necessario consentire gli aggiornamenti della versione principale.
Se si aggiorna una versione principale utilizzando il comando CLI [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html), specificare. `--allow-major-version-upgrade` Questa impostazione non è definitiva, pertanto dovrai specificare `--allow-major-version-upgrade` ogni volta che esegui un aggiornamento importante. Questo parametro non ha alcun impatto sugli aggiornamenti delle versioni secondarie del motore. Per ulteriori informazioni, consulta [Aggiornamento della versione del motore di di un'istanza database](USER_UpgradeDBInstance.Upgrading.md).
Se si aggiorna una versione principale utilizzando la console, non è necessario scegliere un'opzione per consentire l'aggiornamento. Invece, la console visualizza un avviso che indica che gli aggiornamenti principali sono irreversibili.
# Aggiornamenti a una versione secondaria Oracle
In RDS per Oracle, un aggiornamento secondario è un aggiornamento a una versione principale del motore di database. In RDS, una versione secondaria del motore è un Release Update (RU) o uno Spatial Patch Bundle (SPB). Ad esempio, se l'istanza DB esegue la versione principale di Oracle Database 19c e la versione secondaria 19.0.0.0.ru-2025-10.r1, è possibile aggiornare il motore di database alla versione secondaria 19.0.0.0.ru-2026-01.rur-2026-01.rur-2026-01.r1. RDS per Oracle non supporta i downgrade a versioni precedenti.
Puoi eseguire l'aggiornamento del motore di database a una versione secondaria manualmente o automaticamente. Per informazioni su come eseguire l'aggiornamento manualmente, consulta [Aggiornamento manuale della versione del motore](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual). Per informazioni su come configurare gli aggiornamenti automatici, consulta [Aggiornamento automatico della versione secondaria del motore](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades). Indipendentemente dal fatto che sia manuale o automatico, un aggiornamento della versione secondaria comporta tempi di inattività. Tieni in considerazione questo tempo di inattività quando pianifichi gli aggiornamenti.
Amazon RDS supporta anche la politica di implementazione degli aggiornamenti per gestire gli aggiornamenti automatici delle versioni secondarie su più risorse di database e. Account AWS Per ulteriori informazioni, consulta [Utilizzo della politica di implementazione degli AWS Organizations aggiornamenti per gli aggiornamenti automatici delle versioni secondarie](RDS.Maintenance.AMVU.UpgradeRollout.md).
**Importante**
Accertati di testare in modo approfondito qualsiasi aggiornamento per verificare che le tue applicazioni funzionino correttamente prima di applicare l’aggiornamento ai database di produzione. Per ulteriori informazioni, consulta [Verifica di un aggiornamento del database Oracle](USER_UpgradeDBInstance.Oracle.UpgradeTesting.md).
**Topics**
+ [Release Updates (RUs) e Spatial Patch Bundles () SPBs](#RUs-and-SPBs)
+ [Attivazione degli aggiornamenti a versioni secondarie automatiche per Oracle](#oracle-minor-version-upgrade-tuning-on)
+ [Utilizzo della politica di implementazione degli aggiornamenti per gli AWS Organizations aggiornamenti automatici delle versioni secondarie](#oracle-minor-version-upgrade-rollout)
+ [Amazon RDS per Oracle supporta il preavviso degli aggiornamenti automatici della versione secondaria](#oracle-minor-version-upgrade-advance)
+ [In che modo Amazon RDS pianifica gli aggiornamenti automatici delle versioni secondarie](#oracle-minor-version-upgrade-scheduled)
+ [Gestione di un aggiornamento automatico della versione secondaria in RDS per Oracle](#oracle-minor-version-upgrade-managing)
## Release Updates (RUs) e Spatial Patch Bundles () SPBs
In RDS, un aggiornamento della versione (RU) è una versione secondaria trimestrale del motore che include correzioni di sicurezza, correzioni di bug e nuove funzionalità per Oracle Database. Un bundle di patch spaziali (SPB) è una versione del motore RU che include patch progettate per l’opzione Oracle Spatial. Ad esempio, l'SPB denominato 19.0.0.0.ru-2025-01.spb-1.r1 include tutte le patch nella RU corrispondente 19.0.0.0.ru-2025-01.rur-2025-01.r1 più le patch specifiche per Spatial. SPBs sono supportati solo per Oracle Database 19c.
Quando l'istanza è configurata per gli aggiornamenti automatici delle versioni secondarie RUs e SPBs si trova su percorsi di aggiornamento separati. In genere, un SPB viene rilasciato 2-3 settimane dopo l’RU corrispondente. Nella tabella seguente vengono illustrati alcuni esempi di versioni secondarie per Oracle Database 19c.
| Percorso di aggiornamento RU standard | Percorso di aggiornamento SPB |
| --- | --- |
| 19.0.0.0.ru-2025-01.rur-2025-01.r1 | 19.0.0.0.ru-2025-01.spb-1.r1 |
| 19.0.0.0.ru-2025-04.rur-2025-04.r1 | 19.0.0.0.ru-2025-04.spb-1.r1 |
| 19.0.0.0.ru-2025-07.rur-2025-07.r1 | 19.0.0.0.ru-2025-07.spb-1.r1 |
| 19.0.0.0.ru-2025-10.rur-2025-10.r1 | 19.0.0.0.ru-2025-10.spb-1.r1 |
Se l’istanza database è configurata per gli aggiornamenti automatici, si trova sul percorso di aggiornamento corrispondente alla versione corrente. Ad esempio, se l’istanza database esegue la versione 19.0.0.0.ru-2025-01.rur-2025-01.r1, quando viene rilasciata 19.0.0.0.ru-2025-04.rur-2025-04.r1, l’istanza viene aggiornata automaticamente a questo RU. Allo stesso modo, se l’istanza database esegue 19.0.0.0.ru-2025-01.spb-1.r1, quando viene rilasciata 19.0.0.0.ru-2025-04.spb-1.r1, l’istanza viene aggiornata automaticamente a questo SPB. Un’istanza che esegue 19.0.0.0.ru-2025-01.rur-2025-01.r1, che è un RU, non si aggiornerà automaticamente a 19.0.0.0.ru-2025-04.spb-1.r1, che è un SPB su un percorso di aggiornamento separato.
Puoi aggiornare l'istanza DB SPBs anche se l'istanza non utilizza Spatial, ma le patch Spatial si applicano solo a Oracle Spatial. È possibile eseguire manualmente l’aggiornamento da un RU a un SPB con la stessa versione del motore o una versione successiva. Puoi, ad esempio, aggiornare l’istanza da 19.0.0.0.ru-2025-01.rur-2025-01.r1 a una delle seguenti versioni del motore:
+ 19.0.0.0.ru-2025-01.spb-1.r1
+ 19.0.0.0.ru-2025-04.spb-1.r1
È possibile aggiornare l’istanza da un SPB a un RU solo se l’RU è una versione del motore successiva. Puoi, ad esempio, eseguire l’aggiornamento dalla versione 19.0.0.0.ru-2025-04.spb-1.r1 a una versione RU 19.0.0.0.ru-2025-07.rur-2025-07.r1 successiva, ma non alla stessa versione RU 19.0.0.0.ru-2025-04.rur-2025-04.r1.
Se l’istanza database è configurata per gli aggiornamenti automatici delle versioni secondarie ed esegui l’aggiornamento manuale da un RU a un SPB o da un SPB a un RU, il percorso di aggiornamento automatico cambia. Supponi di eseguire manualmente l’aggiornamento dall’RU versione 19.0.0.0.ru-2025-01.rur-2025-01.r1 all’SPB versione 19.0.0.0.ru-2025-01.spb-1.r1. Il successivo aggiornamento automatico di versioni secondarie sarà alla versione 19.0.0.0.ru-2025-04.spb-1.r1.
Perché SPBs funzionano come RUs, gli RDS APIs per l'aggiornamento dell'istanza a e sono identici. RUs SPBs I comandi seguenti mostrano l’aggiornamento a un RU e a un SPB.
```
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--engine-version 19.0.0.0.ru-2025-01.rur-2025-01.r1
aws rds modify-db-instance \
--db-instance-identifier mydbinstance \
--engine-version 19.0.0.0.ru-2025-01.spb-1.r1
```
Per ulteriori informazioni sull’opzione Oracle Spatial, consulta [Come funzionano gli Spatial Patch Bundles () SPBs](Oracle.Options.Spatial.md#Oracle.Options.Spatial.SPBs). Per informazioni supportate RUs e SPBs per Oracle Database 19c, consulta [Amazon RDS for Oracle Database 19c](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html) (19.0.0.0).
## Attivazione degli aggiornamenti a versioni secondarie automatiche per Oracle
In un aggiornamento automatico della versione secondaria, RDS applica l'ultima versione secondaria disponibile al database Oracle senza intervento manuale. Un'istanza database Amazon RDS per Oracle pianifica l'aggiornamento durante la successiva finestra di manutenzione nelle seguenti circostanze:
+ L'opzione **Aggiornamento automatico della versione secondaria** è attivata per l'istanza database.
+ L'istanza database non esegue già la versione secondaria più recente del motore.
Per informazioni su come attivare gli aggiornamenti automatici, consulta [Aggiornamento automatico della versione secondaria del motore](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades).
## Utilizzo della politica di implementazione degli aggiornamenti per gli AWS Organizations aggiornamenti automatici delle versioni secondarie
Amazon RDS for Oracle AWS Organizations supporta la politica di implementazione degli aggiornamenti per gestire gli aggiornamenti automatici delle versioni secondarie su più risorse di database e. Account AWS Questa policy elimina il sovraccarico operativo legato al coordinamento degli aggiornamenti automatici delle versioni secondarie manualmente o tramite strumenti personalizzati, garantendo al contempo che gli aggiornamenti vengano applicati per la prima volta in ambienti non di produzione prima di essere implementati in produzione. Quando diventa disponibile una nuova versione secondaria del motore, Amazon RDS aggiorna le istanze DB in base all'ordine di implementazione dell'aggiornamento configurato:
| Ordine di implementazione dell'upgrade | Caso d'uso tipico | Quando inizia l'aggiornamento |
| --- | --- | --- |
| Primo | Ambienti di sviluppo e test | Earest: ideale per la convalida di nuove versioni |
| Secondo | Ambienti di staging e di produzione non critici | Al termine della «Prima» fase |
| Ultimo | Ambienti di produzione critici | Al termine della «seconda» fase |
**Importante**
Se non configuri un ordine di implementazione dell'aggiornamento per la tua istanza DB, il valore predefinito è second.
Per informazioni dettagliate sulla tempistica e la durata delle fasi, consulta. [In che modo Amazon RDS pianifica gli aggiornamenti automatici delle versioni secondarie](#oracle-minor-version-upgrade-scheduled) Per informazioni sulla configurazione delle politiche di implementazione degli aggiornamenti in AWS Organizations, vedere. [Utilizzo della politica di implementazione degli AWS Organizations aggiornamenti per gli aggiornamenti automatici delle versioni secondarie](RDS.Maintenance.AMVU.UpgradeRollout.md)
## Amazon RDS per Oracle supporta il preavviso degli aggiornamenti automatici della versione secondaria
Se l'aggiornamento automatico della versione secondaria è abilitato sull'istanza DB, RDS per Oracle crea azioni di manutenzione in sospeso per avvisare l'utente prima di applicare gli aggiornamenti. Puoi visualizzare queste azioni di manutenzione in sospeso nella scheda **Manutenzione e backup** della pagina dei dettagli del database nella console Amazon RDS.
Quando diventa disponibile una nuova versione secondaria, RDS per Oracle pubblica una notifica anticipata (in attesa di intervento di manutenzione). La notifica anticipata ha il seguente formato:
```
An automatic minor version upgrade to engine-version will be applied during your maintenance window on apply-date based on the upgrade rollout order rollout-order. You can change the upgrade rollout order or apply this upgrade manually at any time before the scheduled date through the AWS console or AWS CLI.
```
`apply-date`nella notifica anticipata è indicata la data in cui Amazon RDS aggiornerà l'istanza DB. `rollout-order`è il tuo ordine di implementazione dell'upgrade (primo, secondo o ultimo). Se non hai configurato una politica di implementazione dell'aggiornamento, questo valore è il secondo per impostazione predefinita. Per ulteriori informazioni, consulta [Utilizzo della politica di implementazione degli AWS Organizations aggiornamenti per gli aggiornamenti automatici delle versioni secondarie](RDS.Maintenance.AMVU.UpgradeRollout.md).
Quando inizia la fase di implementazione dell'aggiornamento, il messaggio di azione di manutenzione in sospeso cambia nel formato seguente:
```
Automatic minor version upgrade to engine-version
```
Questo messaggio indica che l'aggiornamento è stato pianificato e verrà applicato durante la finestra di manutenzione alla data di applicazione pianificata. Puoi controllare la data di applicazione pianificata nella scheda **Manutenzione e backup** della pagina dei dettagli del database nella console Amazon RDS o nel `CurrentApplyDate` campo della risposta `describe-pending-maintenance-actions` API.
L'esempio seguente mostra che è possibile ottenere i dettagli sulle azioni di manutenzione in sospeso utilizzando il `describe-pending-maintenance-actions` comando nella AWS CLI:
```
aws rds describe-pending-maintenance-actions
"PendingMaintenanceActions": [
{
"ResourceIdentifier": "arn:aws:rds:us-east-1:123456789012:db:orclinst1",
"PendingMaintenanceActionDetails": [
{
"Action": "db-upgrade",
"Description": "Automatic minor version upgrade to 21.0.0.0.ru-2024-07.rur-2024-07.r1",
"CurrentApplyDate": "2024-12-02T08:10:00Z"
}
]
}, ...
```
Per ulteriori informazioni su come [describe-pending-maintenance-actions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-pending-maintenance-actions.html), consulta la *Guida di riferimento ai comandi della AWS CLI *.
## In che modo Amazon RDS pianifica gli aggiornamenti automatici delle versioni secondarie
Quando utilizzi la policy di implementazione degli upgrade di AWS Organizations, Amazon RDS aggiorna le istanze DB in fasi in base all'ordine di implementazione configurato. Questa sezione descrive i tempi e la durata di ogni fase.
**Fase 0: notifica anticipata**
Quando RDS for Oracle rilascia una nuova versione secondaria (in genere 3-4 settimane dopo il rilascio trimestrale della RU di Oracle), tutte le istanze DB con aggiornamento automatico della versione secondaria abilitato ricevono una notifica anticipata. Questa notifica viene visualizzata nella scheda **Manutenzione e backup** della pagina dei dettagli del database nella console Amazon RDS e nella risposta dell'`describe-pending-maintenance-actions`API. La fase di notifica anticipata dura 2 settimane. Durante questa fase, non si verificano aggiornamenti automatici.
**Fase 1: aggiorna prima l'ordine di implementazione**
Al termine della fase di notifica anticipata, RDS per Oracle inizia ad aggiornare le istanze DB innanzitutto con l'ordine di implementazione dell'aggiornamento. Questa fase dura da 2 a 3 settimane per le versioni secondarie trimestrali di gennaio, aprile e luglio e da 7 a 8 settimane per la versione minore trimestrale di ottobre. Il periodo prolungato per la versione secondaria di ottobre offre tempo sufficiente per testare la nuova versione secondaria durante le festività natalizie di fine anno. Le nuove istanze DB create durante questa fase con l'ordine di implementazione dell'aggiornamento verranno aggiornate automaticamente.
**Fase 2: Upgrade Rollout Order (seconda fase)**
Al termine della fase 1, RDS per Oracle inizia l'aggiornamento delle istanze DB con un secondo ordine di implementazione dell'aggiornamento. Questa fase dura 2 settimane per tutte le versioni minori trimestrali. Le nuove istanze DB create con l'ordine di implementazione dell'aggiornamento per la prima o la seconda volta durante questa fase verranno aggiornate automaticamente.
**Fase 3: ultimo ordine di implementazione dell'aggiornamento**
Al termine della Fase 2, RDS per Oracle inizia ad aggiornare le istanze DB con l'ultimo ordine di implementazione dell'aggiornamento. Questa fase dura fino al prossimo rilascio trimestrale della versione secondaria. Le nuove istanze DB create con l'ordine di implementazione dell'aggiornamento per la prima, la seconda o l'ultima volta durante questa fase verranno aggiornate automaticamente.
| Fase | Quando inizia | Durata | Messaggio di operazione di manutenzione in sospeso |
| --- | --- | --- | --- |
| Fase 0: notifica anticipata | Quando RDS per Oracle rilascia una nuova versione secondaria | 2 settimane | Durante la finestra di manutenzione engine-version verrà applicato un aggiornamento automatico della versione secondaria a, in apply-date base all'ordine di implementazione dell'aggiornamento. rollout-order Puoi modificare l'ordine di implementazione dell'aggiornamento o applicarlo manualmente in qualsiasi momento prima della data pianificata tramite la AWS console o la AWS CLI. |
| Fase 1: aggiorna prima l'ordine di implementazione | Fine della fase di notifica anticipata | Da 2 a 4 settimane per le versioni January/April/July secondarie, da 7 a 9 settimane per la versione minore di ottobre | Aggiornamento automatico della versione secondaria a engine-version |
| Fase 2: Upgrade Rollout Order Second | Fine della fase 1 | 2 settimane | Aggiornamento automatico della versione secondaria a engine-version |
| Fase 3: ultimo ordine di implementazione dell'aggiornamento | Fine della fase 2 | Fino al prossimo rilascio trimestrale della versione secondaria | Aggiornamento automatico della versione secondaria a engine-version |
## Gestione di un aggiornamento automatico della versione secondaria in RDS per Oracle
Quando l'aggiornamento automatico della versione secondaria è abilitato sull'istanza DB, Amazon RDS aggiorna automaticamente l'istanza DB all'ultima versione secondaria durante la finestra di manutenzione. Tuttavia, puoi scegliere di applicare l'aggiornamento manualmente prima della data pianificata utilizzando la AWS CLI o nella scheda **Manutenzione e backup** della pagina dei dettagli del database.
Per aggiornare immediatamente l'istanza DB anziché attendere la finestra di manutenzione pianificata:
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:123456789012:db:orclinst1 \
--apply-action db-upgrade \
--opt-in-type immediate
```
Per applicare l'aggiornamento durante la prossima finestra di manutenzione anziché durante la data di applicazione pianificata:
```
aws rds apply-pending-maintenance-action \
--resource-identifier arn:aws:rds:us-east-1:123456789012:db:orclinst1 \
--apply-action db-upgrade \
--opt-in-type next-maintenance
```
Per disattivare l'aggiornamento automatico della versione secondaria, modifica l'istanza DB e disattiva l'opzione di aggiornamento automatico della versione secondaria. Ciò annulla la pianificazione di qualsiasi aggiornamento automatico in sospeso.
Per ulteriori informazioni su come disattivare l'aggiornamento automatico delle versioni secondarie, consulta. [Aggiornamento automatico della versione secondaria del motore](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades) Se hai bisogno di assistenza per disattivare l'aggiornamento automatico delle versioni secondarie, contatta il AWS Supporto.
A volte una nuova versione secondaria diventa disponibile prima che RDS applichi una versione secondaria precedente. Ad esempio, le istanze sono in esecuzione `21.0.0.0.ru-2025-07.rur-2025-07.r1` quando `both 21.0.0.0.ru-2025-10.rur-2025-10.r1` e `21.0.0.0.ru-2026-01.rur-2026-01.r1` sono disponibili come obiettivi di aggiornamento. In questa situazione, per evitare tempi di inattività non necessari per le istanze database, RDS pianifica l’aggiornamento automatico della versione secondaria alla versione più recente, saltando l’aggiornamento alla versione precedente. In questo esempio, RDS aggiorna l'istanza da `21.0.0.0.ru-2025-07.rur-2025-07.r1` Direct a. `21.0.0.0.ru-2026-01.rur-2026-01.r1`
# Considerazioni sugli aggiornamenti per Oracle Database
Prima di aggiornare l'istanza Oracle, esamina le informazioni riportate di seguito.
**Topics**
+ [Considerazioni su Oracle Multitenant](#USER_UpgradeDBInstance.Oracle.multi)
+ [Considerazioni su gruppi di opzioni](#USER_UpgradeDBInstance.Oracle.OGPG.OG)
+ [Considerazioni sui gruppi di parametri](#USER_UpgradeDBInstance.Oracle.OGPG.PG)
+ [Considerazioni sul fuso orario](#USER_UpgradeDBInstance.Oracle.OGPG.DST)
+ [Considerazioni sullo Spatial Patch Bundle (SPB)](#USER_UpgradeDBInstance.Oracle.SPB)
## Considerazioni su Oracle Multitenant
La tabella seguente illustra le architetture di Oracle Database supportate in diverse versioni.
| Versione di Oracle Database | Stato del supporto RDS | Architecture |
| --- | --- | --- |
| Oracle Database 21c | Supportata | Solo CDB |
| Oracle Database 19c | Supportata | CDB o non CDB |
Nella tabella seguente vengono descritti i percorsi di aggiornamento supportati e non supportati.
| Percorsi di aggiornamento | Supportato? |
| --- | --- |
| Da CDB a CDB | Sì |
| Da non CDB a CDB | No, ma è possibile convertire un database non CDB in un database CDB e quindi eseguirne l’aggiornamento. |
| Da CDB a non CDB | No |
Per ulteriori informazioni su Oracle Multitenant in RDS per Oracle, consulta [Configurazione a tenant singolo dell'architettura CDB](Oracle.Concepts.CDBs.md#Oracle.Concepts.single-tenant).
## Considerazioni su gruppi di opzioni
Se l'istanza DB utilizza un gruppo di opzioni personalizzato, a volte Amazon RDS non è in grado di assegnare automaticamente un nuovo gruppo di opzioni. Ad esempio, questo si verifica quando effettui l'aggiornamento a una nuova versione principale. In questi casi, quando esegui l’aggiornamento specifica un nuovo gruppo di opzioni. Ti consigliamo di creare un nuovo gruppo di opzioni e di aggiungere le stesse opzioni presenti nel gruppo di opzioni personalizzato esistente.
Per ulteriori informazioni, consulta [Creazione di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create) o [Copia di un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Copy).
Se l’istanza database utilizza un gruppo di opzioni personalizzato che contiene le opzioni `APEX` e `APEX-DEV`, a volte è possibile ridurre il tempo di aggiornamento. Per fare ciò, aggiorna la versione di Oracle APEX contemporaneamente all’istanza database. Per ulteriori informazioni, consulta [Aggiornamento della versione di Oracle APEX](Appendix.Oracle.Options.APEX.UpgradeandRemove.md#Appendix.Oracle.Options.APEX.Upgrade).
## Considerazioni sui gruppi di parametri
Se l'istanza database utilizza un gruppo di parametri personalizzato, in alcuni casi Amazon RDS non può assegnare automaticamente all'istanza DB un nuovo gruppo di parametri. Ad esempio, questo si verifica quando effettui l'aggiornamento a una nuova versione principale. In questi casi, assicurati di specificare un nuovo gruppo di parametri quando esegui l'aggiornamento. Ti consigliamo di creare un nuovo gruppo di parametri e di configurare i parametri in modo analogo al gruppo di parametri personalizzato esistente.
Per ulteriori informazioni, consulta [Creazione di un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Creating.md) o [Copia di un gruppo di parametri database in Amazon RDS](USER_WorkingWithParamGroups.Copying.md).
## Considerazioni sul fuso orario
L'opzione del fuso orario consente di modificare il *fuso orario del sistema* utilizzato dall'istanza database Oracle. Ad esempio, potrebbe essere necessario modificare il fuso orario di un'istanza di database in modo che sia compatibile con un ambiente locale o con un'applicazione legacy. L'opzione del fuso orario modifica il fuso orario a livello di host. Amazon RDS for Oracle aggiorna automaticamente il fuso orario del sistema per tutto l'anno. Per ulteriori informazioni sulla modifica del fuso orario di sistema, consulta [Fuso orario Oracle](Appendix.Oracle.Options.Timezone.md).
Quando si crea un'istanza database Oracle, il database imposta automaticamente il *fuso orario del database*. Il fuso orario del database è noto anche come fuso orario ora legale (DST). Il fuso orario del database è distinto dal fuso orario del sistema.
Tra le release di Oracle Database, i set di patch o le singole patch possono includere nuove versioni dell'ora legale (DST). Queste patch riflettono le modifiche apportate alle regole di transizione per varie regioni di fuso orario. Ad esempio, un governo potrebbe cambiare il periodo in cui è in vigore l'ora legale. Le modifiche alle regole dell'ora legale possono influire sui dati di tipo di `TIMESTAMP WITH TIME ZONE` esistenti.
Se si aggiorna un'istanza database RDS for Oracle, Amazon RDS non aggiorna automaticamente il file del fuso orario del database. Per aggiornare automaticamente il file del fuso orario, è possibile includere l’opzione `TIMEZONE_FILE_AUTOUPGRADE` nel gruppo di opzioni associato all'istanza DB durante o dopo l'aggiornamento della versione del motore. Per ulteriori informazioni, consulta [Aggiornamento automatico dei file di fuso orario Oracle](Appendix.Oracle.Options.Timezone-file-autoupgrade.md).
In alternativa, per aggiornare manualmente il fuso orario del database, creare una nuova istanza database Oracle con la patch dell'ora legale (DST) desiderata. Tuttavia, si consiglia di aggiornare il file del fuso orario del database utilizzando l’opzione `TIMEZONE_FILE_AUTOUPGRADE`.
Dopo aver aggiornato il file del fuso orario, migra i dati dall'istanza corrente alla nuova istanza. È possibile eseguire la migrazione dei dati utilizzando diverse tecniche, tra cui le seguenti:
+ AWS Database Migration Service
+ Oracolo GoldenGate
+ Oracle Data Pump
+ Originale Export/Import (non supportato per uso generale)
**Nota**
Quando si esegue la migrazione dei dati utilizzando Oracle Data Pump, l'utilità genera l'errore ORA-39405 quando la versione del fuso orario di destinazione è inferiore alla versione del fuso orario di origine.
Per ulteriori informazioni, consulta l'argomento relativo alle [limitazioni TIMESTAMP con TimeZONE (TIMESTAMP WITH TIMEZONE Restrictions)](https://docs.oracle.com/en/database/oracle/oracle-database/19/sutil/oracle-data-pump-overview.html#GUID-9B6C92EE-860E-43DD-9728-735B17B9DA89) nella documentazione Oracle.
## Considerazioni sullo Spatial Patch Bundle (SPB)
In RDS per Oracle, un aggiornamento della versione (RU) è una versione secondaria del motore che include correzioni di sicurezza, correzioni di bug e nuove funzionalità per Oracle Database. Uno Spatial Patch Bundle (SPB) è una versione secondaria del motore che include anche patch progettate per l’opzione Oracle Spatial. Ad esempio, 19.0.0.0.ru-2025-01.spb-1.r1 è una versione secondaria del motore che contiene le patch RU della versione del motore 19.0.0.0.ru-2025-01.rur-2025-01.r1 e le patch di Spatial.
Quando aggiorni il database a SPBs, considera quanto segue:
+ SPBs sono supportati solo per Oracle Database 19c.
+ In genere, un SPB viene rilasciato 2-3 settimane dopo il corrispondente RU trimestrale.
+ È possibile aggiornare l’istanza database a SPB anche se l’istanza non utilizza l’opzione Oracle Spatial, ma le patch di Spatial nella versione del motore si applicano solo a Oracle Spatial. È possibile creare una nuova istanza su un SPB e installare l’opzione Oracle Spatial in un secondo momento.
+ Se abiliti l’aggiornamento automatico a una versione secondaria per l’istanza database in uso, il percorso di aggiornamento dipende dal fatto che attualmente l’istanza utilizzi o meno un SPB o RU. Se l’istanza utilizza un SPB, RDS aggiorna automaticamente l’istanza all’SPB più recente. Se l’istanza utilizza un RU, RDS aggiorna automaticamente l’istanza all’RU più recente.
+ Puoi aggiornare manualmente l’istanza database da un RU a un SPB solo se la versione dell’SPB è la stessa del motore o superiore a quella dell’RU corrente.
+ È possibile aggiornare manualmente l’istanza database da SPB a RU solo se la versione dell’RU è superiore.
# Verifica di un aggiornamento del database Oracle
Prima di eseguire l'aggiornamento di una versione principale nell'istanza database, verifica a fondo il database e tutte le applicazioni che accedono a esso per verificarne la compatibilità con la nuova versione. È consigliabile utilizzare la procedura seguente.
**Per testare un aggiornamento di una versione principale**
1. Analizzare la documentazione dell'aggiornamento Oracle per la nuova versione del motore di database per verificare se sussistono problemi di compatibilità relativi al database o alle applicazioni. Per ulteriori informazioni, consultare la [Guida all'aggiornamento del database](https://docs.oracle.com/database/121/UPGRD/toc.htm) nella documentazione di Oracle.
1. Se l'istanza database utilizza un gruppo di opzioni personalizzato, creare un nuovo gruppo di opzioni compatibile con la nuova versione a cui si sta eseguendo l'aggiornamento. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
1. Se l'istanza database utilizza un gruppo di parametri personalizzato, creare un nuovo gruppo di parametri compatibile con la nuova versione a cui si sta eseguendo l'aggiornamento. Per ulteriori informazioni, consulta [Considerazioni sui gruppi di parametri](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.PG).
1. Creare uno snapshot DB dell'istanza database da aggiornare. Per ulteriori informazioni, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md).
1. Ripristinare lo snapshot DB per creare una nuova istanza database di test. Per ulteriori informazioni, consulta [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
1. Modificare la nuova istanza database di test per aggiornarla alla nuova versione, utilizzando uno dei metodi seguenti:
+ [Console](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.Console)
+ [AWS CLI](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.CLI)
+ [API RDS](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.Manual.API)
1. Eseguire i test:
+ Eseguire quanti più test di controllo qualità possibili per l'istanza database aggiornata come necessario per assicurare che il database e l'applicazione funzionino correttamente con la nuova versione.
+ Implementare qualsiasi nuovo test necessario per valutare l'impatto di problemi di compatibilità identificati nella fase 1.
+ Testare tutte le stored procedure, le funzioni e i trigger.
+ Indirizzare le versioni di test delle applicazioni all'istanza database aggiornata. Verificare che le applicazioni funzionino correttamente con la nuova versione.
+ Valutare lo storage utilizzato dall'istanza aggiornata per determinare se l'aggiornamento richiede storage aggiuntivo. Potrebbe essere necessario scegliere una classe di istanza più grande per supportare la nuova versione in produzione. Per ulteriori informazioni, consulta [Classi di istanze DB ](Concepts.DBInstanceClass.md).
1. Se tutti i test passano, aggiornare l'istanza DB di produzione. Si consiglia di confermare che l'istanza DB funziona correttamente prima di consentire operazioni di scrittura per l'istanza DB.
# Aggiornamento della versione di un’istanza database RDS per Oracle
Per aggiornare manualmente la versione del motore DB di un'istanza DB RDS for Oracle, utilizza l'API Console di gestione AWS AWS CLI, the o RDS. Per informazioni generali sugli aggiornamenti per i database in RDS, consulta [Aggiornamento della versione di un’istanza database RDS per Oracle](#USER_UpgradeDBInstance.Oracle.Upgrading). Per ottenere obiettivi di aggiornamento validi, utilizzare il AWS CLI [ describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html)comando.
## Console
**Per aggiornare la versione del motore di un’istanza database RDS per Oracle tramite la console**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegliere **Databases (Database)** quindi selezionare l'istanza database da aggiornare.
1. Scegliere **Modify (Modifica)**.
1. Per la **versione del motore di database**, scegli una versione del database superiore.
1. Scegliere **Continue (Continua)** e controllare il riepilogo delle modifiche. Assicurati di comprendere le implicazioni di un aggiornamento della versione del database. Non è possibile riconvertire un’istanza database aggiornata alla versione precedente. Assicurati di aver testato sia il database che l’applicazione con la nuova versione prima di continuare.
1. Decidi quando pianificare l’aggiornamento dell’istanza database. Per applicare immediatamente le modifiche, scegliere **Apply immediately (Applica immediatamente)**. In alcuni casi, la chiusura di questa opzione può causare un'interruzione. Per ulteriori informazioni, consulta [Utilizzo dell’impostazione della pianificazione delle modifiche](USER_ModifyInstance.ApplyImmediately.md).
1. Nella pagina di conferma esaminare le modifiche. Se sono corrette, seleziona **Modifica istanza database** per salvare le modifiche.
In alternativa, scegliere **Back (Indietro)** per cambiare le modifiche o **Cancel (Annulla)** per annullare le modifiche.
## AWS CLI
Per aggiornare la versione del motore di un'istanza DB RDS for Oracle, puoi utilizzare il comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html)CLI. Specifica i seguenti parametri:
+ `--db-instance-identifier`: nome dell’istanza database RDS per Oracle.
+ `--engine-version`: numero di versione del motore di database a cui effettuare l’aggiornamento.
Per informazioni sulle versioni valide del motore, utilizzare il AWS CLI [ describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html)comando.
+ `--allow-major-version-upgrade`: per aggiornare la versione del motore di database.
+ `--no-apply-immediately`: per applicare le modifiche durante la finestra di manutenzione successiva. Per applicare immediatamente le modifiche utilizzare `--apply-immediately`.
**Example**
L’esempio seguente aggiorna un’istanza CDB denominata `myorainst` dalla versione corrente di `19.0.0.0.ru-2024-01.rur-2024-01.r1` alla versione `21.0.0.0.ru-2024-04.rur-2024-04.r1`.
Per Linux, macOS o Unix:
```
1. aws rds modify-db-instance \
2. --db-instance-identifier myorainst \
3. --engine-version 21.0.0.0.ru-2024-04.rur-2024-04.r1 \
4. --allow-major-version-upgrade \
5. --no-apply-immediately
```
Per Windows:
```
1. aws rds modify-db-instance ^
2. --db-instance-identifier myorainst ^
3. --engine-version 21.0.0.0.ru-2024-04.rur-2024-04.r1 ^
4. --allow-major-version-upgrade ^
5. --no-apply-immediately
```
## API RDS
Per aggiornare un'istanza DB di RDS for Oracle, utilizzare l'DBInstanceazione [Modifica](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html). Specifica i seguenti parametri:
+ `DBInstanceIdentifier` – Nome dell'istanza database, ad esempio *`myorainst`*.
+ `EngineVersion` – Numero di versione del motore di database a cui effettuare l'aggiornamento. Per informazioni sulle versioni valide del motore, utilizzare l'operazione [Descrivi DBEngine le versioni](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBEngineVersions.html).
+ `AllowMajorVersionUpgrade` – Se consentire un aggiornamento della versione principale. A questo scopo, imposta il valore su `true`.
+ `ApplyImmediately` – Indica se applicare le modifiche immediatamente o durante la finestra di manutenzione successiva. Per applicare le modifiche immediatamente, imposta il valore su `true`. Per applicare le modifiche durante la finestra di manutenzione successiva imposta il valore su `false`.
# Aggiornamento di uno shapshot DB Oracle
L’aggiornamento degli snapshot di Oracle DB in Amazon RDS garantisce che il database rimanga sicuro, compatibile e completamente supportato. Man mano che le versioni precedenti di Oracle raggiungono la fine del supporto delle patch, puoi aggiornare qualsiasi snapshot di database manuale associato a tali versioni per evitare potenziali vulnerabilità o limitazioni del servizio. Per ulteriori informazioni, consulta [Gestione della versione del motore Oracle.](USER_UpgradeDBInstance.Oracle.Overview.md#Oracle.Concepts.Patching).
Amazon RDS supporta l’aggiornamento degli snapshot in tutte le Regioni AWS.
## Console
**Per aggiornare uno shapshot DB Oracle**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all’indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione scegliere **Snapshots (Snapshot)** e selezionare lo snapshot DB da aggiornare.
1. Per **Actions (Operazioni)**, scegliere **Upgrade snapshot (Aggiorna snapshot)**. Viene visualizzata la pagina **Upgrade snapshot (Aggiorna snapshot)**.
1. Scegliere la **nuova versione del motore** a cui aggiornare la copia istantanea.
1. (Facoltativo) Per **Option group (Gruppo di opzioni)**, selezionare il gruppo di opzioni per lo snapshot DB aggiornato. Le stesse considerazioni sui gruppi di opzioni per quando si aggiorna un'istanza database si applicano quando si aggiorna uno snapshot DB. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
1. Per salvare le modifiche, scegliere **Salva modifiche**.
Durante il processo di aggiornamento, tutte le operazioni dello snapshot sono disabilitate per lo snapshot database. Inoltre, lo stato dello snapshot DB cambia da **available (disponibile)** a **upgrading (in aggiornamento)**, quindi diventa **active (attivo)** al completamento. Se lo snapshot DB non può essere aggiornato a causa di problemi di corruzione, lo stato diventa **unavailable (non disponibile)**. Non è possibile recuperare lo snapshot quando è in questo stato.
**Nota**
Se l’aggiornamento dello snapshot fallisce, lo snapshot viene riportato allo stato originario con la versione iniziale.
## AWS CLI
Per aggiornare uno snapshot DB Oracle tramite AWS CLI, chiamare il comando [modify-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-snapshot.html) con i parametri seguenti:
+ `--db-snapshot-identifier` – Nome dello snapshot DB.
+ `--engine-version` – Versione a cui aggiornare lo snapshot.
Puoi anche includere il seguente parametro. Le stesse considerazioni sui gruppi di opzioni per quando si aggiorna un'istanza database si applicano quando si aggiorna uno snapshot DB. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
+ `--option-group-name` – Gruppo di opzioni per lo snapshot DB aggiornato.
**Example**
Il seguente esempio consente di aggiornare uno snapshot DB.
Per Linux, macOS o Unix:
```
aws rds modify-db-snapshot \
--db-snapshot-identifier mydbsnapshot \
--engine-version 19.0.0.0.ru-2020-10.rur-2020-10.r1 \
--option-group-name default:oracle-se2-19
```
Per Windows:
```
aws rds modify-db-snapshot ^
--db-snapshot-identifier mydbsnapshot ^
--engine-version 19.0.0.0.ru-2020-10.rur-2020-10.r1 ^
--option-group-name default:oracle-se2-19
```
## API RDS
Per aggiornare uno snapshot DB Oracle tramite l'API Amazon RDS, chiamare l'operazione [ModifyDBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshot.html) con i parametri seguenti:
+ `DBSnapshotIdentifier` – Nome dello snapshot DB.
+ `EngineVersion` – Versione a cui aggiornare lo snapshot.
Potrebbe anche essere necessario includere il parametro `OptionGroupName`. Le stesse considerazioni sui gruppi di opzioni per quando si aggiorna un'istanza database si applicano quando si aggiorna uno snapshot DB. Per ulteriori informazioni, consulta [Considerazioni su gruppi di opzioni](USER_UpgradeDBInstance.Oracle.OGPG.md#USER_UpgradeDBInstance.Oracle.OGPG.OG).
# Utilizzo di software di terze parti con l'istanza database RDS for Oracle
È possibile ospitare un’istanza database RDS per Oracle in grado di supportare strumenti e software di terze parti.
**Topics**
+ [Utilizzo di Oracle GoldenGate con Amazon RDS per Oracle](Appendix.OracleGoldenGate.md)
+ [Utilizzo di Oracle Repository Creation Utility in RDS for Oracle](Oracle.Resources.RCU.md)
+ [Configurazione di Oracle Connection Manager su un'istanza Amazon EC2](oracle-cman.md)
+ [Installazione di un Database Siebel in Oracle in Amazon RDS](Oracle.Resources.Siebel.md)
# Utilizzo di Oracle GoldenGate con Amazon RDS per Oracle
Oracle GoldenGate raccoglie, replica e gestisce i dati transazionali tra database. È un pacchetto software con funzionalità Change Data Capture (CDC) e di replica basate su log che viene utilizzato con i database per i sistemi elaborazione di transazioni online (OLTP). Oracle GoldenGate crea file trail che contengono i dati modificati più recentemente dal database di origine. Quindi invia questi file al server, dove un processo converte il file trail in SQL standard da applicare al database di destinazione.
Oracle GoldenGate con RDS per Oracle supporta le seguenti funzionalità:
+ Replica di database attivo-attivo
+ Disaster recovery
+ Protezione dei dati
+ Replica in una regione e tra varie regioni
+ Migrazione e upgrade senza tempi di inattività
+ Replica dei dati tra un'istanza database RDS per Oracle e un database non Oracle
**Nota**
Per l'elenco dei database supportati, consulta [Oracle Fusion Middleware Supported System Configurations](https://www.oracle.com/middleware/technologies/fusion-certification.html) (Configurazioni di sistema supportate per Oracle Fusion Middleware) nella documentazione di Oracle.
È possibile utilizzare Oracle GoldenGate con RDS for Oracle per eseguire l'aggiornamento alle versioni principali di Oracle Database. Ad esempio, puoi utilizzare Oracle per GoldenGate eseguire l'aggiornamento da un database locale Oracle Database 11g a Oracle Database 19c su un'istanza database Amazon RDS.
**Topics**
+ [Versioni e opzioni di licenza supportate per Oracle GoldenGate](#Appendix.OracleGoldenGate.licensing)
+ [Requisiti e limitazioni per Oracle GoldenGate](#Appendix.OracleGoldenGate.requirements)
+ [GoldenGate Architettura Oracle](Appendix.OracleGoldenGate.Overview.md)
+ [Configurazione di Oracle GoldenGate](Appendix.OracleGoldenGate.setting-up.md)
+ [Utilizzo delle utilità EXTRACT e REPLICAT di Oracle GoldenGate](Appendix.OracleGoldenGate.ExtractReplicat.md)
+ [Monitoraggio di Oracle GoldenGate](Appendix.OracleGoldenGate.Monitoring.md)
+ [Risoluzione dei problemi relativi a GoldenGate](Appendix.OracleGoldenGate.Troubleshooting.md)
## Versioni e opzioni di licenza supportate per Oracle GoldenGate
È possibile utilizzare Standard Edition 2 (SE2) o Enterprise Edition (EE) di RDS per Oracle con Oracle GoldenGate versione 12c e successive. È possibile utilizzare le seguenti funzionalità Oracle GoldenGate :
+ Oracle GoldenGate Remote Capture (estrazione) è supportato.
+ L'acquisizione (extract) è supportata nelle istanze database RDS per Oracle che utilizzano la tradizionale architettura di database non CDB. L'acquisizione di Oracle GoldenGate Remote PDB è supportata sull' CDBs esecuzione di Oracle Database 21c o Oracle Database 19c versione 19.0.0.0.ru-2024-04.rur-2024-04.r1 o successiva.
+ Oracle GoldenGate Remote Delivery (replicat) è supportato su istanze RDS per Oracle DB che utilizzano architetture non CDB o CDB. Remote Delivery supporta Integrated Replicat, Parallel Replicat, Coordinated Replicat e Classic Replicat.
+ RDS per Oracle supporta le architetture Classic e Microservices di Oracle. GoldenGate
+ La replica dei valori Oracle GoldenGate DDL e Sequence è supportata quando si utilizza la modalità di acquisizione integrata.
Sei responsabile della gestione delle GoldenGate licenze Oracle (BYOL) da utilizzare con Amazon RDS in generale. Regioni AWS Per ulteriori informazioni, consulta [Opzioni di licenza per RDS per Oracle](Oracle.Concepts.Licensing.md).
## Requisiti e limitazioni per Oracle GoldenGate
Quando lavori con Oracle GoldenGate e RDS per Oracle, considera i seguenti requisiti e limitazioni:
+ Sei responsabile della configurazione e della gestione di Oracle GoldenGate per l'utilizzo con RDS for Oracle.
+ Sei responsabile della configurazione di una GoldenGate versione Oracle certificata con i database di origine e di destinazione. Per ulteriori informazioni, consulta [Oracle Fusion Middleware Supported System Configurations](https://www.oracle.com/middleware/technologies/fusion-certification.html) (Configurazioni di sistema supportate per Oracle Fusion Middleware) nella documentazione di Oracle.
+ Puoi utilizzare Oracle GoldenGate in molti AWS ambienti diversi per molti casi d'uso diversi. Se hai un problema relativo al supporto relativo a Oracle GoldenGate, contatta Oracle Support Services.
+ È possibile utilizzare Oracle GoldenGate su RDS per istanze Oracle DB che utilizzano Oracle Transparent Data Encryption (TDE). Per mantenere l'integrità dei dati replicati, configura la crittografia sull' GoldenGate hub Oracle utilizzando i volumi crittografati di Amazon EBS o la crittografia dei file trail. Configura anche la crittografia per i dati inviati tra l' GoldenGate hub Oracle e le istanze del database di origine e destinazione. Le istanze database RDS for Oracle supportano la crittografia con [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md) o [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md).
# GoldenGate Architettura Oracle
L' GoldenGate architettura Oracle da utilizzare con Amazon RDS è costituita dai seguenti moduli disaccoppiati:
Database di origine
Il database di origine può essere un database Oracle che si trova in locale, un database Oracle su un'istanza Amazon EC2 oppure un database Oracle su un'istanza database Amazon RDS.
Hub GoldenGate Oracle
Un GoldenGate hub Oracle sposta le informazioni sulle transazioni dal database di origine al database di destinazione. L'hub può essere uno dei seguenti:
+ Un'istanza Amazon EC2 con Oracle Database e Oracle installati GoldenGate
+ Un'installazione Oracle on-premise
Puoi disporre di più hub Amazon EC2. Si consiglia di utilizzare due hub se si utilizza Oracle GoldenGate per la replica tra regioni.
Database di destinazione
Il database di destinazione può trovarsi in un'istanza database Amazon RDS, in un'istanza Amazon EC2 o in un percorso locale.
Le seguenti sezioni descrivono gli scenari comuni per Oracle GoldenGate su Amazon RDS.
**Topics**
+ [Database di origine locale e hub Oracle GoldenGate](#Appendix.OracleGoldenGate.on-prem-source-gg-hub)
+ [Database di origine on-premise e hub Amazon EC2](#Appendix.OracleGoldenGate.on-prem-source-ec2-hub)
+ [Database di origine Amazon RDS e hub Amazon EC2](#Appendix.OracleGoldenGate.rds-source-ec2-hub)
+ [Database di origine Amazon EC2 e hub Amazon EC2](#Appendix.OracleGoldenGate.ec2-source-ec2-hub)
+ [Hub Amazon EC2 in diverse regioni AWS](#Appendix.OracleGoldenGate.cross-region-hubs)
## Database di origine locale e hub Oracle GoldenGate
In questo scenario, un database di origine Oracle e un GoldenGate hub Oracle locale forniscono dati a un'istanza database Amazon RDS di destinazione.
![\[GoldenGate Configurazione Oracle 0 con Amazon RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-gg0.png)
## Database di origine on-premise e hub Amazon EC2
In questo scenario, un database Oracle on-premise funge da database di origine. È connesso a un hub di istanze Amazon EC2. Questo hub fornisce i dati a un'istanza database RDS di destinazione per Oracle.
![\[GoldenGate Configurazione Oracle 1 con Amazon RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-gg1.png)
## Database di origine Amazon RDS e hub Amazon EC2
In questo scenario, un'istanza database RDS for Oracle funge da database di origine. È connesso a un hub di istanze Amazon EC2. Questo hub fornisce i dati a un'istanza database RDS di destinazione per Oracle.
![\[GoldenGate Configurazione Oracle 2 con Amazon RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-gg2.png)
## Database di origine Amazon EC2 e hub Amazon EC2
In questo scenario, un database Oracle su un'istanza Amazon EC2 funge da database di origine. È connesso a un hub di istanze Amazon EC2. Questo hub fornisce i dati a un'istanza database RDS di destinazione per Oracle.
![\[GoldenGate Configurazione Oracle 3 con Amazon RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-gg3.png)
## Hub Amazon EC2 in diverse regioni AWS
In questo scenario, un database Oracle su un'istanza database Amazon RDS è connesso a un hub di istanze Amazon EC2 nella AWS stessa regione. L'hub è connesso a un hub di istanze Amazon EC2 in una regione diversa AWS . Questo secondo hub fornisce dati all'istanza DB RDS for Oracle di destinazione nella stessa AWS regione del secondo hub di istanza Amazon EC2.
![\[GoldenGate Configurazione Oracle 4 con Amazon RDS\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/oracle-gg4.png)
**Nota**
Tutti i problemi che influiscono sull'esecuzione di Oracle GoldenGate in un ambiente locale influiscono anche sull'esecuzione di Oracle GoldenGate su. AWS Si consiglia vivamente di monitorare l' GoldenGate hub Oracle per assicurarne `EXTRACT` il `REPLICAT` ripristino in caso di failover. Poiché l' GoldenGate hub Oracle viene eseguito su un'istanza Amazon EC2, Amazon RDS non gestisce l' GoldenGate hub Oracle e non può garantirne l'esecuzione.
# Configurazione di Oracle GoldenGate
Per configurare Oracle GoldenGate utilizzando Amazon RDS, configura l'hub su un'istanza Amazon EC2, quindi configura i database di origine e di destinazione. Le sezioni seguenti forniscono un esempio di come configurare Oracle GoldenGate per l'utilizzo con Amazon RDS for Oracle.
**Topics**
+ [Configurazione di un GoldenGate hub Oracle su Amazon EC2](#Appendix.OracleGoldenGate.Hub)
+ [Configurazione di un database di origine da utilizzare con Oracle GoldenGate su Amazon RDS](#Appendix.OracleGoldenGate.Source)
+ [Configurazione di un database di destinazione da utilizzare con Oracle GoldenGate su Amazon RDS](#Appendix.OracleGoldenGate.Target)
## Configurazione di un GoldenGate hub Oracle su Amazon EC2
Per creare un GoldenGate hub Oracle su un'istanza Amazon EC2, devi prima creare un'istanza Amazon EC2 con un'installazione client completa di Oracle RDBMS. L'istanza Amazon EC2 deve inoltre avere installato il GoldenGate software Oracle. Le versioni del GoldenGate software Oracle dipendono dalle versioni del database di origine e di destinazione. Per ulteriori informazioni sull'installazione di Oracle GoldenGate, consulta la [ GoldenGatedocumentazione Oracle](https://docs.oracle.com/en/middleware/goldengate/core/index.html).
L'istanza Amazon EC2 che funge da GoldenGate hub Oracle archivia ed elabora le informazioni sulle transazioni dal database di origine in file trail. Per supportare questo processo, assicurati che siano soddisfatti i seguenti requisiti:
+ Sia stato allocato uno spazio di archiviazione sufficiente per i file trail.
+ L'istanza Amazon EC2 abbia una capacità di calcolo sufficiente per gestire la quantità di dati.
+ Inoltre, assicurati che l'istanza EC2 disponga di memoria sufficiente per archiviare le informazioni sulle transazioni prima che vengano scritte nel file di trail.
**Per configurare un hub di architettura GoldenGate classica Oracle su un'istanza Amazon EC2**
1. Crea sottodirectory nella directory Oracle. GoldenGate
Nella shell della riga di comando di Amazon EC2, start`ggsci`, l'interprete dei GoldenGate comandi Oracle. Il comando `CREATE SUBDIRS` crea le sottodirectory nella directory `/gg` per i file dei parametri, dei report e dei punti di controllo.
```
prompt$ cd /gg
prompt$ ./ggsci
GGSCI> CREATE SUBDIRS
```
1. Configura il file `mgr.prm`.
L'esempio seguente aggiunge le righe al file `$GGHOME/dirprm/mgr.prm`.
```
PORT 8199
PurgeOldExtracts ./dirdat/*, UseCheckpoints, MINKEEPDAYS 5
```
1. Avvia il manager.
L'esempio seguente avvia `ggsci` ed esegue il comando `start mgr`.
```
GGSCI> start mgr
```
L' GoldenGate hub Oracle è ora pronto per l'uso.
## Configurazione di un database di origine da utilizzare con Oracle GoldenGate su Amazon RDS
Completa le seguenti attività per configurare un database di origine da utilizzare con Oracle GoldenGate.
**Topics**
+ [Passaggio 1: attivazione della registrazione supplementare nel database di origine](#Appendix.OracleGoldenGate.Source.Logging)
+ [Passaggio 2: impostazione del parametro di inizializzazione ENABLE\$1GOLDENGATE\$1REPLICATION su true](#Appendix.OracleGoldenGate.Source.enable-gg-rep)
+ [Passaggio 3: impostazione del periodo di conservazione del log nel database di origine](#Appendix.OracleGoldenGate.Source.Retention)
+ [Fase 4: Creare un account GoldenGate utente Oracle nel database di origine](#Appendix.OracleGoldenGate.Source.Account)
+ [Passaggio 5: concessione dei privilegi all'account utente per il database di origine](#Appendix.OracleGoldenGate.Source.Privileges)
+ [Passaggio 6: aggiunta di un alias TNS per il database di origine](#Appendix.OracleGoldenGate.Source.TNS)
### Passaggio 1: attivazione della registrazione supplementare nel database di origine
Per attivare la registrazione supplementare minima a livello di database, esegui la seguente procedura PL/SQL:
```
EXEC rdsadmin.rdsadmin_util.alter_supplemental_logging(p_action => 'ADD')
```
### Passaggio 2: impostazione del parametro di inizializzazione ENABLE\$1GOLDENGATE\$1REPLICATION su true
Quando imposti il parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION` su `true`, i servizi di database supportano la replica logica. Se il database di origine si trova in un'istanza database Amazon RDS, assicurati di disporre di un gruppo di parametri assegnato all'istanza database con il parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION` impostato su `true`. Per ulteriori informazioni sul parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION`, consulta la [documentazione di Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/ENABLE_GOLDENGATE_REPLICATION.html).
### Passaggio 3: impostazione del periodo di conservazione del log nel database di origine
Assicurati di configurare il database di origine in modo che mantenga i log redo archiviati. Considera le linee guida seguenti:
+ Specifica il periodo di retention dei log in ore. Il valore minimo è 1 ora.
+ Imposta la durata su un valore superiore a eventuali potenziali tempi di inattività dell'istanza database di origine e a eventuali potenziali problemi relativi al periodo di comunicazione o di rete per l'istanza di origine. Tale durata consente a Oracle di GoldenGate recuperare i log dall'istanza di origine secondo necessità.
+ Assicurarsi di disporre di spazio sufficiente sulla propria istanza per i file.
Ad esempio, impostare il periodo di conservazione per i redo log archiviati su 24 ore.
```
EXEC rdsadmin.rdsadmin_util.set_configuration('archivelog retention hours',24)
```
Se non è abilitata l'opzione di conservazione dei log o il suo valore è troppo basso, riceverai un messaggio di errore simile al seguente.
```
2022-03-06 06:17:27 ERROR OGG-00446 error 2 (No such file or directory)
opening redo log /rdsdbdata/db/GGTEST3_A/onlinelog/o1_mf_2_9k4bp1n6_.log for sequence 1306
Not able to establish initial position for begin time 2022-03-06 06:16:55.
```
Poiché l'istanza database mantiene i log redo archiviati, assicurati di disporre dello spazio sufficiente per i file. Per vedere quanto spazio hai utilizzato nelle ultime *num\$1hours* ore, esegui la seguente query, sostituendola *num\$1hours* con il numero di ore.
```
SELECT SUM(BLOCKS * BLOCK_SIZE) BYTES FROM V$ARCHIVED_LOG
WHERE NEXT_TIME>=SYSDATE-num_hours/24 AND DEST_ID=1;
```
### Fase 4: Creare un account GoldenGate utente Oracle nel database di origine
Oracle GoldenGate funziona come utente del database e richiede i privilegi di database appropriati per accedere ai redo log e ai redo log archiviati per il database di origine. A questo scopo, crea un account utente sul database di origine. [Per ulteriori informazioni sulle autorizzazioni per un account GoldenGate utente Oracle, consulta la documentazione Oracle.](https://docs.oracle.com/en/middleware/goldengate/core/19.1/oracle-db/establishing-oracle-goldengate-credentials.html#GUID-79122058-27B0-4FB6-B3DC-B7D1B67EB053)
Le istruzioni seguenti creano un account utente denominato `oggadm1`.
```
CREATE TABLESPACE administrator;
CREATE USER oggadm1 IDENTIFIED BY "password"
DEFAULT TABLESPACE ADMINISTRATOR TEMPORARY TABLESPACE TEMP;
ALTER USER oggadm1 QUOTA UNLIMITED ON administrator;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
### Passaggio 5: concessione dei privilegi all'account utente per il database di origine
In questa attività, concedi i privilegi dell'account necessari agli utenti per il database di origine.
**Per concedere privilegi dell'account per il database di origine**
1. Concedi i privilegi necessari all'account GoldenGate utente Oracle utilizzando il comando SQL `grant` e la `rdsadmin.rdsadmin_util` procedura. `grant_sys_object` Le istruzioni seguenti concedono i privilegi all'utente denominato `oggadm1`.
```
GRANT CREATE SESSION, ALTER SESSION TO oggadm1;
GRANT RESOURCE TO oggadm1;
GRANT SELECT ANY DICTIONARY TO oggadm1;
GRANT FLASHBACK ANY TABLE TO oggadm1;
GRANT SELECT ANY TABLE TO oggadm1;
GRANT SELECT_CATALOG_ROLE TO rds_master_user_name WITH ADMIN OPTION;
EXEC rdsadmin.rdsadmin_util.grant_sys_object ('DBA_CLUSTERS', 'OGGADM1');
GRANT EXECUTE ON DBMS_FLASHBACK TO oggadm1;
GRANT SELECT ON SYS.V_$DATABASE TO oggadm1;
GRANT ALTER ANY TABLE TO oggadm1;
```
1. Concedi i privilegi necessari a un account utente per essere amministratore Oracle GoldenGate . Esegui il seguente PL/SQL programma.
```
EXEC rdsadmin.rdsadmin_dbms_goldengate_auth.grant_admin_privilege (
grantee => 'OGGADM1',
privilege_type => 'capture',
grant_select_privileges => true,
do_grants => TRUE);
```
Per revocare i privilegi, utilizzare la procedura `revoke_admin_privilege` nello stesso pacchetto.
### Passaggio 6: aggiunta di un alias TNS per il database di origine
Aggiungi la seguente voce `$ORACLE_HOME/network/admin/tnsnames.ora` in Oracle Home che sarà utilizzata dal processo `EXTRACT`. Per ulteriori informazioni sul file `tnsnames.ora`, consulta la [documentazione di Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/netrf/local-naming-parameters-in-tns-ora-file.html#GUID-7F967CE5-5498-427C-9390-4A5C6767ADAA).
```
OGGSOURCE=
(DESCRIPTION=
(ENABLE=BROKEN)
(ADDRESS_LIST=
(ADDRESS=(PROTOCOL=TCP)(HOST=goldengate-source.abcdef12345.us-west-2.rds.amazonaws.com)(PORT=8200)))
(CONNECT_DATA=(SERVICE_NAME=ORCL))
)
```
## Configurazione di un database di destinazione da utilizzare con Oracle GoldenGate su Amazon RDS
In questo task, si configura un'istanza DB di destinazione da utilizzare con Oracle GoldenGate.
**Topics**
+ [Passaggio 1: impostazione del parametro di inizializzazione ENABLE\$1GOLDENGATE\$1REPLICATION su true](#Appendix.OracleGoldenGate.Target.enable-gg-rep)
+ [Fase 2: Creare un account GoldenGate utente Oracle nel database di destinazione](#Appendix.OracleGoldenGate.Target.User)
+ [Passaggio 3: concessione dei privilegi all'account per il database di destinazione](#Appendix.OracleGoldenGate.Target.Privileges)
+ [Passaggio 4: aggiunta di un alias TNS per il database di destinazione](#Appendix.OracleGoldenGate.Target.TNS)
### Passaggio 1: impostazione del parametro di inizializzazione ENABLE\$1GOLDENGATE\$1REPLICATION su true
Quando imposti il parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION` su `true`, i servizi di database supportano la replica logica. Se il database di origine si trova in un'istanza database Amazon RDS, assicurati di disporre di un gruppo di parametri assegnato all'istanza database con il parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION` impostato su `true`. Per ulteriori informazioni sul parametro di inizializzazione `ENABLE_GOLDENGATE_REPLICATION`, consulta la [documentazione di Oracle Database](https://docs.oracle.com/en/database/oracle/oracle-database/19/refrn/ENABLE_GOLDENGATE_REPLICATION.html).
### Fase 2: Creare un account GoldenGate utente Oracle nel database di destinazione
Oracle GoldenGate viene eseguito come utente del database e richiede i privilegi di database appropriati. A questo scopo, crea un account utente nel database di destinazione.
L'istruzione seguente crea un utente denominato `oggadm1`.
```
CREATE TABLESPSACE administrator;
CREATE USER oggadm1 IDENTIFIED BY "password"
DEFAULT TABLESPACE administrator
TEMPORARY TABLESPACE temp;
ALTER USER oggadm1 QUOTA UNLIMITED ON administrator;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
### Passaggio 3: concessione dei privilegi all'account per il database di destinazione
In questa attività, concedi i privilegi dell'account necessari agli utenti per il database di destinazione.
**Per concedere i privilegi all'account per il database di destinazione**
1. Concedi i privilegi necessari all'account GoldenGate utente Oracle sul database di destinazione. Nell'esempio seguente vengono concessi privilegi a `oggadm1`.
```
GRANT CREATE SESSION TO oggadm1;
GRANT ALTER SESSION TO oggadm1;
GRANT CREATE CLUSTER TO oggadm1;
GRANT CREATE INDEXTYPE TO oggadm1;
GRANT CREATE OPERATOR TO oggadm1;
GRANT CREATE PROCEDURE TO oggadm1;
GRANT CREATE SEQUENCE TO oggadm1;
GRANT CREATE TABLE TO oggadm1;
GRANT CREATE TRIGGER TO oggadm1;
GRANT CREATE TYPE TO oggadm1;
GRANT SELECT ANY DICTIONARY TO oggadm1;
GRANT CREATE ANY TABLE TO oggadm1;
GRANT ALTER ANY TABLE TO oggadm1;
GRANT LOCK ANY TABLE TO oggadm1;
GRANT SELECT ANY TABLE TO oggadm1;
GRANT INSERT ANY TABLE TO oggadm1;
GRANT UPDATE ANY TABLE TO oggadm1;
GRANT DELETE ANY TABLE TO oggadm1;
```
1. Concedi i privilegi necessari a un account utente per essere amministratore Oracle GoldenGate . Esegui il seguente PL/SQL programma.
```
EXEC rdsadmin.rdsadmin_dbms_goldengate_auth.grant_admin_privilege (
grantee => 'OGGADM1',
privilege_type => 'apply',
grant_select_privileges => true,
do_grants => TRUE);
```
Per revocare i privilegi, utilizzare la procedura `revoke_admin_privilege` nello stesso pacchetto.
### Passaggio 4: aggiunta di un alias TNS per il database di destinazione
Aggiungi la seguente voce `$ORACLE_HOME/network/admin/tnsnames.ora` in Oracle Home che sarà utilizzata dal processo `REPLICAT`. Per i database Oracle multitenant, assicurati che l'alias TNS punti al nome del servizio del PDB. Per ulteriori informazioni sul file `tnsnames.ora`, consulta la [documentazione di Oracle](https://docs.oracle.com/en/database/oracle/oracle-database/19/netrf/local-naming-parameters-in-tns-ora-file.html#GUID-7F967CE5-5498-427C-9390-4A5C6767ADAA).
```
OGGTARGET=
(DESCRIPTION=
(ENABLE=BROKEN)
(ADDRESS_LIST=
(ADDRESS=(PROTOCOL=TCP)(HOST=goldengate-target.abcdef12345.us-west-2.rds.amazonaws.com)(PORT=8200)))
(CONNECT_DATA=(SERVICE_NAME=ORCL))
)
```
# Utilizzo delle utilità EXTRACT e REPLICAT di Oracle GoldenGate
Le GoldenGate utilità Oracle `EXTRACT` e Oracle `REPLICAT` collaborano per mantenere sincronizzati i database di origine e di destinazione tramite la replica incrementale delle transazioni utilizzando file trail. Tutte le modifiche che si verificano nel database di origine vengono rilevate automaticamente`EXTRACT`, quindi formattate e trasferite in file trail sull'hub di istanze Oracle GoldenGate on-premise o Amazon EC2. Dopo il completamento del carico iniziale, i dati vengono letti da questi file e replicati nel database di destinazione dall'utilità `REPLICAT`.
## Eseguire l'utilità Oracle EXTRACT GoldenGate
L'utilità `EXTRACT` recupera, converte e restituisce dati dal database di origine nei file di trail. Di seguito è riportato il processo di base:
1. `EXTRACT` accoda i dettagli della transazione in memoria o nello spazio di archiviazione su disco temporaneo.
1. Il database di origine esegue il commit della transazione.
1. `EXTRACT` scrive i dettagli della transazione in un file trail.
1. Il file trail indirizza questi dettagli all'hub di istanze Oracle GoldenGate on-premise o Amazon EC2 e quindi al database di destinazione.
I passaggi seguenti avviano l'utilità `EXTRACT`, acquisiscono i dati da `EXAMPLE.TABLE` nel database di origine `OGGSOURCE` e creano i file trail.
**Per eseguire l'utilità EXTRACT**
1. Configura il file `EXTRACT` dei parametri sull' GoldenGate hub Oracle (locale o istanza Amazon EC2). L'elenco seguente mostra un esempio di file dei parametri `EXTRACT` denominato `$GGHOME/dirprm/eabc.prm`.
```
EXTRACT EABC
USERID oggadm1@OGGSOURCE, PASSWORD "my-password"
EXTTRAIL /path/to/goldengate/dirdat/ab
IGNOREREPLICATES
GETAPPLOPS
TRANLOGOPTIONS EXCLUDEUSER OGGADM1
TABLE EXAMPLE.TABLE;
```
1. Nell' GoldenGate hub Oracle, accedi al database di origine e avvia l'interfaccia a riga di GoldenGate comando Oracle. `ggsci` L'esempio seguente mostra il formato per l'accesso.
```
dblogin oggadm1@OGGSOURCE
```
1. Aggiungi i dati transazionali per attivare la registrazione supplementare per la tabella del database.
```
add trandata EXAMPLE.TABLE
```
1. Utilizzando la linea di comando `ggsci`, abilita l'utilità `EXTRACT` tramite i comandi seguenti.
```
add extract EABC tranlog, INTEGRATED tranlog, begin now
add exttrail /path/to/goldengate/dirdat/ab
extract EABC,
MEGABYTES 100
```
1. Registra l'utilità `EXTRACT` sul database in modo che i log archiviati non vengano eliminati. Questa attività ti consente di recuperare vecchie transazioni di cui non sia stato eseguito il commit, se necessario. Per registrare l'utilità `EXTRACT` nel database, utilizza il comando seguente.
```
register EXTRACT EABC, DATABASE
```
1. Avviare l'utilità `EXTRACT` con il comando seguente.
```
start EABC
```
## Esecuzione dell'utilità Oracle GoldenGate REPLICAT
L'utilità `REPLICAT` immette le informazioni sulla transazione nei file di trail del database di destinazione.
I seguenti passaggi abilitano e avviano l'utilità `REPLICAT` in modo che possa replicare i dati acquisiti nella tabella `EXAMPLE.TABLE` del database di destinazione `OGGTARGET`.
**Per eseguire l'utilità REPLICATE**
1. Configura il file `REPLICAT` dei parametri sull' GoldenGate hub Oracle (locale o istanza EC2). L'elenco seguente mostra un esempio di file dei parametri `REPLICAT` denominato `$GGHOME/dirprm/rabc.prm`.
```
REPLICAT RABC
USERID oggadm1@OGGTARGET, password "my-password"
ASSUMETARGETDEFS
MAP EXAMPLE.TABLE, TARGET EXAMPLE.TABLE;
```
**Nota**
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
1. Accedi al database di destinazione e avvia l'interfaccia a riga di GoldenGate comando Oracle ()`ggsci`. L'esempio seguente mostra il formato per l'accesso.
```
dblogin userid oggadm1@OGGTARGET
```
1. Utilizzando la linea di comando `ggsci`, aggiungi una tabella dei punti di controllo. L'utente indicato deve essere l'account GoldenGate utente Oracle, non il proprietario dello schema della tabella di destinazione. L'esempio seguente crea una tabella dei punti di controllo denominata `gg_checkpoint`.
```
add checkpointtable oggadm1.oggchkpt
```
1. Per abilitare l'utilità `REPLICAT`, utilizza il comando seguente.
```
add replicat RABC EXTTRAIL /path/to/goldengate/dirdat/ab CHECKPOINTTABLE oggadm1.oggchkpt
```
1. Avvia l'utilità `REPLICAT` utilizzando il comando seguente.
```
start RABC
```
# Monitoraggio di Oracle GoldenGate
Quando usi Oracle GoldenGate per la replica, assicurati che il processo Oracle GoldenGate sia attivo e in esecuzione e che i database di origine e destinazione siano sincronizzati. È possibile utilizzare i seguenti strumenti di monitoraggio:
+ [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) è un servizio di monitoraggio utilizzato in questo modello per monitorare i log degli errori di GoldenGate.
+ [Amazon SNS](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/US_SetupSNS.html) è un servizio di notifica dei messaggi utilizzato in questo modello per inviare notifiche e-mail.
Per istruzioni dettagliate, consulta [Monitoraggio dei log di Oracle GoldenGate utilizzando Amazon CloudWatch](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/monitor-oracle-goldengate-logs-by-using-amazon-cloudwatch.html).
# Risoluzione dei problemi relativi a GoldenGate
Questa sezione spiega i problemi più comuni relativi all'utilizzo di Oracle GoldenGate con Amazon RDS for Oracle.
**Topics**
+ [Errore durante l'apertura del log redo online](#Appendix.OracleGoldenGate.Troubleshooting.Logs)
+ [Oracle GoldenGate sembra essere configurato correttamente ma la replica non funziona](#Appendix.OracleGoldenGate.Troubleshooting.Replication)
+ [Integrated REPLICAT lento a causa della query su SYS."\$1DBA\$1APPLY\$1CDR\$1INFO"](#Appendix.OracleGoldenGate.IR)
## Errore durante l'apertura del log redo online
Assicurati di configurare i database per mantenere i log redo archiviati. Considera le linee guida seguenti:
+ Specifica il periodo di retention dei log in ore. Il valore minimo è 1 ora.
+ Imposta la durata su un valore superiore a eventuali potenziali tempi di inattività dell'istanza database di origine e a eventuali potenziali problemi relativi al periodo di comunicazione o di rete per l'istanza database di origine. Tale durata consente a Oracle di GoldenGate recuperare i log dall'istanza DB di origine in base alle esigenze.
+ Assicurarsi di disporre di spazio sufficiente sulla propria istanza per i file.
Se non è abilitata l'opzione di conservazione dei log o il suo valore è troppo basso, riceverai un messaggio di errore simile al seguente.
```
2022-03-06 06:17:27 ERROR OGG-00446 error 2 (No such file or directory)
opening redo log /rdsdbdata/db/GGTEST3_A/onlinelog/o1_mf_2_9k4bp1n6_.log for sequence 1306
Not able to establish initial position for begin time 2022-03-06 06:16:55.
```
## Oracle GoldenGate sembra essere configurato correttamente ma la replica non funziona
Per le tabelle preesistenti, è necessario specificare l'SCN da cui lavora GoldenGate Oracle.
**Per risolvere questo problema**
1. Accedere al database di origine e avviare l'interfaccia a riga di GoldenGate comando Oracle ()`ggsci`. L'esempio seguente mostra il formato per l'accesso.
```
dblogin userid oggadm1@OGGSOURCE
```
1. Utilizzando la riga di comando `ggsci`, imposta l'SCN iniziale per il processo `EXTRACT`. Nell'esempio seguente, l'SCN viene impostato su 223274 per `EXTRACT`.
```
ALTER EXTRACT EABC SCN 223274
start EABC
```
1. Accedi al database di destinazione. L'esempio seguente mostra il formato per l'accesso.
```
dblogin userid oggadm1@OGGTARGET
```
1. Utilizzando la riga di comando `ggsci`, imposta l'SCN iniziale per il processo `REPLICAT`. Nell'esempio seguente, l'SCN viene impostato su 223274 per `REPLICAT`.
```
start RABC atcsn 223274
```
## Integrated REPLICAT lento a causa della query su SYS."\$1DBA\$1APPLY\$1CDR\$1INFO"
Oracle GoldenGate Conflict Detection and Resolution (CDR) fornisce routine di risoluzione dei conflitti di base. Ad esempio, CDR può risolvere un conflitto univoco per un'istruzione `INSERT`.
Quando CDR risolve una collisione, è possibile inserire temporaneamente record nella tabella delle eccezioni `_DBA_APPLY_CDR_INFO`. Integrato `REPLICAT` elimina questi record in un secondo momento. In uno scenario raro, `REPLICAT` integrato può elaborare un gran numero di collisioni, ma un nuovo integrato `REPLICAT` non lo sostituisce. Invece di essere rimosse, le righe esistenti in `_DBA_APPLY_CDR_INFO` sono orfane. Tutti i nuovi processi `REPLICAT` integrati rallentano perché stanno eseguendo query su righe orfane in `_DBA_APPLY_CDR_INFO`.
Per rimuovere tutte le righe da `_DBA_APPLY_CDR_INFO`, attenersi alla Amazon RDS procedura `rdsadmin.rdsadmin_util.truncate_apply$_cdr_info`. Questa procedura viene rilasciata nell'ambito della versione di ottobre 2020 e dell'aggiornamento delle patch. La procedura è disponibile nelle seguenti versioni del database:
+ [Versione 21.0.0.0.ru-2022-01.rur-2022-01.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-21-0.html#oracle-version-RU-RUR.21.0.0.0.ru-2022-01.rur-2022-01.r1) e successive
+ [Versione 19.0.0.0.ru-2020-10.rur-2020-10.r1](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/oracle-version-19-0.html#oracle-version-RU-RUR.19.0.0.0.ru-2020-10.rur-2020-10.r1) e successive
Nell'esempio seguente viene troncata la tabella `_DBA_APPLY_CDR_INFO`.
```
SET SERVEROUTPUT ON SIZE 2000
EXEC rdsadmin.rdsadmin_util.truncate_apply$_cdr_info;
```
# Utilizzo di Oracle Repository Creation Utility in RDS for Oracle
Puoi utilizzare Amazon RDS per ospitare un'istanza database RDS for Oracle che contiene gli schemi per supportare i componenti Oracle Fusion Middleware. Prima di poter utilizzare i componenti Fusion Middleware, crea e popola gli schemi per i componenti nel database. Puoi creare e popolare gli schemi tramite Oracle Repository Creation Utility (RCU).
## Versioni supportate e opzioni di licenza per RCU
Amazon RDS supporta solo la versione 12c di Oracle Repository Creation Utility (RCU). Puoi utilizzare l'RCU nelle configurazioni seguenti:
+ RCU 12c con Oracle Database 21c
+ RCU 12c con Oracle Database 19c
Prima di poter utilizzare la utilità RCU, eseguire la seguente procedura:
+ Ottieni una licenza per Oracle Fusion Middleware.
+ Segui le linee guida Oracle per la gestione delle licenze relative al database Oracle che ospita il repository. Per ulteriori informazioni, consulta [Oracle Fusion Middleware Licensing Information User Manual (Manuale utente riguardante le informazioni di licenza per Oracle Fusion Middleware](https://docs.oracle.com/en/middleware/fusion-middleware/fmwlc/) nella documentazione di Oracle.
Fusion MiddleWare supporta i repository su Oracle Database Enterprise Edition e Standard Edition 2. Oracle consiglia Enterprise Edition per le installazioni di produzione che richiedono il partizionamento e le installazioni che richiedono la ricostruzione dell'indice online.
Prima di creare l'istanza database RDS for Oracle, verifica la versione del database di Oracle necessaria per supportare i componenti che vuoi distribuire. Utilizza la matrice di certificazione per trovare i requisiti per i componenti e le versioni di Fusion Middleware che desideri implementare. Per ulteriori informazioni, consulta [Oracle Fusion Middleware Supported System Configurations](http://www.oracle.com/technetwork/middleware/ias/downloads/fusion-certification-100350.html) (Configurazioni di sistema supportate per Oracle Fusion Middleware) nella documentazione di Oracle.
Amazon RDS supporta gli aggiornamenti della versione del database di Oracle secondo le necessità. Per ulteriori informazioni, consulta [Aggiornamento della versione del motore di di un'istanza database](USER_UpgradeDBInstance.Upgrading.md).
## Requisiti e limitazioni per RCU
Per utilizzare RCU è necessario un Amazon VPC. L'istanza database Amazon RDS deve essere disponibile solo per i componenti Fusion Middleware e non per Internet pubblico. Pertanto, ospita l'istanza database Amazon RDS in una sottorete privata, che garantisce una maggiore sicurezza. È inoltre necessaria un'istanza database RDS for Oracle. Per ulteriori informazioni, consulta [Creazione e connessione a un'istanza database Oracle](CHAP_GettingStarted.CreatingConnecting.Oracle.md).
Puoi archiviare gli schemi per qualsiasi componente Fusion Middleware nell'istanza database Amazon RDS. Gli schemi seguenti sono stati verificati per l'installazione corretta:
+ Analytics (ATTIVITà)
+ Servizi di audit (IAU)
+ Servizi di audit Append (IAU\$1APPEND)
+ Servizi di audit Viewer (IAU\$1VIEWER)
+ Discussioni (DISCUSSIONI)
+ Servizi dei metadati (MDS)
+ Oracle Business Intelligence (BIPLATFORM)
+ Oracle Platform Security Services (OPSS)
+ Portale e servizi (WEBCENTER)
+ Produttori Portlet (PORTLET)
+ Tabella del servizio (STB)
+ Infrastruttura SOA (SOAINFRA)
+ Servizio di messaggistica dell'utente (UCSUMS)
+ WebLogic Servizi (WLS)
## Linee guida per l'utilizzo di RCU
Di seguito sono riportate alcune raccomandazioni quando si utilizza l'istanza database in questo scenario:
+ Raccomandiamo di usare Multi-AZ per carichi di lavoro di produzione. Per altre informazioni sull'utilizzo di zone di disponibilità multiple, consulta [Regioni, zone di disponibilità e Local Zones ](Concepts.RegionsAndAvailabilityZones.md).
+ Per una maggiore sicurezza, Oracle consiglia di utilizzare Transparent Data Encryption (TDE) per crittografare i dati in attesa. Se si dispone di una licenza Enterprise Edition che comprende l'opzione di sicurezza avanzata, è possibile abilitare la crittografia in attesa utilizzando l'opzione TDE. Per ulteriori informazioni, consulta [Oracle Transparent Data Encryption](Appendix.Oracle.Options.AdvSecurity.md).
Amazon RDS fornisce anche un'opzione di crittografia in attesa per tutte le edizioni del database. Per ulteriori informazioni, consulta [Crittografia delle risorse Amazon RDS](Overview.Encryption.md).
+ Configura il gruppo di sicurezza VPC per consentire la comunicazione tra i server dell'applicazione e l'istanza database Amazon RDS. I server dell'applicazione che ospitano i componenti Fusion Middleware possono essere su Amazon EC2 o in locale.
## Esecuzione di RCU
Usa Oracle Repository Creation Utility (RCU) per creare e popolare gli schemi per supportare i componenti di Fusion Middleware. Puoi eseguire RCU in diversi modi diversi.
**Topics**
+ [Esecuzione di RCU usando la riga di comando in un passaggio](#Oracle.Resources.RCU.SilentSingle)
+ [Esecuzione di RCU usando la riga di comando in più passaggi](#Oracle.Resources.RCU.SilentMulti)
+ [Esecuzione di RCU in modalità interattiva](#Oracle.Resources.RCU.Interactive)
### Esecuzione di RCU usando la riga di comando in un passaggio
Se non hai bisogno di modificare nessuno dei tuoi schemi prima di popolarli, puoi eseguire RCU in un unico passaggio. In caso contrario, consulta la seguente sezione per eseguire RCU in più passaggi.
Puoi eseguire RCU in modalità silenziosa usando il parametro della linea di comando `-silent`. Quando esegui RCU in modalità silenziosa, puoi evitare di inserire le password sulla riga di comando creando un file di testo contenente le password. Creare un file di testo con la password per `dbUser` sulla prima riga e la password per ogni componente sulle righe successive. Specifichi il nome del file della password come ultimo parametro al comando RCU.
**Example**
L'esempio seguente crea e popola gli schemi per il componente dell'infrastruttura SOA (e per le sue dipendenze) in un unico passaggio.
Per Linux, macOS o Unix:
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-createRepository \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-f < /tmp/passwordfile.txt
```
Per ulteriori informazioni, consulta [ Running Repository Creation Utility from the Command Line (Esecuzione dell'utilità di creazione del repository dalla riga di comando)](https://docs.oracle.com/middleware/1221/core/RCUUG/GUID-0D3A2959-7CC8-4001-997E-718ADF04C5F2.htm#RCUUG248) nella documentazione di Oracle.
### Esecuzione di RCU usando la riga di comando in più passaggi
Per modificare manualmente gli script dello schema, esegui RCU in più passaggi:
1. Eseguire RCU in modalità **Prepare Scripts for System Load (Preparare gli script per il caricamento del sistema)** usando il parametro della riga di comando `-generateScript` per creare gli script per gli schemi.
1. Modificare manualmente ed eseguire lo script generato `script_systemLoad.sql`.
1. Eseguire RCU di nuovo in modalità **Perform Product Load (Eseguire il caricamento del prodotto)** usando il parametro della riga di comando `-dataLoad` per popolare gli schemi.
1. Esegui lo script di pulizia generato `script_postDataLoad.sql`.
Per eseguire RCU in modalità silenziosa, specifica il parametro della riga di comando `-silent`. Quando si esegue RCU in modalità silenziosa, è possibile evitare di digitare le password sulla riga di comando creando un file di testo contenente le password. Creare un file di testo con la password per `dbUser` sulla prima riga e la password per ogni componente sulle righe successive. Specifica il nome del file della password come ultimo parametro al comando RCU.
**Example**
L'esempio seguente crea degli script per lo schema per il componente dell'infrastruttura SOA e per le sue dipendenze.
Per Linux, macOS o Unix:
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-generateScript \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
[-encryptTablespace true] \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-scriptLocation /tmp/rcuscripts \
-f < /tmp/passwordfile.txt
```
Ora puoi modificare lo script generato, collegarti all'istanza database di Oracle ed eseguire lo script. Lo script generato è denominato `script_systemLoad.sql`. Per ulteriori informazioni sulla connessione alla tua istanza database di Oracle, consulta [Fase 3: connessione del client SQL a un'istanza database Oracle.](CHAP_GettingStarted.CreatingConnecting.Oracle.md#CHAP_GettingStarted.Connecting.Oracle).
L'esempio seguente popola gli schemi per il componente dell'infrastruttura SOA (e per le sue dipendenze).
Per Linux, macOS o Unix:
```
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-silent \
-dataLoad \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal \
-honorOMF \
-schemaPrefix ${SCHEMA_PREFIX} \
-component MDS \
-component STB \
-component OPSS \
-component IAU \
-component IAU_APPEND \
-component IAU_VIEWER \
-component UCSUMS \
-component WLS \
-component SOAINFRA \
-f < /tmp/passwordfile.txt
```
Per completare, collegati all'istanza database di Oracle ed esegui lo script di pulizia. Lo script è denominato `script_postDataLoad.sql`.
Per ulteriori informazioni, consulta [ Running Repository Creation Utility from the Command Line (Esecuzione dell'utilità di creazione del repository dalla riga di comando)](https://docs.oracle.com/middleware/1221/core/RCUUG/GUID-0D3A2959-7CC8-4001-997E-718ADF04C5F2.htm#RCUUG248) nella documentazione di Oracle.
### Esecuzione di RCU in modalità interattiva
Per utilizzare l'interfaccia utente grafica RCU, esegui RCU in modalità interattiva. Includi il parametro `-interactive` e ometti il parametro `-silent`. Per ulteriori informazioni, consulta [ Understanding Repository Creation Utility Screens (Comprensione delle schermate di utilità della creazione del repository)](https://docs.oracle.com/middleware/1213/core/RCUUG/rcu_screens.htm#RCUUG143) nella documentazione di Oracle.
**Example**
L'esempio seguente avvia RCU in modo interattivo e pre-popola le informazioni riguardanti la connessione.
Per Linux, macOS o Unix:
```
export ORACLE_HOME=/u01/app/oracle/product/12.2.1.0/fmw
export JAVA_HOME=/usr/java/jdk1.8.0_65
${ORACLE_HOME}/oracle_common/bin/rcu \
-interactive \
-createRepository \
-connectString ${dbhost}:${dbport}:${dbname} \
-dbUser ${dbuser} \
-dbRole Normal
```
## Risoluzione dei problemi per RCU
Presta particolare attenzione ai seguenti problemi.
**Topics**
+ [Oracle Managed Files (OMF)](#Oracle.Resources.RCU.KnownIssues.OMF)
+ [Privilegi degli oggetti](#Oracle.Resources.RCU.KnownIssues.object-privs)
+ [Enterprise Scheduler Service](#Oracle.Resources.RCU.KnownIssues.Scheduler)
### Oracle Managed Files (OMF)
Amazon RDS usa file di dati OMF per semplificare la gestione dell'archiviazione. È possibile personalizzare gli attributi del tablespace, come ad esempio la dimensione e la gestione dell'estensione. Tuttavia, la specifica del nome di un file di dati quando si esegue la utilità RCU fa sì che il codice del tablespace restituisca l'errore `ORA-20900`. La RCU può essere utilizzata con OMF nei modi seguenti:
+ In RCU 12.2.1.0 e versioni successive, usare il parametro della riga di comando `-honorOMF`.
+ In RCU 12.1.0.3 e versioni successive, utilizzare più passaggi e modificare lo script generato. Per ulteriori informazioni, consulta [Esecuzione di RCU usando la riga di comando in più passaggi](#Oracle.Resources.RCU.SilentMulti).
### Privilegi degli oggetti
Poiché Amazon RDS è un servizio gestito, non avrai l'accesso `SYSDBA` completo all'istanza database RDS per Oracle. Tuttavia, RCU 12c supporta utenti con privilegi inferiori. Nella maggior parte dei casi, il privilegio dell'utente master è sufficiente a creare repository.
L'account master può concedere direttamente i privilegi `WITH GRANT OPTION` già concessi. In alcuni casi, la utilità RCU potrebbe avere esito negativo con `ORA-01031` quando si cerca di concedere i privilegi oggetto `SYS`. Puoi riprovare ed eseguire la stored procedure `rdsadmin_util.grant_sys_object`, come mostrato nell'esempio seguente:
```
BEGIN
rdsadmin.rdsadmin_util.grant_sys_object('GV_$SESSION','MY_DBA','SELECT');
END;
/
```
Se tenti di concedere i privilegi `SYS` sull'oggetto `SCHEMA_VERSION_REGISTRY`, l'operazione potrebbe avere esito negativo e restituire l'errore `ORA-20199: Error in rdsadmin_util.grant_sys_object`. Puoi qualificare la tabella `SCHEMA_VERSION_REGISTRY$` e la vista `SCHEMA_VERSION_REGISTRY` con il nome del proprietario dello schema, ovvero `SYSTEM`, e riprovare l'operazione. In alternativa, puoi creare un sinonimo. Accedi come utente master ed esegui le seguenti istruzioni:
```
CREATE OR REPLACE VIEW SYSTEM.SCHEMA_VERSION_REGISTRY
AS SELECT * FROM SYSTEM.SCHEMA_VERSION_REGISTRY$;
CREATE OR REPLACE PUBLIC SYNONYM SCHEMA_VERSION_REGISTRY FOR SYSTEM.SCHEMA_VERSION_REGISTRY;
CREATE OR REPLACE PUBLIC SYNONYM SCHEMA_VERSION_REGISTRY$ FOR SCHEMA_VERSION_REGISTRY;
```
### Enterprise Scheduler Service
Quando usi la utilità RCU per eliminare un repository Enterprise Scheduler Service, la RCU può restituire il messaggio `Error: Component drop check failed`.
# Configurazione di Oracle Connection Manager su un'istanza Amazon EC2
Oracle Connection Manager (CMAN) è un server proxy che inoltra le richieste di connessione ai server di database o ad altri server proxy. Puoi utilizzare CMAN per configurare quanto segue:
Controllo accessi
Puoi creare regole che filtrano le richieste client specificate dall'utente e accettarne altre.
Multiplexing della sessione
Puoi incanalare più sessioni client tramite una connessione di rete a una destinazione server condivisa.
In genere, CMAN risiede su un host separato dal server di database e dagli host client. Per ulteriori informazioni, consulta [Configuring Oracle Connection Manager](https://docs.oracle.com/en/database/oracle/oracle-database/19/netag/configuring-oracle-connection-manager.html#GUID-AF8A511E-9AE6-4F4D-8E58-F28BC53F64E4) (Configurazione di Oracle Connection Manager) nella documentazione di Oracle Database.
**Topics**
+ [Versioni supportate e opzioni di licenza per CMAN](#oracle-cman.Versions)
+ [Requisiti e limitazioni per CMAN](#oracle-cman.requirements)
+ [Configurazione di CMAN](#oracle-cman.configuring-cman)
## Versioni supportate e opzioni di licenza per CMAN
CMAN supporta l'Enterprise Edition di tutte le versioni di Oracle Database supportate da Amazon RDS. Per ulteriori informazioni, consulta [Release di RDS per Oracle](Oracle.Concepts.database-versions.md).
Puoi installare Oracle Connection Manager su un host separato dall'host in cui è installato Oracle Database. Non è necessaria una licenza separata per l'host che esegue CMAN.
## Requisiti e limitazioni per CMAN
Per offrire un'esperienza completamente gestita, Amazon RDS limita l'accesso al sistema operativo. Non è possibile modificare i parametri del database che richiedono l'accesso al sistema operativo. Pertanto, Amazon RDS non supporta le caratteristiche di CMAN che richiedono l'accesso al sistema operativo.
## Configurazione di CMAN
Quando si configura CMAN, si esegue la maggior parte del lavoro al di fuori del database RDS for Oracle.
**Topics**
+ [Passaggio 1: configura CMAN in un'istanza Amazon EC2 nello stesso VPC dell'istanza RDS for Oracle](#oracle-cman.configuring-cman.vpc)
+ [Passaggio 2: configura i parametri del database per CMAN](#oracle-cman.configuring-cman.parameters)
+ [Passaggio 3: associa l'istanza database al gruppo di parametri](#oracle-cman.configuring-cman.parameter-group)
### Passaggio 1: configura CMAN in un'istanza Amazon EC2 nello stesso VPC dell'istanza RDS for Oracle
Per informazioni su come configurare CMAN, segui le istruzioni dettagliate nel post del blog [Configuring and using Oracle Connection Manager on Amazon EC2 for Amazon RDS for Oracle](https://aws.amazon.com/blogs/database/configuring-and-using-oracle-connection-manager-on-amazon-ec2-for-amazon-rds-for-oracle/) (Configurazione e utilizzo di Oracle Connection Manager su Amazon EC2 per Amazon RDS for Oracle).
### Passaggio 2: configura i parametri del database per CMAN
Per le caratteristiche CMAN come la modalità Traffic Director e il multiplexing di sessione, impostare`REMOTE_LISTENER`parametro all'indirizzo dell'istanza CMAN in un gruppo di parametri del database. Considera il seguente scenario:
+ L'istanza CMAN risiede su un host con indirizzo IP `10.0.159.100` e utilizza la porta `1521`.
+ I database `orcla`, `orclb` e `orclc` risiedono in istanze database RDS for Oracle separate.
La tabella seguente mostra come impostare il valore `REMOTE_LISTENER`. Il valore `LOCAL_LISTENER` viene impostato automaticamente da Amazon RDS.
| Nome dell'istanza database | IP dell'istanza database | Valore del listener locale (impostato automaticamente) | Valore del listener remoto (impostato dall'utente) |
| --- | --- | --- | --- |
| orcla | 10.0.159.200 | ( address=
(protocol=tcp)
(host=10.0.159.200)
(port=1521)
)
| 10.0.159.100:1521 |
| orclb | 10.0.159.300 | ( address=
(protocol=tcp)
(host=10.0.159.300)
(port=1521)
)
| 10.0.159.100:1521 |
| orclc | 10.0.159.400 | ( address=
(protocol=tcp)
(host=10.0.159.400)
(port=1521)
)
| 10.0.159.100:1521 |
### Passaggio 3: associa l'istanza database al gruppo di parametri
Crea o modifica l'istanza database per utilizzare il gruppo di parametri configurato in [Passaggio 2: configura i parametri del database per CMAN](#oracle-cman.configuring-cman.parameters). Per ulteriori informazioni, consulta [Associazione di un gruppo di parametri database a un’istanza database in Amazon RDS](USER_WorkingWithParamGroups.Associating.md).
# Installazione di un Database Siebel in Oracle in Amazon RDS
È possibile usare Amazon RDS per ospitare un database Siebel in un'istanza database di Oracle. Il database Siebel fa parte dell'architettura dell'applicazione Siebel Customer Relationship Management (CRM). Per un'illustrazione, consulta [ Architettura generica dell'applicazione Siebel Business](https://docs.oracle.com/cd/E63029_01/books/PerformTun/performtun_archinfra.htm#i1043361).
Utilizzare il seguente argomento per facilitare la configurazione di un Database Siebel su un'istanza database Oracle su Amazon RDS. È inoltre possibile scoprire come utilizzare Amazon Web Services per supportare gli altri componenti richiesti dall'architettura dell'applicazione Siebel CRM.
**Nota**
Per installare database Siebel in Oracle in Amazon RDS, è necessario utilizzare l'account utente master. Non è necessario il privilegio `SYSDBA`; è sufficiente il privilegio dell'utente master. Per ulteriori informazioni, consulta [Privilegi dell'account utente master](UsingWithRDS.MasterAccounts.md).
## Licenze e versioni
Per installare un database Siebel in Amazon RDS, è necessario usare la propria licenza database di Oracle e la propria licenza Siebel. È necessario disporre della licenza Oracle Database (con Licenza di aggiornamento software e supporto) adatta alla classe dell'istanza database e all'edizione di Oracle Database. Per ulteriori informazioni, consulta [Opzioni di licenza per RDS per Oracle](Oracle.Concepts.Licensing.md).
Oracle Database Enterprise Edition è l'unica edizione certificata da Siebel per questo scenario. Amazon RDS supporta Siebel CRM versione 15.0 o 16.0.
Amazon RDS supporta gli aggiornamenti della versione del database. Per ulteriori informazioni, consulta [Aggiornamento della versione del motore di di un'istanza database](USER_UpgradeDBInstance.Upgrading.md).
## Prima di iniziare
Prima di iniziare è necessario un Amazon VPC. Poiché l'istanza database Amazon RDS deve essere disponibile solo per il server Siebel Enterprise e non nell'ambiente Internet pubblico, l'istanza database Amazon RDS viene ospitata in una sottorete privata, per garantire una maggiore sicurezza. Per informazioni su come creare un Amazon VPC da usare con Siebel CRM, consulta [Creazione e connessione a un'istanza database Oracle](CHAP_GettingStarted.CreatingConnecting.Oracle.md).
Prima di iniziare, è necessaria anche un'istanza database di Oracle. Per informazioni su come creare un'istanza database Oracle da usare con Siebel CRM, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
## Installazione e configurazione di un Database Siebel
Dopo aver creato l'istanza database di Oracle, è possibile installare il database di Siebel. Si installa il database creando il proprietario della tabella e gli account dell'amministratore, installando procedure archiviate e funzioni e quindi eseguendo la Configurazione guidata del database Siebel. Per altri informazioni, consulta [ Installing the Siebel Database on the RDBMS (Installazione del database di Siebel in RDBMS)](https://docs.oracle.com/cd/E63029_01/books/SiebInstWIN/SiebInstCOM_ConfigDB.html).
Per eseguire la configurazione guidata del database di Siebel, è necessario utilizzare l'account utente master. Non è necessario il privilegio `SYSDBA`; è sufficiente il privilegio dell'utente master. Per ulteriori informazioni, consulta [Privilegi dell'account utente master](UsingWithRDS.MasterAccounts.md).
## Utilizzo di altre caratteristiche Amazon RDS con un Database di Siebel
Dopo aver creato l'istanza database di Oracle, è possibile utilizzare delle caratteristiche aggiuntive di Amazon RDS per aiutare a personalizzare il database di Siebel.
### Raccolta di statistiche con l'opzione Oracle Statspack
Puoi aggiungere delle caratteristiche all'istanza database tramite l'uso di opzioni nei gruppi di opzioni database. Quando hai creato l'istanza database di Oracle, hai utilizzato il gruppo di opzioni predefinite database. Se si desidera aggiungere caratteristiche al database, è possibile creare un nuovo gruppo di opzioni per l'istanza database.
Se si desidera raccogliere statistiche sulle prestazioni nel database Siebel, è possibile aggiungere la caratteristica Oracle Statspack Per ulteriori informazioni, consulta [Oracle Statspack](Appendix.Oracle.Options.Statspack.md).
Alcune modifiche dell'opzione vengono applicate immediatamente e alcune modifiche dell'opzione vengono applicate durante la finestra di manutenzione successiva per l'istanza database. Per ulteriori informazioni, consulta [Uso di gruppi di opzioni](USER_WorkingWithOptionGroups.md). Dopo aver creato un gruppo di opzioni personalizzate, modificare l'istanza database per il collegamento. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### Tuning Performance con i parametri
Puoi gestire la configurazione del motore database attraverso l'uso di parametri in un gruppo di parametri database. Quando hai creato l'istanza database di Oracle, hai utilizzato il gruppo di parametri predefiniti database. Se si desidera personalizzare le caratteristiche del database, è possibile creare un nuovo gruppo di parametri per l'istanza database.
Quando modifichi un parametro, in base al tipo di parametro, le modifiche vengono applicate o immediatamente o dopo i riavvio manuale dell'istanza database. Per ulteriori informazioni, consulta [Gruppi di parametri per Amazon RDS](USER_WorkingWithParamGroups.md). Dopo aver creato un gruppo di parametri personalizzati, modificare l'istanza database per il collegamento. Per ulteriori informazioni, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
Per ottimizzare l'istanza database di Oracle per Siebel CRM, è possibile personalizzare determinati parametri. La tabella riportata di seguito mostra alcune impostazioni consigliate per il parametro. Per ulteriori informazioni sulla regolazione delle prestazioni di Siebel CRM, consulta la [Guida alla regolazione delle prestazioni di Siebel CRM](https://docs.oracle.com/cd/E63029_01/books/PerformTun/toc.htm).
****
| Nome del parametro | Valore predefinito | Guida per prestazioni ottimali di Siebel CRM |
| --- | --- | --- |
| \$1always\$1semi\$1join | `CHOOSE` | `OFF` |
| \$1b\$1tree\$1bitmap\$1plans | `TRUE` | `FALSE` |
| \$1like\$1with\$1bind\$1as\$1equality | `FALSE` | `TRUE` |
| \$1no\$1or\$1expansion | `FALSE` | `FALSE` |
| \$1optimizer\$1join\$1sel\$1sanity\$1check | `TRUE` | `TRUE` |
| \$1optimizer\$1max\$1permutations | 2000 | 100 |
| \$1optimizer\$1sortmerge\$1join\$1enabled | `TRUE` | `FALSE` |
| \$1partition\$1view\$1enabled | `TRUE` | `FALSE` |
| open\$1cursors | `300` | Almeno **2000**. |
### Creazione di snapshot
Dopo aver creato il database di Siebel, è possibile copiare il database usando le caratteristiche di snapshot di Amazon RDS. Per ulteriori informazioni, consulta [Creazione di uno snapshot del database per un’istanza database Single-AZ per Amazon RDS](USER_CreateSnapshot.md) e [Ripristino in un’istanza database](USER_RestoreFromSnapshot.md).
## Supporto per altri Componenti Siebel CRM
Oltre al database Siebel, è anche possibile utilizzare Amazon Web Services per supportare gli altri componenti dall'architettura dell'applicazione Siebel CRM. È possibile trovare altre informazioni sul supporto fornite da Amazon AWS per i componenti aggiuntivi di Siebel CRM nella tabella seguente.
****
| Componente Siebel CRM | Supporto Amazon AWS |
| --- | --- |
| Siebel Enterprise(con uno o più server Siebel) | Puoi ospitare i server Siebel in istanze Amazon Elastic Compute Cloud (Amazon EC2). Puoi utilizzare Amazon EC2 per avviare il numero di server virtuali necessari. Usando Amazon EC2, puoi ridurre o aumentare facilmente per gestire i cambiamenti nei requisiti. Per ulteriori informazioni, consulta [Che cos'è Amazon EC2?](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/concepts.html) Puoi inserire i server nello stesso VPC con l'istanza database e usare il gruppo di sicurezza VPC per accedere al database. Per ulteriori informazioni, consulta [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md). |
| Server Web(con Siebel Web Server Extensions) | È possibile installare più server Web su più istanze EC2. Per utilizzare Elastic Load Balancing per distribuire il traffico in ingresso tra le istanze. Per ulteriori informazioni, consulta [Che cos'è Elastic Load Balancing?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/elastic-load-balancing.html) |
| Siebel Gateway Name Server | Puoi ospitare i server Siebel Gateway Name Server nell'istanza EC2. Puoi quindi inserire i server nello stesso VPC con l'istanza database e usare il gruppo di sicurezza VPC per accedere al database. Per ulteriori informazioni, consulta [Uso di un'istanza database in un VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md). |
# Note di rilascio del motore di database Oracle
Aggiorna le istanze database Amazon RDS for Oracle per mantenerle aggiornate. Se applichi gli aggiornamenti, puoi essere certo che l'istanza database esegue una versione del software di database che è stata testata da Oracle e Amazon. Non supportiamo l'applicazione di patch occasionali a singole istanze database RDS per Oracle.
Quando crei una nuova istanza database, puoi specificare qualsiasi versione di Oracle Database attualmente supportata. Si può specificare la versione principale, ad esempio Oracle Database 19c, e qualsiasi versione secondaria supportata per la versione principale specificata. Se non viene specificata alcuna versione, Amazon RDS utilizza per impostazione predefinita una versione supportata, in genere la più recente. Se viene specificata una versione principale ma non una secondaria, per impostazione predefinita Amazon RDS utilizza una release recente della versione principale specificata. Per visualizzare un elenco di versioni supportate e di valori predefiniti per le nuove istanze database create, utilizza il comando della AWS CLI [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Per informazioni dettagliate sulle versioni di Oracle Database supportate da Amazon RDS, consulta le [https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes/Welcome.html).