Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Protezione delle connessioni di istanze database di Oracle
Amazon RDS for Oracle supporta le connessioni crittografate SSL/TLS così come l'opzione Native Network Encryption (NNE) di Oracle per crittografare le connessioni tra l'applicazione e l'istanza database Oracle. Per ulteriori informazioni sull'opzione Native Network Encryption di Oracle, consulta [Oracle native network encryption](Appendix.Oracle.Options.NetworkEncryption.md).
**Topics**
+ [Utilizzo di SSL con un'istanza database RDS per Oracle](Oracle.Concepts.SSL.md)
+ [Aggiornamento delle applicazioni per la connessione alle istanze DB di Oracle utilizzando nuovi certificati SSL/TLS](ssl-certificate-rotation-oracle.md)
+ [Utilizzo di native network encryption con un'istanza database RDS per Oracle](Oracle.Concepts.NNE.md)
+ [Configurazione dell'autenticazione Kerberos per Amazon RDS for Oracle](oracle-kerberos.md)
+ [Configurazione dell'accesso UTL\$1HTTP utilizzando certificati e un portafoglio Oracle](Oracle.Concepts.ONA.md)
# Utilizzo di SSL con un'istanza database RDS per Oracle
Secure Sockets Layer (SSL) è un protocollo standard del settore utilizzato per proteggere connessioni di rete tra client e server. Dopo SSL versione 3.0, il nome è stato modificato in Transport Layer Security (TLS) ma spesso viene ancora indicato come protocollo SSL. Amazon RDS supporta la crittografia SSL per le istanze database Oracle. Mediante SSL, è possibile crittografare una connessione tra l'applicazione cliente e l'istanza database di Oracle. Il supporto per SSL è disponibile in tutte le regioni AWS per Oracle.
Puoi abilitare la crittografia SSL per un'istanza database 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. In questo modo è consentito allo stesso tempo sia testo in chiaro sia comunicazioni con crittografia SSL tra un'istanza database e un cliente Oracle. 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.
Per ulteriori informazioni, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
**Nota**
È possibile utilizzare sia SSL sia NNE di Oracle sulla stessa istanza database. Prima di iniziare a utilizzare la crittografia SSL, è necessario disabilitare le altre crittografie di connessione.
# Aggiornamento delle applicazioni per la connessione alle istanze DB di Oracle utilizzando nuovi certificati SSL/TLS
A partire dal 13 gennaio 2023, Amazon RDS ha pubblicato nuovi certificati dell'autorità di certificazione (CA) per la connessione alle istanze database RDS utilizzando Secure Socket Layer o Transport Layer Security (SSL/TLS). Di seguito sono disponibili le informazioni sull'aggiornamento delle applicazioni per utilizzare i nuovi certificati.
Questo argomento può aiutarti a determinare se alcune applicazioni client vengono utilizzate SSL/TLS per connettersi alle tue istanze DB.
**Importante**
Quando si modifica il certificato per un'istanza database Amazon RDS for Oracle, viene riavviato solo il listener di database. L'istanza database non viene riavviata. Le connessioni al database esistenti non vengono influenzate, ma le nuove connessioni presenteranno errori per un breve periodo durante il riavvio del listener.
È consigliabile riavviare il database Oracle per evitare errori di connessione.
**Nota**
Per le applicazioni client che vengono utilizzate SSL/TLS per connettersi alle istanze DB, è necessario aggiornare gli archivi di fiducia delle applicazioni client per includere i nuovi certificati CA.
Dopo aver aggiornato i certificati CA negli archivi di trust delle applicazioni client, puoi ruotare i certificati nelle istanze database. Consigliamo vivamente di testare queste procedure in un ambiente di sviluppo o di gestione temporanea prima di implementarle negli ambienti di produzione.
Per ulteriori informazioni sulla rotazione dei certificati, consulta [Rotazione del certificato SSL/TLS](UsingWithRDS.SSL-certificate-rotation.md). Per ulteriori informazioni sul download, consulta [](UsingWithRDS.SSL.md). Per informazioni sull'utilizzo SSL/TLS con le istanze Oracle DB, vedere. [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md)
**Topics**
+ [Verifica se le applicazioni si connettono utilizzando SSL](#ssl-certificate-rotation-oracle.determining)
+ [Aggiornare l'archivio di trust delle applicazioni](#ssl-certificate-rotation-oracle.updating-trust-store)
+ [Codice Java di esempio per stabilire connessioni SSL](#ssl-certificate-rotation-oracle.java-example)
## Verifica se le applicazioni si connettono utilizzando SSL
Se la tua istanza database Oracle utilizza un gruppo di opzioni con l'opzione `SSL` aggiunta, potresti dover utilizzare SSL. Controlla seguendo le istruzioni seguenti in [Generazione di un elenco delle opzioni e delle impostazioni delle opzioni per un gruppo di opzioni](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ListOption). Per ulteriori informazioni sull'opzione `SSL`, consulta [Oracle Secure Sockets Layer](Appendix.Oracle.Options.SSL.md).
Controlla il log listener per determinare se ci siano connessioni SSL. Di seguito è riportato un output di esempio in un log listener.
```
date time * (CONNECT_DATA=(CID=(PROGRAM=program)
(HOST=host)(USER=user))(SID=sid)) *
(ADDRESS=(PROTOCOL=tcps)(HOST=host)(PORT=port)) * establish * ORCL * 0
```
Quando `PROTOCOL` ha il valore `tcps` per una entry, mostra una connessione SSL. Tuttavia, quando `HOST` è `127.0.0.1`, puoi ignorare la entry. Le connessioni da `127.0.0.1` sono un management agent locale sull’istanza database. Tali connessioni non sono esterne a SSL. Pertanto, hai applicazioni di connessione mediante SSL se vedi voci dei listener log in cui `PROTOCOL` è `tcps` e `HOST` *non è * `127.0.0.1`.
Per controllare il log del listener, puoi pubblicarlo su Amazon CloudWatch Logs. Per ulteriori informazioni, consulta [Pubblicazione dei log Oracle su Amazon CloudWatch Logs](USER_LogAccess.Concepts.Oracle.md#USER_LogAccess.Oracle.PublishtoCloudWatchLogs).
## Aggiornare l'archivio di trust delle applicazioni
È possibile aggiornare il trust store per le applicazioni che utilizzano SQL\$1Plus o JDBC per le connessioni. SSL/TLS
### Aggiornare l'archivio di trust delle applicazioni per SQL\$1Plus
È possibile aggiornare il trust store per le applicazioni che utilizzano SQL\$1Plus per le connessioni. SSL/TLS
**Nota**
Quando aggiorni l'archivio di trust puoi conservare i certificati meno recenti oltre ad aggiungere i nuovi certificati.
**Per aggiornare l'archivio di trust delle applicazioni SQL\$1Plus**
1. Scaricate il nuovo certificato root che funziona per tutte le AWS regioni e inserite il file nella directory. `ssl_wallet`
Per ulteriori informazioni sul download del certificato root, consulta [](UsingWithRDS.SSL.md).
1. Esegui i comandi seguenti per aggiornare il wallet Oracle.
```
prompt>orapki wallet add -wallet $ORACLE_HOME/ssl_wallet -trusted_cert -cert
$ORACLE_HOME/ssl_wallet/ssl-cert.pem -auto_login_only
```
Sostituire il nome del file con il nome del file scaricato.
1. Eseguire il comando seguente per confermare che il wallet è stato correttamente installato.
```
prompt>orapki wallet display -wallet $ORACLE_HOME/ssl_wallet
```
L'output dovrebbe contenere le seguenti informazioni.
```
Trusted Certificates:
Subject: CN=Amazon RDS Root 2019 CA,OU=Amazon RDS,O=Amazon Web Services\, Inc.,L=Seattle,ST=Washington,C=US
```
### Aggiornare l'archivio di trust delle applicazioni per JDBC
È possibile aggiornare il trust store per le applicazioni che utilizzano JDBC per SSL/TLS le connessioni.
Per ulteriori informazioni sul download del certificato root, consulta [](UsingWithRDS.SSL.md).
Per gli script di esempio che importano i certificati, consulta [Script di esempio per l'importazione di certificati nel tuo archivio di trust](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-sample-script).
## Codice Java di esempio per stabilire connessioni SSL
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 = "";
private static final Integer SSL_PORT = "";
private static final String DB_SID = "";
private static final String DB_USER = "";
private static final String DB_PASSWORD = "";
// This key store has only the prod root ca.
private static final String KEY_STORE_FILE_PATH = "";
private static final String KEY_STORE_PASS = "";
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;
```