Class CfnDBInstance

The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.

Inheritance

object

CfnElement

CfnRefElement

CfnResource

CfnDBInstance

Implements

IInspectable

IDBInstanceRef

IConstruct

IDependable

IEnvironmentAware

ITaggable

Inherited Members

CfnResource.IsCfnResource(object)

CfnResource.AddDeletionOverride(string)

CfnResource.AddDependency(CfnResource)

CfnResource.AddDependsOn(CfnResource)

CfnResource.AddMetadata(string, object)

CfnResource.AddOverride(string, object)

CfnResource.AddPropertyDeletionOverride(string)

CfnResource.AddPropertyOverride(string, object)

CfnResource.ApplyRemovalPolicy(RemovalPolicy?, IRemovalPolicyOptions)

CfnResource.CfnPropertyName(string)

CfnResource.GetAtt(string, ResolutionTypeHint?)

CfnResource.GetMetadata(string)

CfnResource.ObtainDependencies()

CfnResource.ObtainResourceDependencies()

CfnResource.RemoveDependency(CfnResource)

CfnResource.ReplaceDependency(CfnResource, CfnResource)

CfnResource.ShouldSynthesize()

CfnResource.ToString()

CfnResource.ValidateProperties(object)

CfnResource.CfnOptions

CfnResource.CfnResourceType

CfnResource.Env

CfnResource.UpdatedProperites

CfnResource.UpdatedProperties

CfnRefElement.Ref

CfnElement.IsCfnElement(object)

CfnElement.OverrideLogicalId(string)

CfnElement.With(params IMixin[])

CfnElement.CreationStack

CfnElement.LogicalId

CfnElement.Stack

Namespace: Amazon.CDK.AWS.Neptune

Assembly: Amazon.CDK.Lib.dll

Syntax (csharp)

public class CfnDBInstance : CfnResource, IInspectable, IDBInstanceRef, IConstruct, IDependable, IEnvironmentAware, ITaggable

Syntax (vb)

Public Class CfnDBInstance Inherits CfnResource Implements IInspectable, IDBInstanceRef, IConstruct, IDependable, IEnvironmentAware, ITaggable

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

Examples

// The code below shows an example of how to instantiate this type.
             // The values are placeholders you should change.
             using Amazon.CDK.AWS.Neptune;

             var cfnDBInstance = new CfnDBInstance(this, "MyCfnDBInstance", new CfnDBInstanceProps {
                 DbInstanceClass = "dbInstanceClass",

                 // the properties below are optional
                 AllowMajorVersionUpgrade = false,
                 AutoMinorVersionUpgrade = false,
                 AvailabilityZone = "availabilityZone",
                 DbClusterIdentifier = "dbClusterIdentifier",
                 DbInstanceIdentifier = "dbInstanceIdentifier",
                 DbParameterGroupName = "dbParameterGroupName",
                 DbSnapshotIdentifier = "dbSnapshotIdentifier",
                 DbSubnetGroupName = "dbSubnetGroupName",
                 PreferredMaintenanceWindow = "preferredMaintenanceWindow",
                 PubliclyAccessible = false,
                 Tags = new [] { new CfnTag {
                     Key = "key",
                     Value = "value"
                 } }
             });

Synopsis

Constructors

CfnDBInstance(Construct, string, ICfnDBInstanceProps)

Create a new AWS::Neptune::DBInstance.

Properties

AllowMajorVersionUpgrade	Indicates that major version upgrades are allowed.
AttrEndpoint	The connection endpoint for the database.
AttrPort	The port number on which the database accepts connections.
AutoMinorVersionUpgrade	Indicates that minor version patches are applied automatically.
AvailabilityZone	Specifies the name of the Availability Zone the DB instance is located in.
CFN_RESOURCE_TYPE_NAME	The CloudFormation resource type name for this resource class.
CfnProperties	The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.
CfnPropertyNames	The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.
DbClusterIdentifier	If the DB instance is a member of a DB cluster, contains the name of the DB cluster that the DB instance is a member of.
DbInstanceClass	Contains the name of the compute and memory capacity class of the DB instance.
DbInstanceIdentifier	Contains a user-supplied database identifier.
DbInstanceRef	A reference to a DBInstance resource.
DbParameterGroupName	The name of an existing DB parameter group or a reference to an AWS::Neptune::DBParameterGroup resource created in the template.
DbSnapshotIdentifier	(deprecated) This parameter is not supported.
DbSubnetGroupName	A DB subnet group to associate with the DB instance.
PreferredMaintenanceWindow	Specifies the weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).
PubliclyAccessible	Indicates whether the DB instance is publicly accessible.
Tags	Tag Manager which manages the tags for this resource.
TagsRaw	An arbitrary set of tags (key-value pairs) for this DB instance.

Methods

Inspect(TreeInspector)	Examines the CloudFormation resource and discloses attributes.
IsCfnDBInstance(object)	Checks whether the given object is a CfnDBInstance.
RenderProperties(IDictionary<string, object>)	The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.

Constructors

CfnDBInstance(Construct, string, ICfnDBInstanceProps)

Create a new AWS::Neptune::DBInstance.

public CfnDBInstance(Construct scope, string id, ICfnDBInstanceProps props)

Parameters

scope Construct

Scope in which this resource is defined.

id string

Construct identifier for this resource (unique in its scope).

