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 di un'istanza database per Amazon RDS Custom per Oracle
Puoi creare un'istanza database RDS Custom e quindi connetterti ad essa utilizzando Secure Shell (SSH) o AWS Systems Manager.
Per ulteriori informazioni sulla connessione e l’accesso a un’istanza database RDS Custom per Oracle, consulta gli argomenti riportati di seguito.
+ [Connessione all'istanza database RDS Custom utilizzando Session Manager](custom-creating.ssm.md)
+ [Connessione all'istanza database RDS Custom tramite SSH](#custom-creating.ssh)
+ [Accesso al database RDS Custom per Oracle come SYS](custom-creating.sysdba.md)
## Creazione di un'istanza database RDS Custom per Oracle
Crea un'istanza Amazon RDS Custom for Oracle DB utilizzando Console di gestione AWS o. AWS CLI La procedura è simile alla procedura per la creazione di un'istanza database Amazon RDS. Per ulteriori informazioni, consulta [Creazione di un'istanza database Amazon RDS](USER_CreateDBInstance.md).
Se hai incluso i parametri di installazione nel manifesto CEV, l'istanza DB utilizza la base Oracle, la Oracle home e l'ID e il nome dell' UNIX/Linux utente e del gruppo che hai specificato. Il file `oratab`, creato da Oracle Database durante l'installazione, punta alla posizione di installazione reale anziché a un collegamento simbolico. RDS Custom per Oracle esegue i comandi come utente del sistema operativo configurato anziché come utente predefinito `rdsdb`. Per ulteriori informazioni, consulta [Fase 5: preparazione del manifesto CEV](custom-cev.preparing.md#custom-cev.preparing.manifest).
Completa le attività presenti in [Configurazione dell'ambiente per Amazon RDS Custom per Oracle](custom-setup-orcl.md) prima di poter creare o connettere a un'istanza database RDS Custom.
### Console
**Per creare un'istanza database RDS Custom 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 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), scegli **Standard create** (Creazione standard).
1. Nella sezione **Opzioni motore**, procedi nel modo seguente:
1. Per **Engine type** (Tipo di motore), seleziona **Oracle**.
1. Per il **tipo di gestione del database**, selezionare **Amazon RDS Custom**.
1. In **Impostazioni dell'architettura**, effettua una delle seguenti operazioni:
+ Seleziona **Architettura multi-tenant** per creare un database container (CDB). Al momento della creazione, il CDB contiene un seed PDB e un PDB iniziale.
**Nota**
L'**architettura multilocazione** è supportata solo in Oracle Database 19c.
+ Deseleziona **Architettura multi-tenant** per creare un database non di tipo container. Un prodotto non CDB non può contenere. PDBs
1. In **Edizione**, scegli **Oracle Enterprise Edition** o **Oracle Standard Edition 2**.
1. In **Versioni del motore personalizzato**, scegli una versione del motore personalizzato (CEV) RDS Custom esistente. Una CEV ha il formato seguente: `major-engine-version.customized_string`. Un identificatore di esempio è `19.cdb_cev1`.
Se hai scelto **Architettura multitenant** nel passaggio precedente, puoi specificare solo una CEV che utilizza il tipo di motore `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. La console filtra i CEVs file creati con diversi tipi di motore.
1. Per **Templates** (Modelli), scegli **Production** (Produzione).
1. Nella sezione **Rule settings (Impostazioni regole)**, procedi nel seguente modo:
1. In **Identificatore di istanza database**, immetti un nome univoco per l'istanza database.
1. In **Nome utente master**, immetti un nome utente. È possibile recuperare questo valore dalla console in un secondo momento.
Quando ti connetti a un non CDB, l'utente master è l'utente del non CDB. Quando ti connetti a un CDB, l'utente master è l'utente del PDB. Per connetterti alla root CDB, accedi all'host, avvia un client SQL e crea un utente amministrativo con i comandi SQL.
1. Deseleziona **Genera automaticamente una password**.
1. Scegli una classe in **Classe di istanza database**.
Per le classi supportate, consultare [Supporto delle classi di istanza database per RDS Custom per Oracle](custom-oracle-feature-support.md#custom-reqs-limits.instances).
1. Nella sezione **Storage** (Archiviazione), procedi come segue:
1. Per **Tipo di archiviazione**, scegli un tipo di SSD: io1, io2, gp2 o gp3. Sono disponibili le seguenti opzioni aggiuntive:
+ **Per io1, io2 o gp3, scegli una tariffa per Provisioned IOPS.** L'impostazione predefinita è 1000 per io1 e io2 e 12000 per gp3.
+ Per gp3, scegli una tariffa in **Throughput di storage**. L'impostazione predefinita è 500. MiBps
1. In **Storage allocato**, scegli una dimensione di archiviazione. L'impostazione predefinita è 40 GiB.
1. In **Connettività**, specifica un valore nei campi **Cloud privato virtuale (VPC)**, **Gruppi di sottoreti DB** e **Gruppo di sicurezza VPC (firewall)**.
1. Per la sicurezza **RDS Custom**, procedere come segue:
1. Per il **profilo dell'istanza IAM**, selezionare il profilo dell'istanza per l'istanza database RDS Custom per Oracle.
Il profilo dell'istanza IAM deve iniziare con `AWSRDSCustom`, ad esempio *AWSRDSCustomInstanceProfileForRdsCustomInstance*.
1. Per **Crittografia**, scegli **Inserisci una chiave ARN** per elencare le chiavi disponibili AWS KMS . Scegliere quindi la propria chiave dall'elenco.
È richiesta una AWS KMS chiave per RDS Custom. Per ulteriori informazioni, consulta [Fase 1: Creare o riutilizzare una chiave di crittografia simmetrica AWS KMS](custom-setup-orcl.md#custom-setup-orcl.cmk).
1. In **Opzioni database**, esegui le operazioni indicate di seguito:
1. (Facoltativo) In **ID sistema ID (SID)**, inserisci un valore per il SID Oracle, che è anche il nome del tuo CDB. Il valore del campo ID sistema ID (SID) è il nome dell'istanza database Oracle che gestisce i file del database. In questo contesto, il termine "istanza database Oracle" si riferisce esclusivamente all'area globale del sistema (SGA) e ai processi in background di Oracle. Se non specifichi un valore, il valore predefinito è **RDSCDB**.
1. (Facoltativo) In **Nome database iniziale**, immetti un nome. Il valore predefinito è **ORCL**. Nell'architettura multi-tenant, il nome del database iniziale è il nome del PDB.
**Nota**
Il SID e il nome PDB devono essere diversi.
1. In **Gruppo di opzioni**, scegli un gruppo di opzioni o accetta quello predefinito.
**Nota**
L’unica opzione supportata per RDS Custom per Oracle è `Timezone`. Per ulteriori informazioni, consulta [Fuso orario Oracle](custom-managing.timezone.md).
1. In **Periodo di conservazione dei backup**, scegli un valore. Non puoi scegliere **0 giorni**.
1. Per le restanti sezioni, specifica le impostazioni dell'istanza database RDS Custom preferite. Per informazioni su ciascuna impostazione, consulta [Impostazioni per istanze database](USER_CreateDBInstance.Settings.md). Le impostazioni seguenti non appaiono nella console e non sono supportate:
+ **Caratteristiche processore**
+ **Storage autoscaling (Auto Scaling dello storage)**
+ Opzione **Password and Kerberos authentication (Password e autenticazione Kerberos)** in **Database authentication (Autenticazione del database)** (solo **Autenticazione password** è supportata)
+ **Approfondimenti sulle prestazioni**
+ **Log exports (Esportazioni log)**
+ **Abilita aggiornamento automatico della versione secondaria**
+ **Deletion protection (Protezione da eliminazione)**
1. Scegliere **Crea database**.
**Importante**
Quando crei un'istanza database RDS Custom per Oracle, potresti ricevere il seguente errore: Il ruolo collegato ai servizi è nel processo di creazione. Riprova più tardi. In questo caso, attendere alcuni minuti e riprovare a creare l'istanza database.
Il pulsante **View credential details (Vedi dettagli delle credenziali)** viene visualizzato sulla pagina **Database**.
Per vedere nome utente e password per l'istanza database RDS Custom, seleziona **View credential details (Vedi dettagli delle credenziali)**.
Per connetterti all'istanza database come utente principale, utilizza il nome utente e la password visualizzati.
**Importante**
Non è possibile visualizzare di nuovo la password dell'utente master nella console. Se non la registri, potresti doverla modificare. Per modificare la password dell'utente master dopo che l'istanza database RDS Custom è disponibile, accedi al database ed esegui un comando `ALTER USER`. Puoi ripristinare la password utilizzando l'opzione **Modifica** nella console.
1. Scegliere **Database** per visualizzare l'elenco delle istanze database RDS Custom.
1. Scegliere l'istanza database RDS Custom appena creata.
Nella console RDS vengono visualizzati i dettagli per la nuova istanza database RDS Custom:
+ L'istanza database RDS Custom rimane nello stato **creating (creazione in corso)** fino a quando non è stata creata e non è pronta per l'uso. Quando lo stato cambia in **available (disponibile)** è possibile connettersi all'istanza database. A seconda della classe di istanza e dello storage allocato, potrebbero trascorrere diversi minuti prima che la nuova istanza database sia disponibile.
+ **Ruolo** ha il valore **Istanza (RDS Custom)**.
+ **Modalità di automazione RDS Custom** ha il valore **Automazione completa**. Questa impostazione indica che l'istanza database fornisce il monitoraggio automatico e il ripristino dell'istanza.
### AWS CLI
È possibile creare un'istanza DB personalizzata RDS utilizzando il [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html) AWS CLI comando.
Sono richieste le seguenti opzioni:
+ `--db-instance-identifier`
+ `--db-instance-class` (per l'elenco delle classi di istanza supportate, vedere [Supporto delle classi di istanza database per RDS Custom per Oracle](custom-oracle-feature-support.md#custom-reqs-limits.instances))
+ `--engine engine-type`, *engine-type* dov'è`custom-oracle-ee`, `custom-oracle-se2``custom-oracle-ee-cdb`, o `custom-oracle-se2-cdb`
+ `--engine-version cev` (dove *`cev`* è il nome della versione del motore personalizzata specificata in [Creazione di un CEV](custom-cev.create.md))
+ `--kms-key-id my-kms-key`
+ `--backup-retention-period days` (dove *`days`* è un valore maggiore di `0`)
+ `--no-auto-minor-version-upgrade`
+ `--custom-iam-instance-profile AWSRDSCustomInstanceProfile-us-east-1` (dove *`region`* è la Regione AWS in cui stai creando l'istanza DB)
Nell'esempio seguente viene creata un'istanza database RDS Custom per denominata `my-cfo-cdb-instance`. Il database è un CDB con un nome non predefinito. *MYCDB* Il nome PDB non predefinito è. *MYPDB* Il periodo di retention dei backup è di tre giorni.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-db-instance \
2. --engine custom-oracle-ee-cdb \
3. --db-instance-identifier my-cfo-cdb-instance \
4. --engine-version 19.cdb_cev1 \
5. --db-name MYPDB \
6. --db-system-id MYCDB \
7. --allocated-storage 250 \
8. --db-instance-class db.m5.xlarge \
9. --db-subnet-group mydbsubnetgroup \
10. --master-username myuser \
11. --master-user-password mypassword \
12. --backup-retention-period 3 \
13. --port 8200 \
14. --kms-key-id my-kms-key \
15. --no-auto-minor-version-upgrade \
16. --custom-iam-instance-profile AWSRDSCustomInstanceProfile-us-east-1
```
Per Windows:
```
1. aws rds create-db-instance ^
2. --engine custom-oracle-ee-cdb ^
3. --db-instance-identifier my-cfo-cdb-instance ^
4. --engine-version 19.cdb_cev1 ^
5. --db-name MYPDB ^
6. --db-system-id MYCDB ^
7. --allocated-storage 250 ^
8. --db-instance-class db.m5.xlarge ^
9. --db-subnet-group mydbsubnetgroup ^
10. --master-username myuser ^
11. --master-user-password mypassword ^
12. --backup-retention-period 3 ^
13. --port 8200 ^
14. --kms-key-id my-kms-key ^
15. --no-auto-minor-version-upgrade ^
16. --custom-iam-instance-profile AWSRDSCustomInstanceProfile-us-east-1
```
Specifica una password diversa dal prompt mostrato qui come best practice per la sicurezza.
Ottenere informazioni sull'istanza tramite il comando `describe-db-instances`.
**Example**
```
1. aws rds describe-db-instances --db-instance-identifier my-cfo-cdb-instance
```
Il seguente output parziale mostra il motore, i gruppi di parametri e altre informazioni.
```
1. {
2. "DBInstanceIdentifier": "my-cfo-cdb-instance",
3. "DBInstanceClass": "db.m5.xlarge",
4. "Engine": "custom-oracle-ee-cdb",
5. "DBInstanceStatus": "available",
6. "MasterUsername": "admin",
7. "DBName": "MYPDB",
8. "DBSystemID": "MYCDB",
9. "Endpoint": {
10. "Address": "my-cfo-cdb-instance.abcdefghijkl.us-east-1.rds.amazonaws.com",
11. "Port": 1521,
12. "HostedZoneId": "A1B2CDEFGH34IJ"
13. },
14. "AllocatedStorage": 100,
15. "InstanceCreateTime": "2023-04-12T18:52:16.353000+00:00",
16. "PreferredBackupWindow": "08:46-09:16",
17. "BackupRetentionPeriod": 7,
18. "DBSecurityGroups": [],
19. "VpcSecurityGroups": [
20. {
21. "VpcSecurityGroupId": "sg-0a1bcd2e",
22. "Status": "active"
23. }
24. ],
25. "DBParameterGroups": [
26. {
27. "DBParameterGroupName": "default.custom-oracle-ee-cdb-19",
28. "ParameterApplyStatus": "in-sync"
29. }
30. ],
31. ...
```
## Considerazioni sull'architettura multilocazione
Se crei un’istanza database Amazon RDS Custom per Oracle con l’architettura multitenant Oracle (tipo di motore `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`), il database è un database container (CDB). Se non specifichi l’architettura multitenant Oracle, il database è un database tradizionale non CDB che utilizza il tipo di motore `custom-oracle-ee` o `custom-oracle-se2`. Un file non CDB non può contenere database collegabili (). PDBs Per ulteriori informazioni, consulta [Architettura dei database per Amazon RDS Custom per Oracle](custom-oracle.db-architecture.md).
Quando crei un'istanza CDB RDS Custom per Oracle, considera quanto segue:
+ Puoi creare un database multilocazione solo da una CEV Oracle Database 19c.
+ Puoi creare un’istanza CDB solo se la CEV utilizza il tipo di motore `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`.
+ Se crei un'istanza CDB utilizzando Standard Edition 2, il CDB può contenerne al massimo 3. PDBs
+ Per impostazione predefinita, il CDB viene denominato `RDSCDB`, che è anche l'ID di sistema Oracle (Oracle SID). È possibile scegliere un nome diverso.
+ Il tuo CDB contiene solo un PDB iniziale. Il nome predefinito del PDB è `ORCL`. Puoi scegliere un nome diverso per il PDB iniziale, ma il SID Oracle e il nome PDB non possono essere uguali.
+ RDS Custom for Oracle non fornisce per. APIs PDBs Per crearne altri PDBs, utilizzare il comando `CREATE PLUGGABLE DATABASE` Oracle SQL. RDS Custom for Oracle non limita il numero di elementi PDBs che è possibile creare. In generale, sei responsabile della creazione e della gestione PDBs, come in una distribuzione locale.
+ Non è possibile utilizzare RDS APIs per creare, modificare ed eliminare PDBs: è necessario utilizzare le istruzioni Oracle SQL. Quando si crea un PDB utilizzando Oracle SQL, si consiglia di scattare successivamente un'istantanea manuale nel caso in cui sia necessario eseguire il point-in-time ripristino (PITR).
+ Non puoi rinominare una versione esistente PDBs utilizzando Amazon APIs RDS. Inoltre, non è possibile rinominare il CDB utilizzando il comando `modify-db-instance`.
+ La modalità aperta per la root CDB è `READ WRITE` sul database primario e `MOUNTED` su un database di standby montato. RDS Custom for Oracle tenta di aprire tutto all' PDBs apertura del CDB. Se RDS Custom for Oracle non è in grado di aprire tutto PDBs, genera l'evento. `tenant database shutdown`
## Ruolo collegato ai servizi RDS Custom
Un *ruolo collegato al servizio* offre ad Amazon RDS Custom l'accesso alle risorse del tuo. Account AWS Ciò rende più semplice l’utilizzo di RDS Custom perché non si devono aggiungere manualmente le autorizzazioni necessarie. RDS Custom definisce le autorizzazioni dei ruoli associato ai servizi e, salvo diversamente definito, solo RDS Custom può assumere tali ruoli. Le autorizzazioni definite includono la policy di attendibilità e la policy delle autorizzazioni che non può essere collegata a nessun'altra entità IAM.
Quando crei un'istanza DB personalizzata RDS, vengono creati e utilizzati sia i ruoli collegati ai servizi (se non già esistenti) Amazon RDS che RDS Custom. Per ulteriori informazioni, consulta [Utilizzo di ruoli collegati ai servizi per Amazon RDS](UsingWithRDS.IAM.ServiceLinkedRoles.md).
La prima volta che crei un'istanza database RDS Custom per Oracle, potresti ricevere il seguente errore: Il ruolo collegato ai servizi è nel processo di creazione. Riprova più tardi. In questo caso, attendere alcuni minuti e riprovare a creare l'istanza database.
## Installazione di componenti software aggiuntivi sull'istanza database RDS Custom per Oracle
In un'istanza database appena creata, l'ambiente del database include foòe binari Oracle, un database e un ascoltatore di database. Potresti voler installare software aggiuntivo sul sistema operativo host dell'istanza database. Ad esempio, potresti voler installare Oracle Application Express (APEX), l'agente Oracle Enterprise Manager (OEM) o l'agente Guardium S-TAP. Per linee guida e istruzioni di alto livello, consulta il post dettagliato del AWS blog [Installa componenti software aggiuntivi su Amazon RDS Custom for](https://aws.amazon.com//blogs/database/install-additional-software-components-on-amazon-rds-custom-for-oracle/) Oracle.
# Connessione all'istanza database RDS Custom utilizzando Session Manager
Dopo aver creato l'istanza database RDS Custom, è possibile connettersi ad essa utilizzando AWS Systems Manager Session Manager. Questa è la tecnica preferita quando l'istanza database non è accessibile pubblicamente.
Session Manager consente di accedere alle istanze Amazon EC2 tramite una shell (interprete di comandi) basata su browser o tramite la AWS CLI. Per ulteriori informazioni, consulta [AWSSystems Manager Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).
## Console
**Per connettersi all'istanza database utilizzando Session Manager**
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)** e quindi scegliere l'istanza database RDS Custom a cui desideri connetterti.
1. Scegliere **Configuration (Configurazione)**.
1. Annota **Resource ID (Risorsa ID)**per l'istanza database. Ad esempio, l'ID risorsa potrebbe essere `db-ABCDEFGHIJKLMNOPQRS0123456`.
1. Aprire la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel pannello di navigazione, seleziona **Instances (Istanze)**.
1. Cerca il nome dell'istanza EC2, quindi fai clic sull'ID istanza associato con esso. Ad esempio, l'istanza ID potrebbe essere `i-abcdefghijklm01234`.
1. Scegli **Connetti**.
1. Scegli **Session Manager**.
1. Scegli **Connetti**.
Si apre una finestra per la sessione.
## AWS CLI
Puoi connettere l'istanza database RDS Custom tramite AWS CLI. Questa tecnica richiede il plugin Session Manager per AWS CLI. Per informazioni su come installare il plugin, consultare [Installare il plugin di Session Manager per AWS CLI](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html).
Per trovare l'ID della risorsa DB dell'istanza database RDS Custom, utilizzare `aws rds [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)`.
```
aws rds describe-db-instances \
--query 'DBInstances[*].[DBInstanceIdentifier,DbiResourceId]' \
--output text
```
Il seguente output di esempio mostra l'ID della risorsa per l'istanza RDS Custom. Il prefisso è `db-`.
```
db-ABCDEFGHIJKLMNOPQRS0123456
```
Per trovare l'ID dell'istanza EC2 della tua istanza database, utilizzare `aws ec2 describe-instances`. Nell'esempio seguente viene utilizzato `db-ABCDEFGHIJKLMNOPQRS0123456` per l'ID risorsa.
```
aws ec2 describe-instances \
--filters "Name=tag:Name,Values=db-ABCDEFGHIJKLMNOPQRS0123456" \
--output text \
--query 'Reservations[*].Instances[*].InstanceId'
```
L'output di esempio seguente mostra l'ID dell'istanza EC2.
```
i-abcdefghijklm01234
```
Utilizzo del comando `aws ssm start-session`, che fornisce l'ID istanza EC2 nel parametro `--target`.
```
aws ssm start-session --target "i-abcdefghijklm01234"
```
Se l'operazione riesce, la connessione sarà simile al seguente.
```
Starting session with SessionId: yourid-abcdefghijklm1234
[ssm-user@ip-123-45-67-89 bin]$
```
## Connessione all'istanza database RDS Custom tramite SSH
Secure Shell Protocol (SSH) è un protocollo di rete che supporta la comunicazione crittografata su una rete non protetta. Dopo aver creato l'istanza database RDS Custom, è possibile connettersi utilizzando un client SSH. Per ulteriori informazioni, consultare [Connessione all'istanza Linux tramite SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html).
La connessione SSH dipende dal fatto che l'istanza DB è privata, ovvero l'istanza non accetta connessioni dalla rete Internet pubblica. In questo caso, è necessario utilizzare il tunneling SSH per connettere l'utilità ssh alla propria istanza. Questa tecnica trasporta i dati con un flusso di dati dedicato (tunnel) all'interno di una sessione SSH esistente. È possibile configurare il tunneling SSH utilizzando AWS Systems Manager.
**Nota**
Sono supportate varie strategie per accedere alle istanze private. Per scoprire come connettere un client ssh a istanze private utilizzando gli host bastione, consulta [Host bastione Linux su AWS](https://aws.amazon.com/solutions/implementations/linux-bastion/). Per informazioni su come configurare la funzionalità di inoltro alla porta, consulta l'argomento relativo all'[inoltro alla porta tramite AWS Systems Manager Session Manager](https://aws.amazon.com/blogs/aws/new-port-forwarding-using-aws-system-manager-sessions-manager/).
Se l'istanza DB si trova in una sottorete pubblica e per tale istanza è stata abilitata l'opzione Disponibile pubblicamente, non è richiesto il tunneling SSH. Puoi connetterti tramite SSH con la stessa procedura usata per un'istanza Amazon EC2 pubblica.
Per connettere un client SSH all'istanza database, completa la procedura riportata di seguito:
1. [Fase 1: configurazione dell'istanza database per consentire connessioni SSH](#custom-managing.ssh.port-22)
1. [Fase 2: recupero della chiave segreta SSH e l'ID dell'istanza EC2](#custom-managing.ssh.obtaining-key)
1. [Fase 3: connettersi all’istanza EC2 con l’utilità ssh](#custom-managing.ssh.connecting)
### Fase 1: configurazione dell'istanza database per consentire connessioni SSH
Per assicurarti che l'istanza database accetti connessioni SSH, procedi nel modo seguente:
+ Assicurati che il gruppo di sicurezza dell'istanza database consenta le connessioni in entrata sulla porta 22 per TCP.
Per informazioni su come configurare il gruppo di sicurezza per l'istanza DB, consulta [Controllo dell'accesso con i gruppi di sicurezza](Overview.RDSSecurityGroups.md).
+ Se non prevedi di utilizzare il tunneling SSH, assicurati che l'istanza DB risieda in una sottorete pubblica e che sia accessibile al pubblico.
Nella console, il campo pertinente è **Disponibile pubblicamente** nella scheda **Connettività e sicurezza** della pagina dei dettagli del database. Per controllare le impostazioni nella CLI, esegui il comando riportato di seguito:
```
aws rds describe-db-instances \
--query 'DBInstances[*].{DBInstanceIdentifier:DBInstanceIdentifier,PubliclyAccessible:PubliclyAccessible}' \
--output table
```
Per modificare le impostazioni di accessibilità per l'istanza database, consulta [Modifica di un'istanza database Amazon RDS](Overview.DBInstance.Modifying.md).
### Fase 2: recupero della chiave segreta SSH e l'ID dell'istanza EC2
Per connettersi all'istanza database tramite SSH, è necessario disporre della coppia di chiavi SSH associata all'istanza. RDS Custom crea automaticamente la coppia di chiavi SSH utilizzando la convenzione di denominazione `do-not-delete-rds-custom-ssh-privatekey-resource_id-uuid` o `rds-custom!oracle-do-not-delete-resource_id-uuid-ssh-privatekey`. Gestione dei segreti AWS archivia la chiave privata SSH come segreto.
Recupera la tua chiave segreta SSH utilizzando uno o il. Console di gestione AWS AWS CLI Se l'istanza ha un DNS pubblico e non intendi utilizzare il tunneling SSH, recupera anche il nome DNS. Specifica il nome DNS delle connessioni pubbliche.
#### Console
**Per recuperare la chiave SSH segreta**
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)** e quindi scegliere l'istanza database RDS Custom a cui desideri connetterti.
1. Scegliere **Configuration (Configurazione)**.
1. Annota il valore **Resource ID (Risorsa ID)**. Ad esempio, l'ID risorsa dell'istanza DB potrebbe essere `db-ABCDEFGHIJKLMNOPQRS0123456`.
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nel riquadro di navigazione, scegliere **Instances (Istanze)**.
1. Trova il nome dell'istanza EC2 e scegli l'ID istanza associato con esso. Ad esempio, l'ID istanza EC2 potrebbe essere `i-abcdefghijklm01234`.
1. In **Details (Dettagli)**, trovare **Key pair name (Nome della coppia di chiavi)**. Il nome della coppia include l'ID risorsa dell'istanza DB. Ad esempio, il nome della coppia potrebbe essere `do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c` o `rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey`.
1. Se la tua istanza EC2 è pubblica, prendi nota del DNS **pubblico IPv4**. Ad esempio, l'indirizzo del Domain Name System (DNS) pubblico potrebbe essere `ec2-12-345-678-901.us-east-2.compute.amazonaws.com`.
1. Apri la Gestione dei segreti AWS console all'indirizzo. [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/)
1. Scegliere il segreto che ha lo stesso nome della tua coppia di chiavi.
1. Scegli **Retrieve secret value (Recupera il valore del segreto)**.
1. Copia la chiave SSH privata in un file di testo e salva il file con l'estensione `.pem`. Ad esempio, salva il file come `/tmp/do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem` o `/tmp/rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem`.
#### AWS CLI
Per recuperare la chiave SSH privata e salvarla in un file .pem, puoi usare la AWS CLI.
1. Cerca l'ID risorsa dell'istanza database RDS Custom tramite `aws rds [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)`.
```
aws rds describe-db-instances \
--query 'DBInstances[*].[DBInstanceIdentifier,DbiResourceId]' \
--output text
```
Il seguente output di esempio mostra l'ID della risorsa per l'istanza RDS Custom. Il prefisso è `db-`.
```
db-ABCDEFGHIJKLMNOPQRS0123456
```
1. Cerca l'ID dell'istanza EC2 dell'istanza database tramite `aws ec2 describe-instances`. Nell'esempio seguente viene utilizzato `db-ABCDEFGHIJKLMNOPQRS0123456` per l'ID risorsa.
```
aws ec2 describe-instances \
--filters "Name=tag:Name,Values=db-ABCDEFGHIJKLMNOPQRS0123456" \
--output text \
--query 'Reservations[*].Instances[*].InstanceId'
```
L'output di esempio seguente mostra l'ID dell'istanza EC2.
```
i-abcdefghijklm01234
```
1. Per trovare il nome chiave, specifica l'ID istanza EC2. L’esempio seguente descrive l’istanza EC2 `i-0bdc4219e66944afa`.
```
aws ec2 describe-instances \
--instance-ids i-0bdc4219e66944afa \
--output text \
--query 'Reservations[*].Instances[*].KeyName'
```
Il seguente output di esempio mostra il nome della chiave, che utilizza il formato di denominazione `do-not-delete-rds-custom-ssh-privatekey-resource_id-uuid` o `rds-custom!oracle-do-not-delete-resource_id-uuid-ssh-privatekey`.
```
do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c
rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey
```
1. Salva la chiave privata in un file .pem avente lo stesso nome della chiave tramite `aws secretsmanager`.
Nell’esempio seguente, la chiave `do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c` viene salvata in un file nella directory `/tmp`.
```
aws secretsmanager get-secret-value \
--secret-id do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c \
--query SecretString \
--output text >/tmp/do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem
```
Nell’esempio seguente, la chiave `rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey` viene salvata in un file nella directory `/tmp`.
```
aws secretsmanager get-secret-value \
--secret-id rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey \
--query SecretString \
--output text >/tmp/rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem
```
### Fase 3: connettersi all’istanza EC2 con l’utilità ssh
La tecnica di connessione dipende dalla connessione a un'istanza DB privata o a un'istanza pubblica. Una connessione privata richiede la configurazione del tunneling SSH tramite AWS Systems Manager.
**Per connettersi all'istanza EC2 tramite l'utility ssh**
1. Per le connessioni private, modifica il file di configurazione SSH per i comandi proxy impostando AWS Systems Manager Session Manager. Per le connessioni pubbliche, esegui la fase 2.
Aggiungi le righe seguenti a `~/.ssh/config`. Queste righe eseguono i comandi SSH in modalità proxy per gli host i cui nomi iniziano con `i-` o `mi-`.
```
Host i-* mi-*
ProxyCommand sh -c "aws ssm start-session --target %h --document-name AWS-StartSSHSession --parameters 'portNumber=%p'"
```
1. Passare alla directory che contiene il file .pem. Tramite `chmod`, imposta le autorizzazioni su `400`.
L’esempio seguente passa alla directory `/tmp` e imposta le autorizzazioni per il file .pem `do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem`.
```
cd /tmp
chmod 400 do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem
```
L’esempio seguente passa alla directory `/tmp` e imposta le autorizzazioni per il file .pem `rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem`.
```
cd /tmp
chmod 400 rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem
```
1. Esegui l'utilità ssh, specificando il file. pem e il nome DNS pubblico (per le connessioni pubbliche) o l'ID dell'istanza EC2 (per le connessioni private). Accedi come utente `ec2-user`.
L’esempio seguente stabilisce una connessione a un’istanza pubblica utilizzando il nome DNS `ec2-12-345-678-901.us-east-2.compute.amazonaws.com`.
```
# .pem file using naming prefix do-not-delete
ssh -i \
"do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem" \
ec2-user@ec2-12-345-678-901.us-east-2.compute.amazonaws.com
# .pem file using naming prefix rds-custom!oracle-do-not-delete
ssh -i \
"rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem" \
ec2-user@ec2-12-345-678-901.us-east-2.compute.amazonaws.com
```
L’esempio seguente stabilisce una connessione a un’istanza privata utilizzando l’ID istanza EC2 `i-0bdc4219e66944afa`.
```
# .pem file using naming prefix do-not-delete
ssh -i \
"do-not-delete-rds-custom-ssh-privatekey-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c.pem" \
ec2-user@i-0bdc4219e66944afa
# .pem file using naming prefix rds-custom!oracle-do-not-delete
ssh -i \
"rds-custom!oracle-do-not-delete-db-ABCDEFGHIJKLMNOPQRS0123456-0d726c-ssh-privatekey.pem" \
ec2-user@i-0bdc4219e66944afa
```
# Accesso al database RDS Custom per Oracle come SYS
Dopo aver creato l'istanza database RDS Custom, è possibile accedere al database Oracle come utente `SYS`, ruolo che dispone dei privilegi `SYSDBA`. Sono disponibili le seguenti opzioni di accesso:
+ Recupera la password `SYS` da Secrets Manager e specificala nel client SQL.
+ Usa l'autenticazione del sistema operativo per accedere al database. In questo caso, non è necessario inserire una password.
## Individuazione della password SYS per il database RDS Custom per Oracle
È possibile accedere al database Oracle come `SYS` o `SYSTEM` o specificando il nome utente principale in una chiamata API. La password per `SYS` e `SYSTEM` è archiviata in Secrets Manager.
Il segreto utilizza il formato di denominazione `do-not-delete-rds-custom-resource_id-uuid` o `rds-custom!oracle-do-not-delete-resource_id-uuid`. Puoi cercare la password usando la Console di gestione AWS.
### Console
**Per cercare la password SYS per il tuo database in Secrets Manager**
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. Utilizzando la console RDS esegui i passaggi seguenti:
1. Nel pannello di navigazione, seleziona **Database**.
1. Scegli il nome dell'istanza database RDS Custom per Oracle.
1. Scegliere **Configuration (Configurazione)**.
1. Copia il valore riportato sotto **ID risorsa**. Ad esempio, l'ID della risorsa potrebbe essere **db- ABC12 CDE3 FGH4 JKLMNO6 PQR7 I5**.
1. Apri la console Secrets Manager all'indirizzo [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).
1. Utilizzando la console Secrets Manager esegui i passaggi seguenti:
1. Nel pannello di navigazione a sinistra, seleziona **Segreti**.
1. Filtra i segreti in base all’ID risorsa copiato nel passaggio 2.d.
1. **Scegli il segreto che utilizza il formato di denominazione **do-not-delete-rds-custom- *resource\$1id* - *uuid*** o rds-custom\$1 oracle-do-not-delete- -. *resource\$1id* *uuid*** *resource\$1id*È l'ID della risorsa che hai copiato nel passaggio 2.d.
**Ad esempio, se l'ID della risorsa è **db- ABC12 CDE3 FGH4 I5 JKLMNO6 PQR7** e l'UUID è **1234ab, il segreto è denominato do-not-delete-rds -custom-db- I5 -1234ab** o rds-custom\$1 ABC12 CDE3 FGH4 JKLMNO6 PQR7** ** oracle-do-not-delete-db- I5 -1234ab. ABC12 CDE3 FGH4 JKLMNO6 PQR7**
1. Nella sezione **Valore segreto**, scegli **Recupera il valore di un segreto**.
1. In **Chiave/valore**, copia il valore del campo **Password**.
1. Installa SQL\$1Plus sull'istanza DB e accedi al database come `SYS`. Per ulteriori informazioni, consulta [Fase 3: connessione del client SQL a un'istanza database Oracle.](CHAP_GettingStarted.CreatingConnecting.Oracle.md#CHAP_GettingStarted.Connecting.Oracle).
## Accesso al database RDS Custom per Oracle utilizzando l'autenticazione del sistema operativo
L'utente del sistema operativo `rdsdb` possiede i file binari del database Oracle. È possibile passare all'utente `rdsdb` e accedere al database RDS Custom per Oracle senza password.
1. Connect alla propria istanza DB con AWS Systems Manager. Per ulteriori informazioni, consulta [Connessione all'istanza database RDS Custom utilizzando Session Manager](custom-creating.ssm.md).
1. Passa all'utente `rdsdb`.
```
sudo su - rdsdb
```
1. Accedi al database utilizzando l'autenticazione del sistema operativo. È possibile utilizzare `sqlplus / as sysdba` o l’alias `sql`.
```
$ sqlplus / as sysdba
SQL*Plus: Release 21.0.0.0.0 - Production on Wed Apr 12 20:11:08 2023
Version 21.9.0.0.0
Copyright (c) 1982, 2020, Oracle. All rights reserved.
Connected to:
Oracle Database 19c Enterprise Edition Release 19.0.0.0.0 - Production
Version 19.10.0.0.0
```
In alternativa, è possibile utilizzare l’alias `sql`.
```
$ sql
```