pulumi-aws-kotlin/com.pulumi.aws.rds.kotlin/CustomDbEngineVersion

CustomDbEngineVersion

class CustomDbEngineVersion : KotlinCustomResource

Provides an custom engine version (CEV) resource for Amazon RDS Custom. For additional information, see Working with CEVs for RDS Custom for Oracle and Working with CEVs for RDS Custom for SQL Server in the the RDS User Guide.

Example Usage

RDS Custom for Oracle Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.kms.Key("example", {description: "KMS symmetric key for RDS Custom for Oracle"});
const exampleCustomDbEngineVersion = new aws.rds.CustomDbEngineVersion("example", {
    databaseInstallationFilesS3BucketName: "DOC-EXAMPLE-BUCKET",
    databaseInstallationFilesS3Prefix: "1915_GI/",
    engine: "custom-oracle-ee-cdb",
    engineVersion: "19.cdb_cev1",
    kmsKeyId: example.arn,
    manifest: `  {
\x09"databaseInstallationFileNames":["V982063-01.zip"]
  }
`,
    tags: {
        Name: "example",
        Key: "value",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.kms.Key("example", description="KMS symmetric key for RDS Custom for Oracle")
example_custom_db_engine_version = aws.rds.CustomDbEngineVersion("example",
    database_installation_files_s3_bucket_name="DOC-EXAMPLE-BUCKET",
    database_installation_files_s3_prefix="1915_GI/",
    engine="custom-oracle-ee-cdb",
    engine_version="19.cdb_cev1",
    kms_key_id=example.arn,
    manifest="""  {
\x09"databaseInstallationFileNames":["V982063-01.zip"]
  }
""",
    tags={
        "Name": "example",
        "Key": "value",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kms.Key("example", new()
    {
        Description = "KMS symmetric key for RDS Custom for Oracle",
    });
    var exampleCustomDbEngineVersion = new Aws.Rds.CustomDbEngineVersion("example", new()
    {
        DatabaseInstallationFilesS3BucketName = "DOC-EXAMPLE-BUCKET",
        DatabaseInstallationFilesS3Prefix = "1915_GI/",
        Engine = "custom-oracle-ee-cdb",
        EngineVersion = "19.cdb_cev1",
        KmsKeyId = example.Arn,
        Manifest = @"  {
	""databaseInstallationFileNames"":[""V982063-01.zip""]
  }
",
        Tags =
        {
            { "Name", "example" },
            { "Key", "value" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kms"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := kms.NewKey(ctx, "example", &kms.KeyArgs{
			Description: pulumi.String("KMS symmetric key for RDS Custom for Oracle"),
		})
		if err != nil {
			return err
		}
		_, err = rds.NewCustomDbEngineVersion(ctx, "example", &rds.CustomDbEngineVersionArgs{
			DatabaseInstallationFilesS3BucketName: pulumi.String("DOC-EXAMPLE-BUCKET"),
			DatabaseInstallationFilesS3Prefix:     pulumi.String("1915_GI/"),
			Engine:                                pulumi.String("custom-oracle-ee-cdb"),
			EngineVersion:                         pulumi.String("19.cdb_cev1"),
			KmsKeyId:                              example.Arn,
			Manifest:                              pulumi.String("  {\n	\"databaseInstallationFileNames\":[\"V982063-01.zip\"]\n  }\n"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example"),
				"Key":  pulumi.String("value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kms.Key;
import com.pulumi.aws.kms.KeyArgs;
import com.pulumi.aws.rds.CustomDbEngineVersion;
import com.pulumi.aws.rds.CustomDbEngineVersionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Key("example", KeyArgs.builder()
            .description("KMS symmetric key for RDS Custom for Oracle")
            .build());
        var exampleCustomDbEngineVersion = new CustomDbEngineVersion("exampleCustomDbEngineVersion", CustomDbEngineVersionArgs.builder()
            .databaseInstallationFilesS3BucketName("DOC-EXAMPLE-BUCKET")
            .databaseInstallationFilesS3Prefix("1915_GI/")
            .engine("custom-oracle-ee-cdb")
            .engineVersion("19.cdb_cev1")
            .kmsKeyId(example.arn())
            .manifest("""
  {
	"databaseInstallationFileNames":["V982063-01.zip"]
  }
            """)
            .tags(Map.ofEntries(
                Map.entry("Name", "example"),
                Map.entry("Key", "value")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:kms:Key
    properties:
      description: KMS symmetric key for RDS Custom for Oracle
  exampleCustomDbEngineVersion:
    type: aws:rds:CustomDbEngineVersion
    name: example
    properties:
      databaseInstallationFilesS3BucketName: DOC-EXAMPLE-BUCKET
      databaseInstallationFilesS3Prefix: 1915_GI/
      engine: custom-oracle-ee-cdb
      engineVersion: 19.cdb_cev1
      kmsKeyId: ${example.arn}
      manifest: |2
          {
        	"databaseInstallationFileNames":["V982063-01.zip"]
          }
      tags:
        Name: example
        Key: value
Content copied to clipboard

RDS Custom for Oracle External Manifest Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as std from "@pulumi/std";
const example = new aws.kms.Key("example", {description: "KMS symmetric key for RDS Custom for Oracle"});
const exampleCustomDbEngineVersion = new aws.rds.CustomDbEngineVersion("example", {
    databaseInstallationFilesS3BucketName: "DOC-EXAMPLE-BUCKET",
    databaseInstallationFilesS3Prefix: "1915_GI/",
    engine: "custom-oracle-ee-cdb",
    engineVersion: "19.cdb_cev1",
    kmsKeyId: example.arn,
    filename: "manifest_1915_GI.json",
    manifestHash: std.filebase64sha256({
        input: json,
    }).then(invoke => invoke.result),
    tags: {
        Name: "example",
        Key: "value",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
import pulumi_std as std
example = aws.kms.Key("example", description="KMS symmetric key for RDS Custom for Oracle")
example_custom_db_engine_version = aws.rds.CustomDbEngineVersion("example",
    database_installation_files_s3_bucket_name="DOC-EXAMPLE-BUCKET",
    database_installation_files_s3_prefix="1915_GI/",
    engine="custom-oracle-ee-cdb",
    engine_version="19.cdb_cev1",
    kms_key_id=example.arn,
    filename="manifest_1915_GI.json",
    manifest_hash=std.filebase64sha256(input=json).result,
    tags={
        "Name": "example",
        "Key": "value",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
using Std = Pulumi.Std;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Kms.Key("example", new()
    {
        Description = "KMS symmetric key for RDS Custom for Oracle",
    });
    var exampleCustomDbEngineVersion = new Aws.Rds.CustomDbEngineVersion("example", new()
    {
        DatabaseInstallationFilesS3BucketName = "DOC-EXAMPLE-BUCKET",
        DatabaseInstallationFilesS3Prefix = "1915_GI/",
        Engine = "custom-oracle-ee-cdb",
        EngineVersion = "19.cdb_cev1",
        KmsKeyId = example.Arn,
        Filename = "manifest_1915_GI.json",
        ManifestHash = Std.Filebase64sha256.Invoke(new()
        {
            Input = json,
        }).Apply(invoke => invoke.Result),
        Tags =
        {
            { "Name", "example" },
            { "Key", "value" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kms"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := kms.NewKey(ctx, "example", &kms.KeyArgs{
			Description: pulumi.String("KMS symmetric key for RDS Custom for Oracle"),
		})
		if err != nil {
			return err
		}
		invokeFilebase64sha256, err := std.Filebase64sha256(ctx, &std.Filebase64sha256Args{
			Input: json,
		}, nil)
		if err != nil {
			return err
		}
		_, err = rds.NewCustomDbEngineVersion(ctx, "example", &rds.CustomDbEngineVersionArgs{
			DatabaseInstallationFilesS3BucketName: pulumi.String("DOC-EXAMPLE-BUCKET"),
			DatabaseInstallationFilesS3Prefix:     pulumi.String("1915_GI/"),
			Engine:                                pulumi.String("custom-oracle-ee-cdb"),
			EngineVersion:                         pulumi.String("19.cdb_cev1"),
			KmsKeyId:                              example.Arn,
			Filename:                              pulumi.String("manifest_1915_GI.json"),
			ManifestHash:                          pulumi.String(invokeFilebase64sha256.Result),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("example"),
				"Key":  pulumi.String("value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.kms.Key;
import com.pulumi.aws.kms.KeyArgs;
import com.pulumi.aws.rds.CustomDbEngineVersion;
import com.pulumi.aws.rds.CustomDbEngineVersionArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Filebase64sha256Args;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Key("example", KeyArgs.builder()
            .description("KMS symmetric key for RDS Custom for Oracle")
            .build());
        var exampleCustomDbEngineVersion = new CustomDbEngineVersion("exampleCustomDbEngineVersion", CustomDbEngineVersionArgs.builder()
            .databaseInstallationFilesS3BucketName("DOC-EXAMPLE-BUCKET")
            .databaseInstallationFilesS3Prefix("1915_GI/")
            .engine("custom-oracle-ee-cdb")
            .engineVersion("19.cdb_cev1")
            .kmsKeyId(example.arn())
            .filename("manifest_1915_GI.json")
            .manifestHash(StdFunctions.filebase64sha256(Filebase64sha256Args.builder()
                .input(json)
                .build()).result())
            .tags(Map.ofEntries(
                Map.entry("Name", "example"),
                Map.entry("Key", "value")
            ))
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:kms:Key
    properties:
      description: KMS symmetric key for RDS Custom for Oracle
  exampleCustomDbEngineVersion:
    type: aws:rds:CustomDbEngineVersion
    name: example
    properties:
      databaseInstallationFilesS3BucketName: DOC-EXAMPLE-BUCKET
      databaseInstallationFilesS3Prefix: 1915_GI/
      engine: custom-oracle-ee-cdb
      engineVersion: 19.cdb_cev1
      kmsKeyId: ${example.arn}
      filename: manifest_1915_GI.json
      manifestHash:
        fn::invoke:
          function: std:filebase64sha256
          arguments:
            input: ${json}
          return: result
      tags:
        Name: example
        Key: value
Content copied to clipboard

RDS Custom for SQL Server Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// CEV creation requires an AMI owned by the operator
const test = new aws.rds.CustomDbEngineVersion("test", {
    engine: "custom-sqlserver-se",
    engineVersion: "15.00.4249.2.cev-1",
    sourceImageId: "ami-0aa12345678a12ab1",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# CEV creation requires an AMI owned by the operator
test = aws.rds.CustomDbEngineVersion("test",
    engine="custom-sqlserver-se",
    engine_version="15.00.4249.2.cev-1",
    source_image_id="ami-0aa12345678a12ab1")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // CEV creation requires an AMI owned by the operator
    var test = new Aws.Rds.CustomDbEngineVersion("test", new()
    {
        Engine = "custom-sqlserver-se",
        EngineVersion = "15.00.4249.2.cev-1",
        SourceImageId = "ami-0aa12345678a12ab1",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// CEV creation requires an AMI owned by the operator
		_, err := rds.NewCustomDbEngineVersion(ctx, "test", &rds.CustomDbEngineVersionArgs{
			Engine:        pulumi.String("custom-sqlserver-se"),
			EngineVersion: pulumi.String("15.00.4249.2.cev-1"),
			SourceImageId: pulumi.String("ami-0aa12345678a12ab1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.rds.CustomDbEngineVersion;
import com.pulumi.aws.rds.CustomDbEngineVersionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        // CEV creation requires an AMI owned by the operator
        var test = new CustomDbEngineVersion("test", CustomDbEngineVersionArgs.builder()
            .engine("custom-sqlserver-se")
            .engineVersion("15.00.4249.2.cev-1")
            .sourceImageId("ami-0aa12345678a12ab1")
            .build());
    }
}
Content copied to clipboard
resources:
  # CEV creation requires an AMI owned by the operator
  test:
    type: aws:rds:CustomDbEngineVersion
    properties:
      engine: custom-sqlserver-se
      engineVersion: 15.00.4249.2.cev-1
      sourceImageId: ami-0aa12345678a12ab1
Content copied to clipboard

RDS Custom for SQL Server Usage with AMI from another region

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.ec2.AmiCopy("example", {
    name: "sqlserver-se-2019-15.00.4249.2",
    description: "A copy of ami-xxxxxxxx",
    sourceAmiId: "ami-xxxxxxxx",
    sourceAmiRegion: "us-east-1",
});
// CEV creation requires an AMI owned by the operator
const test = new aws.rds.CustomDbEngineVersion("test", {
    engine: "custom-sqlserver-se",
    engineVersion: "15.00.4249.2.cev-1",
    sourceImageId: example.id,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.ec2.AmiCopy("example",
    name="sqlserver-se-2019-15.00.4249.2",
    description="A copy of ami-xxxxxxxx",
    source_ami_id="ami-xxxxxxxx",
    source_ami_region="us-east-1")
# CEV creation requires an AMI owned by the operator
test = aws.rds.CustomDbEngineVersion("test",
    engine="custom-sqlserver-se",
    engine_version="15.00.4249.2.cev-1",
    source_image_id=example.id)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Ec2.AmiCopy("example", new()
    {
        Name = "sqlserver-se-2019-15.00.4249.2",
        Description = "A copy of ami-xxxxxxxx",
        SourceAmiId = "ami-xxxxxxxx",
        SourceAmiRegion = "us-east-1",
    });
    // CEV creation requires an AMI owned by the operator
    var test = new Aws.Rds.CustomDbEngineVersion("test", new()
    {
        Engine = "custom-sqlserver-se",
        EngineVersion = "15.00.4249.2.cev-1",
        SourceImageId = example.Id,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/rds"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := ec2.NewAmiCopy(ctx, "example", &ec2.AmiCopyArgs{
			Name:            pulumi.String("sqlserver-se-2019-15.00.4249.2"),
			Description:     pulumi.String("A copy of ami-xxxxxxxx"),
			SourceAmiId:     pulumi.String("ami-xxxxxxxx"),
			SourceAmiRegion: pulumi.String("us-east-1"),
		})
		if err != nil {
			return err
		}
		// CEV creation requires an AMI owned by the operator
		_, err = rds.NewCustomDbEngineVersion(ctx, "test", &rds.CustomDbEngineVersionArgs{
			Engine:        pulumi.String("custom-sqlserver-se"),
			EngineVersion: pulumi.String("15.00.4249.2.cev-1"),
			SourceImageId: example.ID(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ec2.AmiCopy;
import com.pulumi.aws.ec2.AmiCopyArgs;
import com.pulumi.aws.rds.CustomDbEngineVersion;
import com.pulumi.aws.rds.CustomDbEngineVersionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new AmiCopy("example", AmiCopyArgs.builder()
            .name("sqlserver-se-2019-15.00.4249.2")
            .description("A copy of ami-xxxxxxxx")
            .sourceAmiId("ami-xxxxxxxx")
            .sourceAmiRegion("us-east-1")
            .build());
        // CEV creation requires an AMI owned by the operator
        var test = new CustomDbEngineVersion("test", CustomDbEngineVersionArgs.builder()
            .engine("custom-sqlserver-se")
            .engineVersion("15.00.4249.2.cev-1")
            .sourceImageId(example.id())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:ec2:AmiCopy
    properties:
      name: sqlserver-se-2019-15.00.4249.2
      description: A copy of ami-xxxxxxxx
      sourceAmiId: ami-xxxxxxxx
      sourceAmiRegion: us-east-1
  # CEV creation requires an AMI owned by the operator
  test:
    type: aws:rds:CustomDbEngineVersion
    properties:
      engine: custom-sqlserver-se
      engineVersion: 15.00.4249.2.cev-1
      sourceImageId: ${example.id}
Content copied to clipboard

Import

Using pulumi import, import custom engine versions for Amazon RDS custom using the engine and engine_version separated by a colon (:). For example:

$ pulumi import aws:rds/customDbEngineVersion:CustomDbEngineVersion example custom-oracle-ee-cdb:19.cdb_cev1
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

The Amazon Resource Name (ARN) for the custom engine version.

Link copied to clipboard
val createTime: Output<String>

The date and time that the CEV was created.

Link copied to clipboard
val databaseInstallationFilesS3BucketName: Output<String>?

The name of the Amazon S3 bucket that contains the database installation files.

Link copied to clipboard
val databaseInstallationFilesS3Prefix: Output<String>?

The prefix for the Amazon S3 bucket that contains the database installation files.

Link copied to clipboard
val dbParameterGroupFamily: Output<String>

The name of the DB parameter group family for the CEV.

Link copied to clipboard
val description: Output<String>?

The description of the CEV.

Link copied to clipboard
val engine: Output<String>

The name of the database engine. Valid values are custom-oracle*, custom-sqlserver*.

Link copied to clipboard
val engineVersion: Output<String>

The version of the database engine.

Link copied to clipboard
val filename: Output<String>?

The name of the manifest file within the local filesystem. Conflicts with manifest.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val imageId: Output<String>

The ID of the AMI that was created with the CEV.

Link copied to clipboard
val kmsKeyId: Output<String>

The ARN of the AWS KMS key that is used to encrypt the database installation files. Required for RDS Custom for Oracle.

Link copied to clipboard
val majorEngineVersion: Output<String>

The major version of the database engine.

Link copied to clipboard
val manifest: Output<String>?

The manifest file, in JSON format, that contains the list of database installation files. Conflicts with filename.

Link copied to clipboard
val manifestComputed: Output<String>

The returned manifest file, in JSON format, service generated and often different from input manifest.

Link copied to clipboard
val manifestHash: Output<String>?

Used to trigger updates. Must be set to a base64-encoded SHA256 hash of the manifest source specified with filename. The usual way to set this is filebase64sha256("manifest.json") where "manifest.json" is the local filename of the manifest source.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val sourceImageId: Output<String>?

The ID of the AMI to create the CEV from. Required for RDS Custom for SQL Server. For RDS Custom for Oracle, you can specify an AMI ID that was used in a different Oracle CEV.

Link copied to clipboard
val status: Output<String>

The status of the CEV. Valid values are available, inactive, inactive-except-restore.

Link copied to clipboard
val tags: Output<Map<String, String>>?

A mapping of tags to assign to the resource. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val urn: Output<String>