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à.
# 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;
```