props ICfnDBInstanceProps

Resource properties.

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

Properties

AllowMajorVersionUpgrade

Indicates that major version upgrades are allowed.

public virtual object? AllowMajorVersionUpgrade { get; set; }

Property Value

object

Remarks

Type union: either bool or IResolvable

AttrEndpoint

The connection endpoint for the database.

public virtual string AttrEndpoint { get; }

Property Value

string

Remarks

For example: mystack-mydb-1apw1j4phylrk.cg034hpkmmjt.us-east-2.rds.amazonaws.com .

CloudformationAttribute: Endpoint

AttrPort

The port number on which the database accepts connections.

public virtual string AttrPort { get; }

Property Value

string

Remarks

For example: 8182 .

CloudformationAttribute: Port

AutoMinorVersionUpgrade

Indicates that minor version patches are applied automatically.

public virtual object? AutoMinorVersionUpgrade { get; set; }

Property Value

object

Remarks

Type union: either bool or IResolvable

AvailabilityZone

Specifies the name of the Availability Zone the DB instance is located in.

public virtual string? AvailabilityZone { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

CFN_RESOURCE_TYPE_NAME

The CloudFormation resource type name for this resource class.

public static string CFN_RESOURCE_TYPE_NAME { get; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

CfnProperties

The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.

protected override IDictionary<string, object> CfnProperties { get; }

Property Value

IDictionary<string, object>

Overrides

CfnResource.CfnProperties

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

CfnPropertyNames

The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.

protected override IDictionary<string, string> CfnPropertyNames { get; }

Property Value

IDictionary<string, string>

Overrides

CfnResource.CfnPropertyNames

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbClusterIdentifier

If the DB instance is a member of a DB cluster, contains the name of the DB cluster that the DB instance is a member of.

public virtual string? DbClusterIdentifier { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbInstanceClass

Contains the name of the compute and memory capacity class of the DB instance.

public virtual string DbInstanceClass { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbInstanceIdentifier

Contains a user-supplied database identifier.

public virtual string? DbInstanceIdentifier { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbInstanceRef

A reference to a DBInstance resource.

public virtual IDBInstanceReference DbInstanceRef { get; }

Property Value

IDBInstanceReference

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbParameterGroupName

The name of an existing DB parameter group or a reference to an AWS::Neptune::DBParameterGroup resource created in the template.

public virtual string? DbParameterGroupName { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

DbSnapshotIdentifier

(deprecated) This parameter is not supported.

[Obsolete("this property has been deprecated")]
public virtual string? DbSnapshotIdentifier { get; set; }

Property Value

string

Remarks

Stability: Deprecated

DbSubnetGroupName

A DB subnet group to associate with the DB instance.

public virtual string? DbSubnetGroupName { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

PreferredMaintenanceWindow

Specifies the weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).

public virtual string? PreferredMaintenanceWindow { get; set; }

Property Value

string

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

PubliclyAccessible

Indicates whether the DB instance is publicly accessible.

public virtual object? PubliclyAccessible { get; set; }

Property Value

object

Remarks

Type union: either bool or IResolvable

Tags

Tag Manager which manages the tags for this resource.

public virtual TagManager Tags { get; }

Property Value

TagManager

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

TagsRaw

An arbitrary set of tags (key-value pairs) for this DB instance.

public virtual ICfnTag[]? TagsRaw { get; set; }

Property Value

ICfnTag[]

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

Methods

Inspect(TreeInspector)

Examines the CloudFormation resource and discloses attributes.

public virtual void Inspect(TreeInspector inspector)

Parameters

inspector TreeInspector

tree inspector to collect and process attributes.

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

IsCfnDBInstance(object)

Checks whether the given object is a CfnDBInstance.

public static bool IsCfnDBInstance(object x)

Parameters

x object

Returns

bool

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

RenderProperties(IDictionary<string, object>)

The AWS::Neptune::DBInstance type creates an Amazon Neptune DB instance.

protected override IDictionary<string, object> RenderProperties(IDictionary<string, object> props)

Parameters

props IDictionary<string, object>

Returns

IDictionary<string, object>

Overrides

CfnResource.RenderProperties(IDictionary<string, object>)

Remarks

Updating DB Instances

You can set a deletion policy for your DB instance to control how CloudFormation handles the instance when the stack is deleted. For Neptune DB instances, you can choose to retain the instance, to delete the instance, or to create a snapshot of the instance. The default CloudFormation behavior depends on the DBClusterIdentifier property:

Deleting DB Instances

If a DB instance is deleted or replaced during an update, CloudFormation deletes all automated snapshots. However, it retains manual DB snapshots. During an update that requires replacement, you can apply a stack policy to prevent DB instances from being replaced.

When properties labeled Update requires: Replacement are updated, CloudFormation first creates a replacement DB instance, changes references from other dependent resources to point to the replacement DB instance, and finally deletes the old DB instance.

We highly recommend that you take a snapshot of the database before updating the stack. If you don't, you lose the data when CloudFormation replaces your DB instance. To preserve your data, perform the following procedure:

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-neptune-dbinstance.html

CloudformationResource: AWS::Neptune::DBInstance

ExampleMetadata: fixture=_generated

Implements

IInspectable

IDBInstanceRef

Constructs.IConstruct

Constructs.IDependable

IEnvironmentAware

ITaggable