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à.
# Utilizzo di versioni del motore personalizzate per Amazon RDS Custom per Oracle
Una *versione del motore personalizzato (CEV)*per Amazon RDS Custom per Oracle è una snapshot del volume binario di un motore di database e di una specifica Amazon Machine Image (AMI). Per impostazione predefinita, RDS Custom per Oracle utilizza l'AMI più recente disponibile gestita da RDS Custom, ma puoi specificare un'AMI utilizzata in una CEV precedente. Archiviare i file di installazione del database in Amazon S3. RDS Custom utilizza i file di installazione e l'AMI per creare automaticamente la CEV.
**Topics**
+ [Preparazione alla creazione di un CEV](custom-cev.preparing.md)
+ [Creazione di un CEV](custom-cev.create.md)
+ [Modifica dello stato del CEV](custom-cev.modify.md)
+ [Visualizzazione dei dettagli della CEV per Amazon RDS Custom per Oracle](custom-cev.view.md)
+ [Eliminazione di un CEV](custom-cev.delete.md)
# Preparazione alla creazione di un CEV
Per creare un CEV, accedi ai file di installazione e alle patch archiviati nel bucket Amazon S3 per una delle seguenti versioni:
+ Oracle Database 19c
+ Oracle Database 18c
+ Oracle Database 12c Release 2 (12.2)
+ Oracle Database 12c Release 1 (12.1)
Ad esempio, puoi utilizzare April 2021 RU/RUR per Oracle Database 19c o qualsiasi combinazione valida di file di installazione e patch. Per ulteriori informazioni sulle versioni e sulle regioni supportate da RDS Custom per Oracle, consulta [RDS Custom con RDS per Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.html#Concepts.RDS_Fea_Regions_DB-eng.Feature.RDSCustom.ora).
**Topics**
+ [Fase 1 (facoltativo): download dei modelli di manifesto](#custom-cev.preparing.templates)
+ [Fase 2: download di file e patch di installazione del database da Oracle Software Delivery Cloud](#custom-cev.preparing.download)
+ [Fase 3: caricamento dei file di installazione in Amazon S3](#custom-cev.preparing.s3)
+ [Passaggio 4 (facoltativo): condividi i supporti di installazione in S3 su Account AWS](#custom-cev.preparing.accounts)
+ [Fase 5: preparazione del manifesto CEV](#custom-cev.preparing.manifest)
+ [Fase 6 (facoltativo): convalida del manifesto CEV](#custom-cev.preparing.validating)
+ [Fase 7: aggiunta delle autorizzazioni IAM necessarie](#custom-cev.preparing.iam)
## Fase 1 (facoltativo): download dei modelli di manifesto
Un *manifesto CEV* è un documento JSON che include l'elenco dei file di installazione del database in formato .zip per la tua CEV. Per creare una CEV, procedi come descritto qui di seguito:
1. Individua i file di installazione del database Oracle che desideri includere nella CEV.
1. Scarica i file di installazione.
1. Crea un manifesto JSON contenente l'elenco dei file di installazione.
RDS Custom per Oracle fornisce modelli di manifesto JSON con i file .zip consigliati per ogni versione supportata del database Oracle. Ad esempio, il seguente modello è per la RU 19.17.0.0.0.
```
{
"mediaImportTemplateVersion": "2020-08-14",
"databaseInstallationFileNames": [
"V982063-01.zip"
],
"opatchFileNames": [
"p6880880_190000_Linux-x86-64.zip"
],
"psuRuPatchFileNames": [
"p34419443_190000_Linux-x86-64.zip",
"p34411846_190000_Linux-x86-64.zip"
],
"otherPatchFileNames": [
"p28852325_190000_Linux-x86-64.zip",
"p29997937_190000_Linux-x86-64.zip",
"p31335037_190000_Linux-x86-64.zip",
"p32327201_190000_Linux-x86-64.zip",
"p33613829_190000_Linux-x86-64.zip",
"p34006614_190000_Linux-x86-64.zip",
"p34533061_190000_Linux-x86-64.zip",
"p34533150_190000_Generic.zip",
"p28730253_190000_Linux-x86-64.zip",
"p29213893_1917000DBRU_Generic.zip",
"p33125873_1917000DBRU_Linux-x86-64.zip",
"p34446152_1917000DBRU_Linux-x86-64.zip"
]
}
```
A ogni modello è associato un file readme che include le istruzioni per scaricare le patch, URLs i file.zip e i checksum dei file. Puoi usare questi modelli così come sono o modificarli con le tue patch. Per rivedere i modelli, scaricate il [custom-oracle-manifestfile.zip](samples/custom-oracle-manifest.zip) sul disco locale e apritelo con un'applicazione per l'archiviazione dei file. Per ulteriori informazioni, consulta [Fase 5: preparazione del manifesto CEV](#custom-cev.preparing.manifest).
## Fase 2: download di file e patch di installazione del database da Oracle Software Delivery Cloud
Dopo aver individuato i file di installazione per la tua CEV, scaricali sul tuo sistema locale. I file di installazione e le patch di Oracle Database sono ospitati su Oracle Software Delivery Cloud. Ogni CEV richiede una versione di base, ad esempio Oracle Database 19c Release 2 (12.2) e un elenco facoltativo di patch.
**Per scaricare i file di installazione del database per Oracle Database**
1. Andare su [https://edelivery.oracle.com/](https://edelivery.oracle.com/) e accedere.
1. Nella casella di ricerca, inserisci **Oracle Database Enterprise Edition** o **Oracle Database Standard Edition 2** e scegli **Cerca**.
1. Seleziona una delle seguenti versioni base:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/custom-cev.preparing.html)
1. Scegli **Continua**.
1. Deseleziona la casella di controllo **Download Queue (Scarica coda)**.
1. Seleziona l'opzione che corrisponde alla versione di base:
+ **Oracle Database 19.3.0.0.0: versione a lungo termine**
+ **Oracle Database 18.0.0.0.0**
+ **Oracle Database 12.2.0.1.0**
+ **Oracle Database 12.1.0.2.0**
1. Scegli **Linux x86-64** in **Piattaforma/lingue**.
1. Scegli **Continua**, quindi firma il contratto di licenza Oracle.
1. Seleziona il file .zip corrispondente alla versione del database:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/custom-cev.preparing.html)
1. Scarica le patch Oracle desiderate da `updates.oracle.com` o `support.oracle.com` nel tuo sistema locale. È possibile trovare URLs le patch nelle seguenti posizioni:
+ I file Readme contenuti nel file. zip scaricato in [Fase 1 (facoltativo): download dei modelli di manifesto](#custom-cev.preparing.templates)
+ Le patch elencate in ciascun RU (Release Update, aggiornamento rilascio) riportato nella pagina relativa alle [note di rilascio per Amazon Relational Database Service (Amazon RDS) per Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes)
## Fase 3: caricamento dei file di installazione in Amazon S3
Caricare i file di installazione e patch Oracle in Amazon S3 tramite AWS CLI. Il bucket S3 che contiene i file di installazione deve trovarsi nella stessa AWS regione del CEV.
Gli esempi in questa sezione utilizzano i seguenti segnaposto:
+ `install-or-patch-file.zip` – File multimediale di installazione Oracle. Ad esempio, p32126828\$1190000\$1Linux-x86-64.zip è una patch.
+ `amzn-s3-demo-destination-bucket` – Il bucket Amazon S3 designato per i file di installazione caricati.
+ `123456789012/cev1` – Un prefisso opzionale nel bucket Amazon S3.
+ `amzn-s3-demo-source-bucket` – Un bucket Amazon S3 in cui è possibile facoltativamente organizzare i file.
**Topics**
+ [Passaggio 3a: verifica che il bucket S3 sia nella posizione corretta Regione AWS](#custom-cev.preparing.s3.verify-region)
+ [Fase 3b: verifica delle autorizzazioni corrette della policy del bucket S3](#custom-cev.preparing.s3.verify-policy)
+ [Fase 3c: caricamento dei file utilizzando i comandi cp o sync](#custom-cev.preparing.s3.upload)
+ [Fase 3d: elenco dei file nel bucket S3](#custom-cev.preparing.s3.list)
### Passaggio 3a: verifica che il bucket S3 sia nella posizione corretta Regione AWS
Verifica che il bucket S3 si trovi nella AWS regione in cui intendi eseguire il comando. `create-custom-db-engine-version`
```
aws s3api get-bucket-location --bucket amzn-s3-demo-destination-bucket
```
### Fase 3b: verifica delle autorizzazioni corrette della policy del bucket S3
È possibile creare una CEV da zero o da una CEV di origine. Se prevedi di creare un nuovo CEV dal codice sorgente CEVs, assicurati che la tua policy sui bucket S3 disponga delle autorizzazioni corrette:
1. Identifica il bucket S3 riservato da RDS Custom. Il formato del nome del bucket è `do-not-delete-rds-custom-account-region-string`. Ad esempio, il nome del bucket potrebbe essere `do-not-delete-rds-custom-123456789012-us-east-1-abc123EXAMPLE`.
1. Assicurati che la seguente autorizzazione sia aggiunta alla policy dei bucket S3. Sostituisci `do-not-delete-rds-custom-123456789012-us-east-1-abc123EXAMPLE` con il nome del tuo bucket.
```
{
"Sid": "AWSRDSCustomForOracleCustomEngineVersionGetObject",
"Effect": "Allow",
"Principal": {
"Service": "custom.rds.amazonaws.com"
},
"Action": [
"s3:GetObject",
"s3:GetObjectTagging"
],
"Resource": "arn:aws:s3:::do-not-delete-rds-custom-123456789012-us-east-1-abc123EXAMPLE/CustomEngineVersions/*"
}, ...
```
### Fase 3c: caricamento dei file utilizzando i comandi cp o sync
Seleziona una delle seguenti opzioni:
+ Utilizza `aws s3 cp` per caricare un singolo file.zip.
Carica ogni file con estensione zip di installazione separatamente. Non combinare i file.zip in un singolo file.zip.
+ Utilizza `aws s3 sync` per caricare una directory.
**Example**
Viene caricato l'esempio `install-or-patch-file.zip` riportato di seguito nella cartella `123456789012/cev1` nel bucket Amazon S3 RDS Custom. Esegui un comando `aws s3` separato per ogni .zip che si desidera caricare.
Per Linux, macOS o Unix:
```
1. aws s3 cp install-or-patch-file.zip \
2. s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Per Windows:
```
1. aws s3 cp install-or-patch-file.zip ^
2. s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
**Example**
L'esempio seguente carica i file nella cartella locale *cev1* nella *123456789012/cev1* cartella del bucket Amazon S3.
Per Linux, macOS o Unix:
```
aws s3 sync cev1 \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Per Windows:
```
aws s3 sync cev1 ^
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
**Example**
Nel seguente esempio vengono caricati tutti i file in `amzn-s3-demo-source-bucket` nella cartella **`123456789012/cev1`** nel bucket Amazon S3.
Per Linux, macOS o Unix:
```
aws s3 sync s3://amzn-s3-demo-source-bucket/ \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Per Windows:
```
aws s3 sync s3://amzn-s3-demo-source-bucket/ ^
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
### Fase 3d: elenco dei file nel bucket S3
L'esempio seguente utilizza il comando `s3 ls` per elencare i file nel bucket S3 Amazon RDS Custom.
```
aws s3 ls \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
## Passaggio 4 (facoltativo): condividi i supporti di installazione in S3 su Account AWS
Ai fini di questa sezione, il bucket Amazon S3 che contiene i file di installazione Oracle caricati è il *bucket dei file di installazione*. La tua organizzazione potrebbe utilizzarne più di uno Account AWS in un Regione AWS. In tal caso, potresti volerne usare uno Account AWS per popolare il tuo bucket multimediale e un altro Account AWS per crearlo. CEVs Se non desideri condividere il bucket dei file di installazione, passa alla sezione successiva.
In questa sezione si presuppone quanto segue:
+ Puoi accedere all'account che ha creato il tuo bucket multimediale e a un altro account con cui intendi crearlo. CEVs
+ Intendi crearlo CEVs in uno Regione AWS solo. Se intendi utilizzare più regioni, crea un bucket dei file di installazione in ciascuna regione.
+ Stai usando la CLI. Se stai utilizzando la console Amazon S3, procedi nel seguente modo:
**Per configurare il tuo bucket multimediale per la condivisione su Account AWS**
1. Accedi al bucket S3 Account AWS che contiene il bucket S3 in cui hai caricato il supporto di installazione.
1. Inizia con un modello di policy JSON vuoto o con una policy esistente che puoi adattare.
Il comando seguente recupera una politica esistente e la salva come. *my-policy.json* In questo esempio, viene denominato il bucket S3 contenente i file di installazione. *amzn-s3-demo-bucket*
```
aws s3api get-bucket-policy \
--bucket amzn-s3-demo-bucket \
--query Policy \
--output text > my-policy.json
```
1. Modifica le autorizzazioni del bucket dei file di installazione come segue:
+ Nell'elemento `Resource` del modello, specifica il bucket S3 in cui hai caricato i file di installazione di Oracle Database.
+ Nell'`Principal`elemento, specificate ARNs for all Account AWS che intendete utilizzare per creare. CEVs Puoi aggiungere il root, un utente o un ruolo all'elenco degli indirizzi consentiti del bucket S3. Per ulteriori informazioni, consultare [Identificatori IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html) nella *Guida per l'utente di AWS Identity and Access Management *.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GrantAccountsAccess",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::111122223333:root",
"arn:aws:iam::444455556666:user/user-name-with-path",
"arn:aws:iam::123456789012:role/role-name-with-path"
]
},
"Action": [
"s3:GetObject",
"s3:GetObjectAcl",
"s3:GetObjectTagging",
"s3:ListBucket",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
}
]
}
```
------
1. Collega la policy al bucket dei file di installazione.
Nell'esempio seguente, *amzn-s3-demo-bucket* è il nome del bucket S3 che contiene i file di installazione ed *my-policy.json* è il nome del file JSON.
```
aws s3api put-bucket-policy \
--bucket amzn-s3-demo-bucket \
--policy file://my-policy.json
```
1. Accedi a un file Account AWS in cui intendi creare. CEVs
1. Verifica che questo account possa accedere al bucket multimediale nel quale Account AWS è stato creato.
```
aws s3 ls --query "Buckets[].Name"
```
Per ulteriori informazioni, consulta [aws s3 ls](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html) nel *Riferimento ai comandi della AWS CLI Command Reference*.
1. Crea un CEV seguendo i passaggi descritti in [Creazione di un CEV](custom-cev.create.md).
## Fase 5: preparazione del manifesto CEV
Un manifesto CEV è un documento JSON che include quanto segue:
+ (Obbligatorio) L'elenco dei file .zip di installazione caricati in Amazon S3. RDS Custom applica le patch nell'ordine in cui sono elencate nel manifesto.
+ (Facoltativo) Parametri di installazione che impostano valori non predefiniti per Oracle base, Oracle home e l'ID e il nome dell' UNIX/Linux utente e del gruppo. Tieni presente che non puoi modificare i parametri di installazione per una CEV esistente o un'istanza database esistente. Inoltre, non è possibile eseguire l'aggiornamento da una CEV a un'altra quando i parametri di installazione hanno impostazioni diverse.
Per esempi di manifesti CEV, consulta i modelli JSON scaricati in [Fase 1 (facoltativo): download dei modelli di manifesto](#custom-cev.preparing.templates). Puoi esaminare gli esempi in [Esempi di manifesto CEV](#custom-cev.preparing.manifest.examples).
**Topics**
+ [Campi JSON nel manifesto CEV](#custom-cev.preparing.manifest.fields)
+ [Creazione del manifest CEV](#custom-cev.preparing.manifest.creating)
+ [Esempi di manifesto CEV](#custom-cev.preparing.manifest.examples)
### Campi JSON nel manifesto CEV
La seguente tabella descrive i campi JSON nel manifest.
| Campo JSON | Description |
| --- | --- |
| `MediaImportTemplateVersion` | Versione del manifest CEV. Il formato della data è `YYYY-MM-DD`. |
| `databaseInstallationFileNames` | Elenco ordinato dei file di installazione per il database. |
| `opatchFileNames` | Elenco ordinato degli OPatch installatori utilizzati per il motore Oracle DB. È valido solo un valore. I valori per `opatchFileNames` devono iniziare con `p6880880_`. |
| `psuRuPatchFileNames` | Patch PSU e RU per questo database. Se includi `psuRuPatchFileNames`, `opatchFileNames` è obbligatorio. I valori per `opatchFileNames` devono iniziare con `p6880880_`. |
| `OtherPatchFileNames` | Le patch che non sono incluse nell'elenco delle patch PSU e RU. RDS Custom applica queste patch dopo aver applicato le patch PSU e RU. Se includi `OtherPatchFileNames`, `opatchFileNames` è obbligatorio. I valori per `opatchFileNames` devono iniziare con `p6880880_`. |
| `installationParameters` | Impostazioni non predefinite per Oracle base, Oracle home e l'ID e il nome dell' UNIX/Linux utente e del gruppo. Puoi impostare i seguenti parametri: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/custom-cev.preparing.html) |
Ogni versione di Oracle Database ha un elenco diverso di file di installazione supportati. Quando crei il manifesto CEV, assicurati di specificare solo i file supportati da RDS Custom per Oracle. In caso contrario, la creazione di CEV ha esito negativo e restituisce un errore. Sono supportate tutte le patch riportate nella pagina relativa alle [note di rilascio per Amazon Relational Database Service (Amazon RDS) per Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes)
### Creazione del manifest CEV
**Per creare un manifesto CEV**
1. Elenca tutti i file di installazione da applicare nell'ordine desiderato.
1. Associa i file di installazione ai campi JSON descritti in [Campi JSON nel manifesto CEV](#custom-cev.preparing.manifest.fields).
1. Esegui una delle operazioni seguenti:
+ Crea il manifesto CEV come file di testo JSON.
+ Modifica il modello di manifesto CEV quando crei il CEV nella console. Per ulteriori informazioni, consulta [Creazione di un CEV](custom-cev.create.md).
### Esempi di manifesto CEV
Gli esempi seguenti mostrano i file manifesto CEV per diverse versioni di Oracle Database. Se includi un campo JSON nel manifesto, assicurati che non sia vuoto. Ad esempio, il manifesto seguente non è valido perché `otherPatchFileNames` è vuoto.
```
{
"mediaImportTemplateVersion": "2020-08-14",
"databaseInstallationFileNames": [
"V982063-01.zip"
],
"opatchFileNames": [
"p6880880_190000_Linux-x86-64.zip"
],
"psuRuPatchFileNames": [
"p32126828_190000_Linux-x86-64.zip"
],
"otherPatchFileNames": [
]
}
```
**Argomenti**
+ [Sample CEV manifest for Oracle Database 12c Release 1 (12.1)](#oracle-cev-manifest-12.1)
+ [Sample CEV manifest for Oracle Database 12c Release 2 (12.2)](#oracle-cev-manifest-12.2)
+ [Sample CEV manifest for Oracle Database 18c](#oracle-cev-manifest-18c)
+ [Sample CEV manifest for Oracle Database 19c](#oracle-cev-manifest-19c)
**Example Esempio di manifesto CEV per Oracle Database 12c Release 1 (12.1)**
Nell'esempio seguente per la PSU di luglio 2021 per Oracle Database 12c Release 1 (12.1), RDS Custom applica le patch nell'ordine specificato. Pertanto, RDS Custom applica p32768233, p32876425, quindi p18759211 e così via. L'esempio imposta nuovi valori per l'utente e il gruppo UNIX, la home Oracle e la base Oracle.
```
{
"mediaImportTemplateVersion":"2020-08-14",
"databaseInstallationFileNames":[
"V46095-01_1of2.zip",
"V46095-01_2of2.zip"
],
"opatchFileNames":[
"p6880880_121010_Linux-x86-64.zip"
],
"psuRuPatchFileNames":[
"p32768233_121020_Linux-x86-64.zip"
],
"otherPatchFileNames":[
"p32876425_121020_Linux-x86-64.zip",
"p18759211_121020_Linux-x86-64.zip",
"p19396455_121020_Linux-x86-64.zip",
"p20875898_121020_Linux-x86-64.zip",
"p22037014_121020_Linux-x86-64.zip",
"p22873635_121020_Linux-x86-64.zip",
"p23614158_121020_Linux-x86-64.zip",
"p24701840_121020_Linux-x86-64.zip",
"p25881255_121020_Linux-x86-64.zip",
"p27015449_121020_Linux-x86-64.zip",
"p28125601_121020_Linux-x86-64.zip",
"p28852325_121020_Linux-x86-64.zip",
"p29997937_121020_Linux-x86-64.zip",
"p31335037_121020_Linux-x86-64.zip",
"p32327201_121020_Linux-x86-64.zip",
"p32327208_121020_Generic.zip",
"p17969866_12102210119_Linux-x86-64.zip",
"p20394750_12102210119_Linux-x86-64.zip",
"p24835919_121020_Linux-x86-64.zip",
"p23262847_12102201020_Linux-x86-64.zip",
"p21171382_12102201020_Generic.zip",
"p21091901_12102210720_Linux-x86-64.zip",
"p33013352_12102210720_Linux-x86-64.zip",
"p25031502_12102210720_Linux-x86-64.zip",
"p23711335_12102191015_Generic.zip",
"p19504946_121020_Linux-x86-64.zip"
],
"installationParameters": {
"unixGroupName": "dba",
"unixGroupId": 12345,
"unixUname": "oracle",
"unixUid": 12345,
"oracleHome": "/home/oracle/oracle.12.1.0.2",
"oracleBase": "/home/oracle"
}
}
```
**Example Esempio di manifesto CEV per Oracle Database 12c Release 2 (12.2)**
Nell'esempio seguente per la PSU di ottobre 2021 per Oracle Database 12c Release 2 (12.2), RDS Custom applica p33261817, p33192662, quindi p29213893 e così via. L'esempio imposta nuovi valori per l'utente e il gruppo UNIX, la home Oracle e la base Oracle.
```
{
"mediaImportTemplateVersion":"2020-08-14",
"databaseInstallationFileNames":[
"V839960-01.zip"
],
"opatchFileNames":[
"p6880880_122010_Linux-x86-64.zip"
],
"psuRuPatchFileNames":[
"p33261817_122010_Linux-x86-64.zip"
],
"otherPatchFileNames":[
"p33192662_122010_Linux-x86-64.zip",
"p29213893_122010_Generic.zip",
"p28730253_122010_Linux-x86-64.zip",
"p26352615_12201211019DBOCT2021RU_Linux-x86-64.zip",
"p23614158_122010_Linux-x86-64.zip",
"p24701840_122010_Linux-x86-64.zip",
"p25173124_122010_Linux-x86-64.zip",
"p25881255_122010_Linux-x86-64.zip",
"p27015449_122010_Linux-x86-64.zip",
"p28125601_122010_Linux-x86-64.zip",
"p28852325_122010_Linux-x86-64.zip",
"p29997937_122010_Linux-x86-64.zip",
"p31335037_122010_Linux-x86-64.zip",
"p32327201_122010_Linux-x86-64.zip",
"p32327208_122010_Generic.zip"
],
"installationParameters": {
"unixGroupName": "dba",
"unixGroupId": 12345,
"unixUname": "oracle",
"unixUid": 12345,
"oracleHome": "/home/oracle/oracle.12.2.0.1",
"oracleBase": "/home/oracle"
}
}
```
**Example Esempio di manifesto CEV per Oracle Database 18c**
Nell'esempio seguente per la PSU di ottobre 2021 per Oracle Database 18c, RDS Custom applica p32126855, p28730253, quindi p27539475 e così via. L'esempio imposta nuovi valori per l'utente e il gruppo UNIX, la home Oracle e la base Oracle.
```
{
"mediaImportTemplateVersion":"2020-08-14",
"databaseInstallationFileNames":[
"V978967-01.zip"
],
"opatchFileNames":[
"p6880880_180000_Linux-x86-64.zip"
],
"psuRuPatchFileNames":[
"p32126855_180000_Linux-x86-64.zip"
],
"otherPatchFileNames":[
"p28730253_180000_Linux-x86-64.zip",
"p27539475_1813000DBRU_Linux-x86-64.zip",
"p29213893_180000_Generic.zip",
"p29374604_1813000DBRU_Linux-x86-64.zip",
"p29782284_180000_Generic.zip",
"p28125601_180000_Linux-x86-64.zip",
"p28852325_180000_Linux-x86-64.zip",
"p29997937_180000_Linux-x86-64.zip",
"p31335037_180000_Linux-x86-64.zip",
"p31335142_180000_Generic.zip"
]
"installationParameters": {
"unixGroupName": "dba",
"unixGroupId": 12345,
"unixUname": "oracle",
"unixUid": 12345,
"oracleHome": "/home/oracle/18.0.0.0.ru-2020-10.rur-2020-10.r1",
"oracleBase": "/home/oracle/"
}
}
```
**Example Esempio di manifesto CEV per Oracle Database 19c**
Nell'esempio seguente per Oracle Database 19c, RDS Custom applica p32126828, quindi p29213893, quindi p29782284 e così via. L'esempio imposta nuovi valori per l'utente e il gruppo UNIX, la home Oracle e la base Oracle.
```
{
"mediaImportTemplateVersion": "2020-08-14",
"databaseInstallationFileNames": [
"V982063-01.zip"
],
"opatchFileNames": [
"p6880880_190000_Linux-x86-64.zip"
],
"psuRuPatchFileNames": [
"p32126828_190000_Linux-x86-64.zip"
],
"otherPatchFileNames": [
"p29213893_1910000DBRU_Generic.zip",
"p29782284_1910000DBRU_Generic.zip",
"p28730253_190000_Linux-x86-64.zip",
"p29374604_1910000DBRU_Linux-x86-64.zip",
"p28852325_190000_Linux-x86-64.zip",
"p29997937_190000_Linux-x86-64.zip",
"p31335037_190000_Linux-x86-64.zip",
"p31335142_190000_Generic.zip"
],
"installationParameters": {
"unixGroupName": "dba",
"unixGroupId": 12345,
"unixUname": "oracle",
"unixUid": 12345,
"oracleHome": "/home/oracle/oracle.19.0.0.0.ru-2020-04.rur-2020-04.r1.EE.1",
"oracleBase": "/home/oracle"
}
}
```
## Fase 6 (facoltativo): convalida del manifesto CEV
Facoltativamente, verificare che manifest sia un file JSON valido eseguendo lo script Python `json.tool`. Ad esempio, se si passa alla directory contenente un manifest CEV denominato `manifest.json`, esegui il comando riportato di seguito.
```
python -m json.tool < manifest.json
```
## Fase 7: aggiunta delle autorizzazioni IAM necessarie
Verifica che il principale IAM che crea il CEV disponga delle policy necessarie descritte in [Fase 5: concessione delle autorizzazioni richieste al ruolo o utente IAM](custom-setup-orcl.md#custom-setup-orcl.iam-user).
# Creazione di un CEV
È possibile creare un CEV tramite Console di gestione AWS o AWS CLI. Specifica l'architettura multilocazione o non multilocazione. Per ulteriori informazioni, consulta [Considerazioni sull'architettura multilocazione](custom-creating.md#custom-creating.overview).
In genere, la creazione di un CEV richiede circa due ore. Dopo aver creato la CEV, puoi usarla per creare o aggiornare un’istanza database RDS Custom. Per ulteriori informazioni, consultare [Creazione di un'istanza database RDS Custom per Oracle](custom-creating.md#custom-creating.create) e [Aggiornamento di un'istanza database RDS Custom per Oracle](custom-upgrading-modify.md).
**Nota**
Se la tua istanza database utilizza attualmente Oracle Linux 7.9, crea una nuova CEV che utilizzi l’AMI più recente, che usa Oracle Linux 8. Modifica quindi l’istanza in modo da utilizzare la nuova CEV.
Tieni presenti i requisiti e le limitazioni seguenti per la creazione di una CEV:
+ Il bucket Amazon S3 che contiene i file di installazione deve trovarsi nella stessa Regione Regione AWS della CEV. In caso contrario, il processo di creazione non riesce.
+ Il nome della CEV deve essere nel formato `major-engine-version.customized_string`, come in `19.cdb_cev1`.
+ Il nome della CEV deve contenere da 1 a 50 caratteri alfanumerici, caratteri di sottolineatura, trattini o punti.
+ Il nome della CEV non può contenere punti consecutivi, come in `19..cdb_cev1`.
## Console
**Per creare un CEV**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Versioni motore personalizzate**.
La pagina **Versioni motore personalizzate** mostra tutti i CEV attualmente esistenti. Se non è stato creato alcun CEV, la pagina è vuota.
1. Scegliere **Creazione della versione del motore personalizzata**.
1. In **Opzioni motore**, procedi nel modo seguente:
1. Per **Engine type** (Tipo di motore), seleziona **Oracle**.
1. In **Impostazioni dell’architettura**, scegli **Architettura multi-tenant** per creare una CEV multitenant Oracle, che utilizza il motore di database `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. È possibile creare un RDS Custom per Oracle solo con una CEV multi-tenant. Se non si sceglie questa opzione, la CEV non è un CDB, che utilizza il motore `custom-oracle-ee` o `custom-oracle-se2`.
**Nota**
L'architettura selezionata è una caratteristica permanente della CEV. Non puoi modificare la CEV in modo che utilizzi un'architettura diversa in un secondo momento.
1. Seleziona una delle seguenti opzioni:
+ **Crea un nuovo CEV**: crea una nuova versione del motore personalizzato da zero. In questo caso, è necessario specificare un manifesto JSON che definisca i file binari del database.
+ **Crea un CEV dall'origine**: in **Specifica il CEV da copiare** scegli una versione del motore personalizzato esistente da utilizzare come CEV di origine. In questo caso, puoi specificare una nuova Amazon Machine Image (AMI), ma non puoi definire file binari del database diversi.
1. In **Versione principale**, scegli la versione principale del motore.
1. In **Dettagli versione**, procedi come segue:
1. Inserisci un nome valido in **Nome della versione del motore personalizzato**. Ad esempio, è possibile inserire il nome **19.cdb\$1cev1**.
1. (Facoltativo) Inserisci una descrizione per la CEV.
1. In **Media di installazione**, esegui le operazioni indicate di seguito:
1. (Facoltativo) Lascia il campo **ID AMI** vuoto per utilizzare l'AMI più recente fornita dal servizio oppure specifica l'AMI che hai usato in precedenza per creare una versione del motore personalizzato. Per ottenere ID AMI validi, usa una delle seguenti tecniche:
+ Nella console, scegli **Versioni del motore personalizzato** nel riquadro di navigazione a sinistra e scegli il nome di una CEV. L'ID AMI utilizzato dalla CEV viene visualizzato nella scheda **Configurazione**.
+ In AWS CLI, usa il comando `describe-db-engine-versions`. Cerca nell'output per `ImageID`.
1. Per la **posizione S3 dei file manifest**, inserisci la posizione del bucket Amazon S3 specificata in [Fase 3: caricamento dei file di installazione in Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3). Ad esempio, specifica **s3://my-custom-installation-files/123456789012/cev1/**.
**Nota**
La Regione AWS in cui crei la versione del motore personalizzato deve trovarsi nella stessa regione del bucket S3.
1. (Solo Crea un nuovo CEV) In **Manifest CEV** inserisci il manifesto JSON creato in [Creazione del manifest CEV](custom-cev.preparing.md#custom-cev.preparing.manifest.creating).
1. Nella sezione **Chiave KMS**, seleziona **Inserisci un ARN della chiave** per elencare le chiavi AWS KMS disponibili. Selezionare quindi la propria chiave KMS dall'elenco.
Per RDS Custom è necessaria la chiave AWS KMS. 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. (Facoltativo) Scegli **Aggiungi nuovo tag** per creare una coppia chiave-valore per la tua CEV.
1. Scegliere **Creazione della versione del motore personalizzata**.
Se il formato del manifesto JSON non è valido, la console visualizza **Error validating the CEV manifest**. Risolvi i problemi e riprova.
La pagina **Versioni motore personalizzate** viene visualizzata. Il tuo CEV viene mostrato con lo stato **Creating (Creazione)**. Il processo di creazione della versione del motore personalizzato richiede circa due ore.
## AWS CLI
Creazione di un CEV tramite AWS CLI, esegui il comando [create-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/create-custom-db-engine-version.html).
Sono richieste le seguenti opzioni:
+ `--engine`: specifica il tipo di motore. Per un CDB, specifica `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. Per un non CDB, specifica `custom-oracle-ee` o `custom-oracle-se2`. È possibile creare CDB solo da una CEV creata con `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. È possibile creare non CDB solo da una CEV creata con `custom-oracle-ee` o `custom-oracle-se2`.
+ `--engine-version`: specifica la versione del motore. Il formato è *major-engine-version*.*customized\$1string*. Il nome della CEV deve contenere da 1 a 50 caratteri alfanumerici, caratteri di sottolineatura, trattini o punti. Il nome della CEV non può contenere punti consecutivi, come in `19..cdb_cev1`.
+ `--kms-key-id`: specifica una AWS KMS key.
+ `--manifest`: specifica `manifest_json_string` o `--manifest file:file_name`. I caratteri di nuova riga non sono consentiti in `manifest_json_string`. Assicurati di evitare le doppie virgolette (") nel codice JSON precedendole con il backslash (\$1).
L'esempio seguente mostra il `manifest_json_string` per 19c da [Fase 5: preparazione del manifesto CEV](custom-cev.preparing.md#custom-cev.preparing.manifest). L'esempio imposta nuovi valori per la base Oracle, la home Oracle e l'ID e il nome dell'utente e del gruppo UNIX/Linux. Se copi questa stringa, rimuovi tutti i caratteri di nuova riga prima di incollarla nel comando.
`"{\"mediaImportTemplateVersion\": \"2020-08-14\",\"databaseInstallationFileNames\": [\"V982063-01.zip\"],\"opatchFileNames\": [\"p6880880_190000_Linux-x86-64.zip\"],\"psuRuPatchFileNames\": [\"p32126828_190000_Linux-x86-64.zip\"],\"otherPatchFileNames\": [\"p29213893_1910000DBRU_Generic.zip\",\"p29782284_1910000DBRU_Generic.zip\",\"p28730253_190000_Linux-x86-64.zip\",\"p29374604_1910000DBRU_Linux-x86-64.zip\",\"p28852325_190000_Linux-x86-64.zip\",\"p29997937_190000_Linux-x86-64.zip\",\"p31335037_190000_Linux-x86-64.zip\",\"p31335142_190000_Generic.zip\"]\"installationParameters\":{ \"unixGroupName\":\"dba\", \ \"unixUname\":\"oracle\", \ \"oracleHome\":\"/home/oracle/oracle.19.0.0.0.ru-2020-04.rur-2020-04.r1.EE.1\", \ \"oracleBase\":\"/home/oracle/\"}}"`
+ `--database-installation-files-s3-bucket-name`: specifica lo stesso nome del bucket specificato in [Fase 3: caricamento dei file di installazione in Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3). La Regione AWS in cui esegui `create-custom-db-engine-version` deve trovarsi nella stessa regione del bucket Amazon S3.
È anche possibile specificare le seguenti opzioni:
+ `--description`: specifica una descrizione della CEV.
+ `--database-installation-files-s3-prefix`: specifica il nome della cartella specificato in [Fase 3: caricamento dei file di installazione in Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3).
+ `--image-id`: specifica un ID AMI che si desidera riutilizzare. Per trovare ID validi, esegui il comando `describe-db-engine-versions`, quindi cerca l'output per `ImageID`. Per impostazione predefinita, RDS Custom per Oracle utilizza l'AMI disponibile più recente.
L'esempio seguente crea una CEV multitenant Oracle denominata `19.cdb_cev1`. L'esempio riutilizza un'AMI esistente anziché utilizzare l'ultima AMI disponibile. Assicurati che il nome del tuo CEV inizi con il numero di versione principale del motore.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds create-custom-db-engine-version \
2. --engine custom-oracle-se2-cdb \
3. --engine-version 19.cdb_cev1 \
4. --database-installation-files-s3-bucket-name us-east-1-123456789012-custom-installation-files \
5. --database-installation-files-s3-prefix 123456789012/cev1 \
6. --kms-key-id my-kms-key \
7. --description "test cev" \
8. --manifest manifest_string \
9. --image-id ami-012a345678901bcde
```
Per Windows:
```
1. aws rds create-custom-db-engine-version ^
2. --engine custom-oracle-se2-cdb ^
3. --engine-version 19.cdb_cev1 ^
4. --database-installation-files-s3-bucket-name us-east-1-123456789012-custom-installation-files ^
5. --database-installation-files-s3-prefix 123456789012/cev1 ^
6. --kms-key-id my-kms-key ^
7. --description "test cev" ^
8. --manifest manifest_string ^
9. --image-id ami-012a345678901bcde
```
**Example**
Ottenere informazioni sul CEV tramite il comando `describe-db-engine-versions`.
```
1. aws rds describe-db-engine-versions \
2. --engine custom-oracle-se2-cdb \
3. --include-all
```
Il seguente output parziale mostra il motore, i gruppi di parametri, il manifesto e altre informazioni.
```
1. {
2. "DBEngineVersions": [
3. {
4. "Engine": "custom-oracle-se2-cdb",
5. "EngineVersion": "19.cdb_cev1",
6. "DBParameterGroupFamily": "custom-oracle-se2-cdb-19",
7. "DBEngineDescription": "Containerized Database for Oracle Custom SE2",
8. "DBEngineVersionDescription": "test cev",
9. "Image": {
10. "ImageId": "ami-012a345678901bcde",
11. "Status": "active"
12. },
13. "ValidUpgradeTarget": [],
14. "SupportsLogExportsToCloudwatchLogs": false,
15. "SupportsReadReplica": true,
16. "SupportedFeatureNames": [],
17. "Status": "available",
18. "SupportsParallelQuery": false,
19. "SupportsGlobalDatabases": false,
20. "MajorEngineVersion": "19",
21. "DatabaseInstallationFilesS3BucketName": "us-east-1-123456789012-custom-installation-files",
22. "DatabaseInstallationFilesS3Prefix": "123456789012/cev1",
23. "DBEngineVersionArn": "arn:aws:rds:us-east-1:123456789012:cev:custom-oracle-se2-cdb/19.cdb_cev1/abcd12e3-4f5g-67h8-i9j0-k1234l56m789",
24. "KMSKeyId": "arn:aws:kms:us-east-1:732027699161:key/1ab2345c-6d78-9ef0-1gh2-3456i7j89k01",
25. "CreateTime": "2023-03-07T19:47:58.131000+00:00",
26. "TagList": [],
27. "SupportsBabelfish": false,
28. ...
```
## Impossibile creare un CEV
Se il processo di creazione di un CEV non riesce, RDS Custom emette `RDS-EVENT-0198` con il messaggio `Creation failed for custom engine version major-engine-version.cev_name` e include i dettagli sull'errore. Ad esempio, l'evento stampa i file mancanti.
Non è possibile modificare un CEV fallito. È possibile solamente eliminarlo, quindi riprovare a creare un CEV dopo aver risolto le cause dell'errore. Per informazioni sulla risoluzione dei problemi relativi all'errore di creazione del CEV, consulta [Risoluzione dei problemi relativi alla creazione di versioni personalizzate del motore per RDS Custom per Oracle](custom-troubleshooting.md#custom-troubleshooting.cev).
# Modifica dello stato del CEV
È possibile modificare un CEV tramite Console di gestione AWS o AWS CLI. È possibile modificare la descrizione CEV o il relativo stato di disponibilità. Il CEV ha uno dei seguenti valori di stato:
+ `available` – È possibile utilizzare questo CEV per creare una nuova istanza database RDS Custom o aggiornare un'istanza database. Questo è lo stato predefinito per un CEV appena creato.
+ `inactive` – Non è possibile creare o aggiornare un'istanza RDS Custom con questo CEV. Non è possibile ripristinare una snapshot DB per creare una nuova istanza database RDS Custom con questo CEV.
È possibile modificare il CEV da qualsiasi stato supportato a qualsiasi altro stato supportato. È possibile modificare lo stato per impedire l'uso accidentale di un CEV o rendere nuovamente idoneo l'uso di un CEV sospeso. Ad esempio, puoi modificare lo stato del tuo CEV da `available` a `inactive`, nonché da `inactive` tornare a `available`.
## Console
**Per modificare un CEV**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Versioni motore personalizzate**.
1. Scegliere un CEV di cui si desidera modificare la descrizione o lo stato.
1. Per **Operazioni**, scegli **Modifica**.
1. Effettua una qualsiasi delle seguenti modifiche:
+ Per **CEV status settings** (Impostazioni dello stato del CEV) scegliere un nuovo stato di disponibilità.
+ In **Version description** (Descrizione versione), inserire una nuova descrizione.
1. Scegliere **Modify CEV** (Modifica CEV).
Se il CEV è in uso, la console visualizza **You can't modify the CEV status** (Non puoi modificare lo stato CEV). Risolvi i problemi e riprova.
La pagina **Versioni motore personalizzate** viene visualizzata.
## AWS CLI
Per modificare un CEV tramite AWS CLI, esegui il comando [modify-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-custom-db-engine-version.html). È possibile trovare CEV da modificare tramite il comando [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Sono richieste le seguenti opzioni:
+ `--engine engine-type`, dove *engine-type* è `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 che si desidera modificare
+ `--status`` status`, dove *`status`* è lo stato di disponibilità che si desidera assegnare al CEV
L'esempio seguente cambia un CEV denominato `19.my_cev1` dal suo stato attuale a `inactive`.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds modify-custom-db-engine-version \
2. --engine custom-oracle-se2 \
3. --engine-version 19.my_cev1 \
4. --status inactive
```
Per Windows:
```
1. aws rds modify-custom-db-engine-version ^
2. --engine custom-oracle-se2 ^
3. --engine-version 19.my_cev1 ^
4. --status inactive
```
# Visualizzazione dei dettagli della CEV per Amazon RDS Custom per Oracle
Puoi visualizzare i dettagli del manifesto CEV e del comando utilizzato per creare la CEV utilizzando la Console di gestione AWS o AWS CLI.
## Console
**Per visualizzare i dettagli della CEV**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Versioni motore personalizzate**.
La pagina **Versioni motore personalizzate** mostra tutti i CEV attualmente esistenti. Se non è stato creato alcun CEV, la pagina è vuota.
1. Seleziona il nome della CEV che vuoi visualizzare.
1. Scegli **Configuration** (Configurazione) per visualizzare i parametri di installazione specificati nel manifesto.
![\[Visualizza i parametri di installazione per una CEV.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/cev-configuration-tab.png)
1. Scegli **Manifest** (Manifesto) per visualizzare i parametri di installazione specificati nell'opzione `--manifest` del comando `create-custom-db-engine-version`. È possibile copiare questo testo, sostituire i valori in base alle esigenze e utilizzarli in un nuovo comando.
![\[Visualizza il comando usato per creare la CEV.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/UserGuide/images/cev-manifest-tab.png)
## AWS CLI
Per informazioni su una CEV usando AWS CLI, esegui il comando [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Sono richieste le seguenti opzioni:
+ `--engine engine-type`, dove *engine-type* è `custom-oracle-ee`, `custom-oracle-se2`, `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`
+ `--engine-version major-engine-version.customized_string`
L’esempio seguente crea una CEV non CDB che utilizza Enterprise Edition. Il nome della CEV `19.my_cev1` inizia con il numero di versione principale del motore, che è obbligatorio.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds describe-db-engine-versions \
2. --engine custom-oracle-ee \
3. --engine-version 19.my_cev1
```
Per Windows:
```
1. aws rds describe-db-engine-versions ^
2. --engine custom-oracle-ee ^
3. --engine-version 19.my_cev1
```
Il seguente output parziale mostra il motore, i gruppi di parametri, il manifesto e altre informazioni.
```
1. "DBEngineVersions": [
2. {
3. "Engine": "custom-oracle-ee",
4. "MajorEngineVersion": "19",
5. "EngineVersion": "19.my_cev1",
6. "DatabaseInstallationFilesS3BucketName": "us-east-1-123456789012-cev-customer-installation-files",
7. "DatabaseInstallationFilesS3Prefix": "123456789012/cev1",
8. "CustomDBEngineVersionManifest": "{\n\"mediaImportTemplateVersion\": \"2020-08-14\",\n\"databaseInstallationFileNames\": [\n\"V982063-01.zip\"\n],\n\"installationParameters\": {\n\"oracleBase\":\"/tmp\",\n\"oracleHome\":\"/tmp/Oracle\"\n},\n\"opatchFileNames\": [\n\"p6880880_190000_Linux-x86-64.zip\"\n],\n\"psuRuPatchFileNames\": [\n\"p32126828_190000_Linux-x86-64.zip\"\n],\n\"otherPatchFileNames\": [\n\"p29213893_1910000DBRU_Generic.zip\",\n\"p29782284_1910000DBRU_Generic.zip\",\n\"p28730253_190000_Linux-x86-64.zip\",\n\"p29374604_1910000DBRU_Linux-x86-64.zip\",\n\"p28852325_190000_Linux-x86-64.zip\",\n\"p29997937_190000_Linux-x86-64.zip\",\n\"p31335037_190000_Linux-x86-64.zip\",\n\"p31335142_190000_Generic.zip\"\n]\n}\n",
9. "DBParameterGroupFamily": "custom-oracle-ee-19",
10. "DBEngineDescription": "Oracle Database server EE for RDS Custom",
11. "DBEngineVersionArn": "arn:aws:rds:us-west-2:123456789012:cev:custom-oracle-ee/19.my_cev1/0a123b45-6c78-901d-23e4-5678f901fg23",
12. "DBEngineVersionDescription": "test",
13. "KMSKeyId": "arn:aws:kms:us-east-1:123456789012:key/ab1c2de3-f4g5-6789-h012-h3ijk4567l89",
14. "CreateTime": "2022-11-18T09:17:07.693000+00:00",
15. "ValidUpgradeTarget": [
16. {
17. "Engine": "custom-oracle-ee",
18. "EngineVersion": "19.cev.2021-01.09",
19. "Description": "test",
20. "AutoUpgrade": false,
21. "IsMajorVersionUpgrade": false
22. }
23. ]
```
# Eliminazione di un CEV
È possibile eliminare un CEV tramite Console di gestione AWS o AWS CLI. In genere, l’eliminazione richiede pochi minuti.
Per eliminare un CEV, non può essere utilizzato da nessuno dei seguenti elementi:
+ Un'istanza database RDS Custom
+ Una snapshot di un'istanza database RDS Custom
+ Backup automatico dell'istanza database RDS Custom
## Console
**Per eliminare un CEV**
1. Accedi alla Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel pannello di navigazione, scegliere **Versioni motore personalizzate**.
1. Scegliere un CEV di cui si desidera eliminare la descrizione o lo stato.
1. In **Actions (Azioni)**, scegliere **Delete (Elimina)**.
Viene visualizzata la finestra di dialogo **Delete *cev\$1name*? (Elimina cev\$1name?)**.
1. Immettere **delete me**, quindi scegliere **Delete (Elimina)**.
Nella pagina **Versioni motore personalizzate**, il banner mostra che il tuo CEV è stato eliminato.
## AWS CLI
Per eliminare un CEV tramite AWS CLI, esegui il comando [delete-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-custom-db-engine-version.html).
Sono richieste le seguenti opzioni:
+ `--engine engine-type`, dove *engine-type* è `custom-oracle-ee`, `custom-oracle-se2`, `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`
+ `--engine-version cev`, in cui *cev* è il nome della versione del motore personalizzata da eliminare
L'esempio seguente elimina un CEV denominato `19.my_cev1`.
**Example**
Per Linux, macOS o Unix:
```
1. aws rds delete-custom-db-engine-version \
2. --engine custom-oracle-ee \
3. --engine-version 19.my_cev1
```
Per Windows:
```
1. aws rds delete-custom-db-engine-version ^
2. --engine custom-oracle-ee ^
3. --engine-version 19.my_cev1
```