# Trabajar con versiones de motor personalizadas para Amazon RDS Custom for Oracle
Una *versión de motor personalizado (CEV)* para Amazon RDS Custom for Oracle es una instantánea de volumen binario de un motor de base de datos y una Amazon Machine Image (AMI) específica. De forma predeterminada, RDS Custom para Oracle usa la última AMI disponible administrada por RDS Custom, pero puede especificar una AMI que se usó en una CEV anterior. Almacena los archivos de instalación de la base de datos en Amazon S3. RDS Custom utiliza los archivos de instalación y la AMI para crear la CEV en su nombre.
**Topics**
+ [Preparación para crear una CEV](custom-cev.preparing.md)
+ [Creación de una CEV](custom-cev.create.md)
+ [Modificación del estado de CEV](custom-cev.modify.md)
+ [Visualización de detalles de la CEV de Amazon RDS Custom para Oracle](custom-cev.view.md)
+ [Eliminación de una CEV](custom-cev.delete.md)
# Preparación para crear una CEV
Para crear un CEV, acceda a los archivos de instalación y a los parches que están almacenados en su bucket de Amazon S3 para cualquiera de las siguientes versiones:
+ Oracle Database 19c
+ Oracle Database 18c
+ Base de datos Oracle 12c versión 2 (12.2)
+ Base de datos Oracle 12c versión 1 (12.1)
Por ejemplo, puede usar la RU/RUR de abril de 2021 para Oracle Database 19c o cualquier combinación válida de archivos de instalación y parches. Para obtener más información sobre las regiones y regiones compatibles con RDS Custom para Oracle, consulta [RDS Custom con RDS para 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**
+ [Paso 1 (opcional): descargar las plantillas del manifiesto](#custom-cev.preparing.templates)
+ [Paso 2: descargar revisiones y archivos de instalación de la base de datos desde Oracle Software Delivery Cloud](#custom-cev.preparing.download)
+ [Paso 3: cargar los archivos de instalación en Amazon S3](#custom-cev.preparing.s3)
+ [Paso 4 (opcional): compartir los medios de instalación en S3 en Cuentas de AWS](#custom-cev.preparing.accounts)
+ [Paso 5: preparar el manifiesto de la CEV](#custom-cev.preparing.manifest)
+ [Paso 6 (opcional): validar el manifiesto de CEV](#custom-cev.preparing.validating)
+ [Paso 7: añadir los permisos de IAM necesarios](#custom-cev.preparing.iam)
## Paso 1 (opcional): descargar las plantillas del manifiesto
Un *manifiesto CEV* es un documento JSON que incluye la lista de archivos.zip de instalación de la base de datos para su CEV. Para crear una CEV, haga lo siguiente:
1. Identifique los archivos de instalación de la base de datos Oracle que desea incluir en su CEV.
1. Descargue los archivos de instalación.
1. Cree un manifiesto JSON que enumere los archivos de instalación.
RDS Custom para Oracle proporciona plantillas de manifiestos JSON con los archivos.zip que recomendamos para cada versión compatible de Oracle Database. Por ejemplo, la siguiente plantilla es para 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"
]
}
```
Cada plantilla tiene un archivo readme asociado que incluye instrucciones para descargar las revisiones, las URL de los archivos.zip y las sumas de verificación de los archivos. Puede utilizar estas plantillas tal como están o modificarlas con sus propias revisiones. Para revisar las plantillas, descargue [custom-oracle-manifest.zip](samples/custom-oracle-manifest.zip) en el disco local y, a continuación, ábralo con una aplicación de archivado de archivos. Para obtener más información, consulte [Paso 5: preparar el manifiesto de la CEV](#custom-cev.preparing.manifest).
## Paso 2: descargar revisiones y archivos de instalación de la base de datos desde Oracle Software Delivery Cloud
Cuando haya identificado los archivos de instalación que desea para su CEV, descárguelos en su sistema local. Los archivos y las revisiones de instalación de Oracle Database se alojan en Oracle Software Delivery Cloud. Cada CEV requiere una versión básica, como Oracle Database 19c u Oracle Database 12c Versión 2 (12.2), y una lista de revisiones opcional.
**Para descargar los archivos de instalación de Oracle Database**
1. Vaya a [https://edelivery.oracle.com/](https://edelivery.oracle.com/) e inicie sesión.
1. En el cuadro de búsqueda, introduzca **Oracle Database Enterprise Edition** o **Oracle Database Standard Edition 2** y elija **Search**.
1. Elija una de las siguientes versiones básicas:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/custom-cev.preparing.html)
1. Elija **Continuar**.
1. Borre la casilla de verificación **Download Queue** (Descargar cola).
1. Elija la opción que corresponda a su versión básica:
+ **Oracle Database 19,3.0.0.0 - Versión a largo plazo**.
+ **Oracle Database 18.0.0.0.0**
+ **Oracle Database 12.2.0.1.0**.
+ **Oracle Database 12.1.0.2.0**.
1. Elija **Linux x86-64** en **Plataforma/Idiomas**.
1. Seleccione **Continuar** y firme el contrato de licencia de Oracle.
1. Elija el archivo .zip que corresponda a su versión de la base de datos:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/custom-cev.preparing.html)
1. Descargue las revisiones de Oracle que desee desde `updates.oracle.com` o `support.oracle.com` en su sistema local. Puede encontrar las URL de las revisiones en las siguientes ubicaciones:
+ Los archivos readme del archivo .zip que ha descargado en [Paso 1 (opcional): descargar las plantillas del manifiesto](#custom-cev.preparing.templates)
+ Las revisiones que se enumeran en cada actualización de la versión (RU) en [Notas de versión de Amazon Relational Database Service (Amazon RDS) para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes).
## Paso 3: cargar los archivos de instalación en Amazon S3
Cargue los archivos de revisión y de instalación de Oracle en Amazon S3 mediante la AWS CLI. El bucket de S3 que contiene los archivos de instalación debe estar en la misma Región AWS como CEV.
En los ejemplos de esta sección se utilizan los siguientes marcadores de posición:
+ `install-or-patch-file.zip`: archivo multimedia de instalación de Oracle. Por ejemplo, p32126828\$1190000\$1Linux-x86-64.zip es una revisión.
+ `amzn-s3-demo-destination-bucket`: el bucket de Amazon S3 designado para los archivos de instalación cargados.
+ `123456789012/cev1`: prefijo opcional en el bucket de Amazon S3.
+ `amzn-s3-demo-source-bucket`: bucket de Amazon S3 en el que puede organizar archivos de forma opcional.
**Topics**
+ [Paso 3a: compruebe que el bucket de S3 esté en la Región de AWS correcta](#custom-cev.preparing.s3.verify-region)
+ [Paso 3b: asegúrese de que su política de buckets de S3 tenga los permisos correctos](#custom-cev.preparing.s3.verify-policy)
+ [Paso 3c: cargue sus archivos mediante los comandos cp o sync](#custom-cev.preparing.s3.upload)
+ [Paso 3d: enumere los archivos en su bucket de S3](#custom-cev.preparing.s3.list)
### Paso 3a: compruebe que el bucket de S3 esté en la Región de AWS correcta
Compruebe que el bucket de S3 esté en la Región AWS en la que planea ejecutar el comando `create-custom-db-engine-version`.
```
aws s3api get-bucket-location --bucket amzn-s3-demo-destination-bucket
```
### Paso 3b: asegúrese de que su política de buckets de S3 tenga los permisos correctos
Puede crear una CEV desde cero o desde una CEV de origen. Si planea crear una CEV nueva a partir de las CEV de origen, asegúrese de que su política de bucket de S3 tenga los permisos correctos:
1. Identifique el bucket de S3 reservado por RDS Custom. El nombre del bucket tiene el formato `do-not-delete-rds-custom-account-region-string`. Por ejemplo, el nombre del bucket puede ser `do-not-delete-rds-custom-123456789012-us-east-1-abc123EXAMPLE`.
1. Asegúrese de que el siguiente permiso esté adjunto a la política de bucket de S3. Reemplace `do-not-delete-rds-custom-123456789012-us-east-1-abc123EXAMPLE` con el nombre de su 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/*"
}, ...
```
### Paso 3c: cargue sus archivos mediante los comandos cp o sync
Elija cualquiera de las siguientes opciones:
+ Utilice `aws s3 cp` para cargar un solo archivo .zip.
Cargue cada archivo .zip de instalación por separado. No combine los archivos .zip en un solo archivo .zip.
+ Use `aws s3 sync` para cargar un directorio.
**Example**
El siguiente ejemplo carga `install-or-patch-file.zip` en la carpeta `123456789012/cev1` en el bucket de Amazon S3 de RDS Custom. Ejecute un comando `aws s3` separado para cada .zip que desee cargar.
Para Linux, macOS o Unix:
```
1. aws s3 cp install-or-patch-file.zip \
2. s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Para Windows:
```
1. aws s3 cp install-or-patch-file.zip ^
2. s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
**Example**
El siguiente ejemplo carga los archivos en su carpeta *cev1* local a la carpeta *123456789012/cev1* en su bucket de Amazon S3.
Para Linux, macOS o Unix:
```
aws s3 sync cev1 \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Para Windows:
```
aws s3 sync cev1 ^
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
**Example**
El siguiente ejemplo carga todos los archivos `amzn-s3-demo-source-bucket` en la carpeta **`123456789012/cev1`** en el bucket de Amazon S3.
Para Linux, macOS o Unix:
```
aws s3 sync s3://amzn-s3-demo-source-bucket/ \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
Para Windows:
```
aws s3 sync s3://amzn-s3-demo-source-bucket/ ^
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
### Paso 3d: enumere los archivos en su bucket de S3
El siguiente ejemplo utiliza el comando `s3 ls` para enumerar los archivos de su bucket de Amazon S3 de RDS Custom.
```
aws s3 ls \
s3://amzn-s3-demo-destination-bucket/123456789012/cev1/
```
## Paso 4 (opcional): compartir los medios de instalación en S3 en Cuentas de AWS
Para la finalidad de esta sección, el bucket de Amazon S3 que contiene los archivos de instalación de Oracle está en su *bucket de medios*. Es posible que su organización utilice varias Cuentas de AWS en una Región de AWS. Si es así, puede usar una Cuenta de AWS para rellenar el bucket de medios y una Cuenta de AWS diferente para crear CEV. Si no desea compartir el bucket de medios, vaya a la siguiente sección.
En esta sección se presupone lo siguiente:
+ Puede acceder a la cuenta que creó su bucket de medios y a otra cuenta en la que tiene pensado crear CEV.
+ Tiene pensado crear CEV en una sola Región de AWS. Si tiene pensado usar varias regiones, cree un bucket de medios en cada región.
+ Está usando la CLI. Si utiliza la consola de Amazon S3, siga estos pasos:
**Para configurar su bucket de medios para compartirlo entre Cuentas de AWS**
1. Inicie sesión en la Cuenta de AWS que contiene el bucket de S3 en el que ha cargado los medios de instalación.
1. Comience con una plantilla de política JSON en blanco o una política existente que pueda adaptar.
El siguiente comando recupera una política existente y la guarda como *my-policy.json*. En este ejemplo, el bucket de S3 que contiene los archivos de instalación se denomina *amzn-s3-demo-bucket*.
```
aws s3api get-bucket-policy \
--bucket amzn-s3-demo-bucket \
--query Policy \
--output text > my-policy.json
```
1. Edite los permisos del bucket de medios de la siguiente manera:
+ En el elemento `Resource` de la plantilla, especifique el bucket de S3 en el que ha cargado los archivos de instalación de Oracle Database.
+ En el elemento `Principal`, especifique los ARN para todas las Cuentas de AWS que pretende usar para crear CEV. Puede añadir la raíz, un usuario o un rol a la lista de buckets de S3 permitidos. Para obtener más información, consulte [Identificadores de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html) en la *Guía del usuario de 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. Adjunte la política a su bucket de medios.
En el siguiente ejemplo, *amzn-s3-demo-bucket* es el nombre del bucket de S3 que contiene los archivos de instalación, y *my-policy.json* es el nombre del archivo JSON.
```
aws s3api put-bucket-policy \
--bucket amzn-s3-demo-bucket \
--policy file://my-policy.json
```
1. Inicie sesión en una Cuenta de AWS en la que piensa crear CEV.
1. Verifique que esta cuenta pueda acceder al bucket de medios en la Cuenta de AWS que lo creó.
```
aws s3 ls --query "Buckets[].Name"
```
Para obtener más información, consulte [aws s3 ls](https://docs.aws.amazon.com/cli/latest/reference/s3/ls.html) en la *referencia de comandos de la AWS CLI*.
1. Cree un CEV siguiendo los pasos de [Creación de una CEV](custom-cev.create.md).
## Paso 5: preparar el manifiesto de la CEV
Un manifiesto de CEV es un documento JSON que incluye lo siguiente:
+ (Obligatorio) La lista de archivos de instalación .zip que ha cargado en Amazon S3. RDS Custom aplica los parches en el orden en que aparecen en el manifesto.
+ (Opcional) Parámetros de instalación que establecen valores no predeterminados para la base de Oracle, el directorio raíz Oracle y el ID y el nombre del usuario y el grupo de UNIX/Linux. Tenga en cuenta que no puede modificar los parámetros de instalación de una CEV existente o una instancia de base de datos existente. Tampoco puede actualizar de una CEV a otra si los parámetros de instalación tienen configuraciones diferentes.
Para ver ejemplos de manifiestos de CEV, consulte las plantillas de JSON que ha descargado en [Paso 1 (opcional): descargar las plantillas del manifiesto](#custom-cev.preparing.templates). También puede revisar los ejemplos en [Ejemplos de manifiestos CEV](#custom-cev.preparing.manifest.examples).
**Topics**
+ [Campos JSON en el manifiesto de CEV](#custom-cev.preparing.manifest.fields)
+ [Creación del manifiesto de CEV](#custom-cev.preparing.manifest.creating)
+ [Ejemplos de manifiestos CEV](#custom-cev.preparing.manifest.examples)
### Campos JSON en el manifiesto de CEV
La siguiente tabla describe los campos JSON en el manifiesto.
| Campo JSON | Descripción |
| --- | --- |
| `MediaImportTemplateVersion` | Versión del manifiesto de CEV. La fecha tiene el formato `YYYY-MM-DD`. |
| `databaseInstallationFileNames` | Lista ordenada de archivos de instalación para la base de datos. |
| `opatchFileNames` | Lista ordenada de instaladores de OPatch utilizados para el motor de base de datos de Oracle. Solo es válido un valor. Los valores de `opatchFileNames` deben comenzar con `p6880880_`. |
| `psuRuPatchFileNames` | Las revisiones de PSU y RU para esta base de datos. Si incluye `psuRuPatchFileNames`, `opatchFileNames` es necesario. Los valores de `opatchFileNames` deben comenzar con `p6880880_`. |
| `OtherPatchFileNames` | Las revisiones que no figuran en la lista de revisiones de PSU y RU. RDS Custom aplica estas revisiones después de aplicar las revisiones de PSU y RU. Si incluye `OtherPatchFileNames`, `opatchFileNames` es necesario. Los valores de `opatchFileNames` deben comenzar con `p6880880_`. |
| `installationParameters` | Configuración no predeterminada para la base de Oracle, el directorio raíz de Oracle, y el ID y el nombre del usuario y el grupo de UNIX/Linux. Puede definir los siguientes parámetros: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/custom-cev.preparing.html) |
Cada versión de Oracle Database tiene una lista diferente de archivos de instalación compatibles. Cuando cree el manifiesto de CEV, asegúrese de especificar solo los archivos compatibles con RDS Custom para Oracle. De lo contrario, se produce un error en la creación de CEV. Las revisiones que se enumeran en cada actualización de la versión (RU) en [Notas de versión de Amazon Relational Database Service (Amazon RDS) para Oracle](https://docs.aws.amazon.com/AmazonRDS/latest/OracleReleaseNotes).
### Creación del manifiesto de CEV
**Para crear un manifiesto CEV**
1. Enumere todos los archivos de instalación que va a aplicar, en el orden en que desea aplicarlos.
1. Correlacione los archivos de instalación con los campos JSON que se describen en [Campos JSON en el manifiesto de CEV](#custom-cev.preparing.manifest.fields).
1. Haga una de estas dos operaciones:
+ Cree el manifiesto CEV como un archivo de texto JSON.
+ Edite la plantilla de manifiesto CEV cuando cree el CEV en la consola. Para obtener más información, consulte [Creación de una CEV](custom-cev.create.md).
### Ejemplos de manifiestos CEV
Los siguientes ejemplos muestran archivos de manifiesto CEV para diferentes versiones de Oracle Database. Si incluye un campo JSON en el manifiesto, asegúrese de que no esté vacío. Por ejemplo, el siguiente manifiesto CEV no es válido porque `otherPatchFileNames` está vacío.
```
{
"mediaImportTemplateVersion": "2020-08-14",
"databaseInstallationFileNames": [
"V982063-01.zip"
],
"opatchFileNames": [
"p6880880_190000_Linux-x86-64.zip"
],
"psuRuPatchFileNames": [
"p32126828_190000_Linux-x86-64.zip"
],
"otherPatchFileNames": [
]
}
```
**Temas**
+ [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 Manifiesto CEV de ejemplo para Oracle Database 12c versión 1 (12.1)**
En el siguiente ejemplo para PSU de julio de 2021 para Oracle Database 12c, versión 1 (12.1), RDS Custom aplica los parches en el orden especificado. Por lo tanto, RDS Custom aplica p32768233; luego, p18759211 y así sucesivamente. El ejemplo establece valores nuevos para el usuario y el grupo de UNIX, así como para el directorio raíz y la base de 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 Manifiesto CEV de ejemplo para Oracle Database 12c versión 2 (12.2)**
En el siguiente ejemplo para PSU de octubre de 2021 para Oracle Database 12c, versión 2 (12.2), RDS Custom aplica p33261817; luego, p33192662; luego, p29213893 y así sucesivamente. El ejemplo establece valores nuevos para el usuario y el grupo de UNIX, así como para el directorio raíz y la base de 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 Manifiesto CEV de ejemplo para Oracle Database 18c**
En el siguiente ejemplo para PSU de octubre de 2021 para Oracle Database 18c, RDS Custom aplica p32126855; luego, p28730253; luego, p27539475 y así sucesivamente. El ejemplo establece valores nuevos para el usuario y el grupo de UNIX, así como para el directorio raíz y la base de 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 Manifiesto CEV de ejemplo para Oracle Database 19c**
En el siguiente ejemplo para Oracle Database 19c, RDS Custom aplica p32126828; luego, p29213893; luego, p29782284 y así sucesivamente. El ejemplo establece valores nuevos para el usuario y el grupo de UNIX, así como para el directorio raíz y la base de 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"
}
}
```
## Paso 6 (opcional): validar el manifiesto de CEV
Opcionalmente, compruebe que el manifiesto es un archivo JSON válido al ejecutar el Script de Python `json.tool`. Por ejemplo, si cambia al directorio que contiene un manifiesto CEV denominado `manifest.json`, ejecute el siguiente comando.
```
python -m json.tool < manifest.json
```
## Paso 7: añadir los permisos de IAM necesarios
Asegúrese de que la entidad principal de IAM que crea el CEV tenga las políticas necesarias descritas en [Paso 5: otorgar los permisos necesarios al rol o usuario de IAM](custom-setup-orcl.md#custom-setup-orcl.iam-user).
# Creación de una CEV
Puede crear un CEV mediante el Consola de administración de AWS o el AWS CLI. Especifique la arquitectura multitenencia o no multitenencia. Para obtener más información, consulte [Consideraciones sobre la arquitectura multitenencia](custom-creating.md#custom-creating.overview).
Normalmente, crear una CEV lleva aproximadamente dos horas. Una vez creada la CEV, puede utilizarla para usarla para crear o actualizar una instancia de base de datos de RDS Custom. Para obtener más información, consulte [Creación de una instancia de base de datos de RDS Custom for Oracle](custom-creating.md#custom-creating.create) y [Actualización de una instancia de base de datos de RDS Custom para Oracle](custom-upgrading-modify.md).
**nota**
Si su instancia de base de datos utiliza actualmente Oracle Linux 7.9, cree un nuevo CEV que utilice la AMI más reciente, que utilice Oracle Linux 8. A continuación, modifique su instancia para usar el nuevo CEV.
Tome nota de los siguientes requisitos y limitaciones para crear una CEV:
+ El bucket de Amazon S3 que incluye los archivos de instalación debe estar en la misma Región de AWS que la CEV. De lo contrario, el proceso de creación producirá un error.
+ El nombre de la CEV debe estar en el formato `major-engine-version.customized_string`, como en `19.cdb_cev1`.
+ El nombre de la CEV debe contener de 1 a 50 caracteres alfanuméricos, guiones bajos, guiones o puntos.
+ El nombre de la CEV no puede contener puntos consecutivos, como en `19..cdb_cev1`.
## Consola
**Para crear una CEV**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Custom engine versions** (Versiones de motor personalizadas).
La página de **Custom engine versions** (Versiones de motor personalizadas) muestra todos las CEV que existen actualmente. Si no ha creado ninguna CEV, la página está vacía.
1. Elija **Crear versión de motor personalizada**.
1. En **Opciones del motor**, haga lo siguiente:
1. En **Engine type** (Tipo de motor), elija **Oracle**.
1. En **Configuración de la arquitectura**, elija **Arquitectura multitenencia** para crear una CEV multiinquilino de Oracle que utilice el motor de base de datos `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. Puede crear una CDB de RDS Custom para Oracle únicamente con una CEV de varios inquilinos. Si no elige esta opción, su CEV no será una CDB que usa el motor `custom-oracle-ee` o `custom-oracle-se2`.
**nota**
La arquitectura que elija será una característica permanente de su CEV. No puede modificar su CEV para usar una arquitectura diferente más adelante.
1. Elija cualquiera de las siguientes opciones:
+ **Crear nueva CEV**: cree una CEV desde cero. En este caso, debe especificar un manifiesto de JSON que especifique los binarios de la base de datos.
+ **Crear CEV a partir de origen**: en **Especificar la CEV que se desea copiar**, seleccione una CEV existente para usarla como la CEV de origen. En este caso, puede especificar una nueva imagen de máquina de Amazon (AMI), pero no puede especificar binarios de base de datos diferentes.
1. En **Versión del motor**, elija la versión principal del motor.
1. En **Detalles de la versión**, realice lo siguiente:
1. Introduzca un nombre válido en **Nombre de la versión del motor personalizada**. Por ejemplo, puede ingresar el nombre **19.cdb\$1cev1**.
1. (Opcional) Escriba una descripción para la CEV.
1. En **Instalación de medios**, haga lo siguiente:
1. (Opcional) En **ID de AMI**, deje el campo en blanco para utilizar la AMI más reciente proporcionada por el servicio o introduzca una AMI que haya utilizado anteriormente para crear una CEV. Para obtener ID de AMI válidos, utilice cualquiera de las siguientes técnicas:
+ En la consola, seleccione **Versiones de motor personalizadas** en el panel de navegación izquierdo y elija el nombre de una CEV. El ID de AMI utilizado por la CEV aparece en la pestaña **Configuración**.
+ En la AWS CLI, utilice el comando `describe-db-engine-versions`. Busque en la salida de `ImageID`.
1. Para **S3 location of manifest files** (Ubicación S3 de los archivos de manifiesto), ingrese la ubicación del bucket de Amazon S3 que especificó en [Paso 3: cargar los archivos de instalación en Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3). Por ejemplo, escriba **s3://my-custom-installation-files/123456789012/cev1/**.
**nota**
La Región de AWS en la que crea la CEV debe ser la misma que la del bucket de S3.
1. (Solo para Crear nueva CEV) En **Manifiesto de la CEV**, introduzca el manifiesto de JSON que ha creado en [Creación del manifiesto de CEV](custom-cev.preparing.md#custom-cev.preparing.manifest.creating).
1. En la sección **Clave de KMS**, seleccione **Escriba un ARN de clave** para ver las claves AWS KMS disponibles. A continuación, seleccione la clave de KMS de la lista.
Se requiere una clave AWS KMS para RDS Custom. Para obtener más información, consulte [Paso 1: crear o reutilizar una clave AWS KMS de cifrado simétrica](custom-setup-orcl.md#custom-setup-orcl.cmk).
1. (Opcional) Seleccione **Añadir una etiqueta nueva** para crear un par clave-valor para su CEV.
1. Elija **Crear versión de motor personalizada**.
Si el manifiesto de JSON tiene un formulario no válido, la consola mostrará **Error al validar el manifiesto de la CEV**. Corrija los problemas e inténtelo de nuevo.
Aparece la página de **Custom engine versions** (Versiones de motor personalizadas). Su CEV se muestra con el estado **Create** (Crear). El proceso para crear la CEV toma aproximadamente dos horas.
## AWS CLI
Para crear una CEV mediante la AWS CLI, ejecute el comando [create-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/create-custom-db-engine-version.html).
Se requieren las siguientes opciones:
+ `--engine`: especifique el tipo de motor. Para una CDB, especifique `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. Para no CDB, especifique `custom-oracle-ee` o `custom-oracle-se2`. Solo puede crear CDB a partir de una CEV creada con `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`. Solo puede crear no CDB a partir de una CEV creada con `custom-oracle-ee` o `custom-oracle-se2`.
+ `--engine-version`: especifique la versión del motor. El formato es *major-engine-version*.*customized\$1string*. El nombre de la CEV debe contener de 1 a 50 caracteres alfanuméricos, guiones bajos, guiones o puntos. El nombre de la CEV no puede contener puntos consecutivos, como en `19..cdb_cev1`.
+ `--kms-key-id`: especifique un AWS KMS key.
+ `--manifest`: especifique `manifest_json_string` o `--manifest file:file_name`. No se permiten caracteres de nueva línea en `manifest_json_string`. Asegúrese de escapar de las comillas dobles (") en el código JSON prefijándolos con una barra invertida (\$1).
En el siguiente ejemplo, se muestra `manifest_json_string` para 19c desde [Paso 5: preparar el manifiesto de la CEV](custom-cev.preparing.md#custom-cev.preparing.manifest). El ejemplo establece valores nuevos para la base de Oracle, la página de inicio de Oracle, y el ID y el nombre del usuario y el grupo de UNIX/Linux. Si copia esta cadena, elimine todos los caracteres de nueva línea antes de pegarla en el 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`: ponga el mismo nombre de bucket que haya puesto en [Paso 3: cargar los archivos de instalación en Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3). La Región de AWS donde ejecute `create-custom-db-engine-version` debe estar en la misma región que el bucket de Amazon S3.
También puede especificar las siguientes opciones:
+ `--description`: ponga una descripción de la CEV.
+ `--database-installation-files-s3-prefix`: ponga el mismo nombre de carpeta que haya puesto en [Paso 3: cargar los archivos de instalación en Amazon S3](custom-cev.preparing.md#custom-cev.preparing.s3).
+ `--image-id`: especifique el ID de AMI que desea reutilizar. Para encontrar ID válidos, ejecute el comando `describe-db-engine-versions` y, a continuación, busque el resultado de `ImageID`. De forma predeterminada, RDS Custom para Oracle utiliza la AMI más reciente disponible.
El siguiente ejemplo crea una CEV multitenencia de Oracle denominada `19.cdb_cev1`. En el ejemplo, se reutiliza una AMI existente en lugar de utilizar la AMI más reciente disponible. Asegúrese de que el nombre de la CEV comience con el número de versión principal del motor.
**Example**
Para 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
```
Para 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**
Obtenga detalles acerca de su CEV mediante el comando `describe-db-engine-versions`.
```
1. aws rds describe-db-engine-versions \
2. --engine custom-oracle-se2-cdb \
3. --include-all
```
El siguiente resultado de ejemplo parcial muestra el motor, los grupos de parámetros, el manifiesto y otra información.
```
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. ...
```
## No se ha creado una CEV
Si la creación de CEV falla, RDS Custom emite `RDS-EVENT-0198` con el mensaje `Creation failed for custom engine version major-engine-version.cev_name` e incluye detalles sobre el error. Por ejemplo, el evento imprime los archivos que faltan.
No puede modificar una CEV que haya fallado. Solo puede eliminarlo y, a continuación, volver a intentar crear una CEV después de corregir las causas del error. Para obtener información sobre la solución de problemas de los motivos del error de creación de CEV, consulte [Solución de problemas de creación de versiones de motores personalizados para RDS Custom for Oracle](custom-troubleshooting.md#custom-troubleshooting.cev).
# Modificación del estado de CEV
Puede modificar una CEV mediante la Consola de administración de AWS o la AWS CLI. Puede modificar la descripción de la CEV o su estado de disponibilidad. La CEV tiene uno de los siguientes valores de estado:
+ `available` – Puede utilizar esta CEV para crear una nueva instancia de base de datos de RDS Custom o actualizar una instancia de base de datos. Este es el estado predeterminado de una CEV recién creada.
+ `inactive` – No se puede crear ni actualizar una instancia de RDS Custom con esta CEV. No puede restaurar una instantánea de base de datos para crear una nueva instancia de base de datos de RDS Custom con esta CEV.
Puede cambiar la CEV de cualquier estado compatible a cualquier otro estado admitido. Puede cambiar el estado para evitar el uso accidental de un CEV o hacer que un CEV interrumpido pueda utilizarse de nuevo. Por ejemplo, puede cambiar el estado de su CEV desde `available` a `inactive`, y `inactive` de vuelta a `available`.
## Consola
**Para modificar una CEV**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Custom engine versions** (Versiones de motor personalizadas).
1. Elija una CEV cuya descripción o estado desee modificar.
1. Para **Actions (Acciones)**, elija **Modify (Modificar)**.
1. Realice cualquiera de los siguientes cambios:
+ Para **CEV status settings** (Configuración del estado de CEV), elija un nuevo estado de disponibilidad.
+ Para **Version description** (Descripción de la versión), ingrese una nueva descripción.
1. Elija **Modify CEV** (Modificar CEV).
Si la CEV está en uso, la consola muestra **You can't modify the CEV status** (No se puede modificar el estado de la CEV). Corrija los problemas e inténtelo de nuevo.
Aparece la página de **Custom engine versions** (Versiones de motor personalizadas).
## AWS CLI
Para modificar una CEV mediante la AWS CLI, ejecute el comando [modify-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-custom-db-engine-version.html). Puede encontrar las CEV para modificarlas al ejecutar el comando [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Se requieren las siguientes opciones:
+ `--engine engine-type`, donde *engine-type* es `custom-oracle-ee`, `custom-oracle-se2`, `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`
+ `--engine-version cev`, donde *`cev`* es el nombre de la versión del motor personalizada que desea modificar
+ `--status`` status`, donde *`status`* es el estado de disponibilidad que desea asignar a la CEV
En el siguiente ejemplo se cambia una CEV denominada `19.my_cev1` de su estado actual a `inactive`.
**Example**
Para 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
```
En:Windows
```
1. aws rds modify-custom-db-engine-version ^
2. --engine custom-oracle-se2 ^
3. --engine-version 19.my_cev1 ^
4. --status inactive
```
# Visualización de detalles de la CEV de Amazon RDS Custom para Oracle
Puede ver los detalles sobre su manifiesto CEV y el comando utilizado para crear su CEV mediante la Consola de administración de AWS o la AWS CLI.
## Consola
**Para ver los detalles de la CEV**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Custom engine versions** (Versiones de motor personalizadas).
La página de **Custom engine versions** (Versiones de motor personalizadas) muestra todos las CEV que existen actualmente. Si no ha creado ninguna CEV, la página está vacía.
1. Elija el nombre de la CEV que desea ver.
1. Elija **Configuration** (Configuración) para ver los parámetros de instalación especificados en el manifiesto.
![\[Vea los parámetros de instalación de una CEV.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/cev-configuration-tab.png)
1. Elija **Manifest** (Manifiesto) para ver los parámetros de instalación especificados en la opción `--manifest` del comando `create-custom-db-engine-version`. Puede copiar este texto, reemplazar los valores según sea necesario y utilizarlos en un comando nuevo.
![\[Visualice el comando utilizado para crear la CEV.\]](http://docs.aws.amazon.com/es_es/AmazonRDS/latest/UserGuide/images/cev-manifest-tab.png)
## AWS CLI
Para ver detalles acerca de una CEV mediante la AWS CLI, ejecute el comando [describe-db-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Se requieren las siguientes opciones:
+ `--engine engine-type`, donde *engine-type* es `custom-oracle-ee`, `custom-oracle-se2`, `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`
+ `--engine-version major-engine-version.customized_string`
En el siguiente ejemplo, se crea una CEV que no es CDB y que utiliza Enterprise Edition. El nombre de la CEV `19.my_cev1` comienza con el número de versión principal del motor, que es obligatorio.
**Example**
Para Linux, macOS o:Unix
```
1. aws rds describe-db-engine-versions \
2. --engine custom-oracle-ee \
3. --engine-version 19.my_cev1
```
En:Windows
```
1. aws rds describe-db-engine-versions ^
2. --engine custom-oracle-ee ^
3. --engine-version 19.my_cev1
```
El siguiente resultado de ejemplo parcial muestra el motor, los grupos de parámetros, el manifiesto y otra información.
```
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. ]
```
# Eliminación de una CEV
Puede eliminar una CEV con la Consola de administración de AWS o la AWS CLI. Por lo general, la eliminación tarda unos minutos.
Para eliminar una CEV, no puede estar en uso por ninguno de los siguientes:
+ Una instancia de base de datos de RDS Custom
+ Instantánea de una instancia de base de datos de RDS Custom
+ Una copia de seguridad automatizada de su instancia de base de datos de RDS Custom
## Consola
**Para eliminar una CEV**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon RDS en [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. En el panel de navegación, elija **Custom engine versions** (Versiones de motor personalizadas).
1. Elija una CEV cuya descripción o estado desea eliminar.
1. En **Actions (Acciones)**, seleccione **Delete (Eliminar)**.
Aparece el cuadro de diálogo **Delete *cev\$1name*?** (¿Desea eliminar cev\$1name?).
1. Introduzca **delete me** y luego escriba **Delete (Eliminar)**.
En la página de **Custom engine versions** (Versiones de motor personalizadas), el banner muestra que se está eliminando su CEV.
## AWS CLI
Para eliminar una CEV mediante la AWS CLI, ejecute el comando [delete-custom-db-engine-version](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-custom-db-engine-version.html).
Se requieren las siguientes opciones:
+ `--engine engine-type`, donde *engine-type* es `custom-oracle-ee`, `custom-oracle-se2`, `custom-oracle-ee-cdb` o `custom-oracle-se2-cdb`
+ `--engine-version cev`, donde *cev* es el nombre de la versión del motor personalizada que se va a eliminar
El siguiente ejemplo elimina una CEV denominada `19.my_cev1`.
**Example**
Para Linux, macOS o:Unix
```
1. aws rds delete-custom-db-engine-version \
2. --engine custom-oracle-ee \
3. --engine-version 19.my_cev1
```
En:Windows
```
1. aws rds delete-custom-db-engine-version ^
2. --engine custom-oracle-ee ^
3. --engine-version 19.my_cev1
```