awscdkneptunealpha

package module
v2.144.0-alpha.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 31, 2024 License: Apache-2.0 Imports: 12 Imported by: 0

README

Amazon Neptune Construct Library

---

The APIs of higher level constructs in this module are experimental and under active development. They are subject to non-backward compatible changes or removal in any future version. These are not subject to the Semantic Versioning model and breaking changes will be announced in the release notes. This means that while you may use them, you may need to update your source code when upgrading to a newer version of this package.

Amazon Neptune is a fast, reliable, fully managed graph database service that makes it easy to build and run applications that work with highly connected datasets. The core of Neptune is a purpose-built, high-performance graph database engine. This engine is optimized for storing billions of relationships and querying the graph with milliseconds latency. Neptune supports the popular graph query languages Apache TinkerPop Gremlin and W3C’s SPARQL, enabling you to build queries that efficiently navigate highly connected datasets.

The @aws-cdk/aws-neptune-alpha package contains primitives for setting up Neptune database clusters and instances.

import neptune "github.com/aws/aws-cdk-go/awscdkneptunealpha"

Starting a Neptune Database

To set up a Neptune database, define a DatabaseCluster. You must always launch a database in a VPC.

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
})

By default only writer instance is provisioned with this construct.

Connecting

To control who can access the cluster, use the .connections attribute. Neptune databases have a default port, so you don't need to specify the port:

cluster.Connections.AllowDefaultPortFromAnyIpv4(jsii.String("Open to the world"))

The endpoints to access your database cluster will be available as the .clusterEndpoint and .clusterReadEndpoint attributes:

writeAddress := cluster.ClusterEndpoint.SocketAddress

IAM Authentication

You can also authenticate to a database cluster using AWS Identity and Access Management (IAM) database authentication; See https://docs.aws.amazon.com/neptune/latest/userguide/iam-auth.html for more information and a list of supported versions and limitations.

The following example shows enabling IAM authentication for a database cluster and granting connection access to an IAM role.

cluster := neptune.NewDatabaseCluster(this, jsii.String("Cluster"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	IamAuthentication: jsii.Boolean(true),
})
role := iam.NewRole(this, jsii.String("DBRole"), &RoleProps{
	AssumedBy: iam.NewAccountPrincipal(this.Account),
})
// Use one of the following statements to grant the role the necessary permissions
cluster.GrantConnect(role) // Grant the role neptune-db:* access to the DB
cluster.Grant(role, jsii.String("neptune-db:ReadDataViaQuery"), jsii.String("neptune-db:WriteDataViaQuery"))

Customizing parameters

Neptune allows configuring database behavior by supplying custom parameter groups. For more details, refer to the following link: https://docs.aws.amazon.com/neptune/latest/userguide/parameters.html

clusterParams := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

dbParams := neptune.NewParameterGroup(this, jsii.String("DbParams"), &ParameterGroupProps{
	Description: jsii.String("Db parameter group"),
	Parameters: map[string]*string{
		"neptune_query_timeout": jsii.String("120000"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	ClusterParameterGroup: clusterParams,
	ParameterGroup: dbParams,
})

Note: To use the Neptune engine versions 1.2.0.0 or later, including the newly added 1.3 series, it's necessary to specify the appropriate engineVersion prop in neptune.DatabaseCluster. Additionally, for both 1.2 and 1.3 series, the corresponding family prop must be set to ParameterGroupFamily.NEPTUNE_1_2 or ParameterGroupFamily.NEPTUNE_1_3 respectively in neptune.ClusterParameterGroup and neptune.ParameterGroup.

Adding replicas

DatabaseCluster allows launching replicas along with the writer instance. This can be specified using the instanceCount attribute.

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	Instances: jsii.Number(2),
})

Additionally, it is also possible to add replicas using DatabaseInstance for an existing cluster.

replica1 := neptune.NewDatabaseInstance(this, jsii.String("Instance"), &DatabaseInstanceProps{
	Cluster: Cluster,
	InstanceType: neptune.InstanceType_R5_LARGE(),
})

Automatic minor version upgrades

By setting autoMinorVersionUpgrade to true, Neptune will automatically update the engine of the entire cluster to the latest minor version after a stabilization window of 2 to 3 weeks.

neptune.NewDatabaseCluster(this, jsii.String("Cluster"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	AutoMinorVersionUpgrade: jsii.Boolean(true),
})

Logging

Neptune supports various methods for monitoring performance and usage. One of those methods is logging

  1. Neptune provides logs e.g. audit logs which can be viewed or downloaded via the AWS Console. Audit logs can be enabled using the neptune_enable_audit_log parameter in ClusterParameterGroup or ParameterGroup
  2. Neptune provides the ability to export those logs to CloudWatch Logs
// Cluster parameter group with the neptune_enable_audit_log param set to 1
clusterParameterGroup := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	// Audit logs are enabled via the clusterParameterGroup
	ClusterParameterGroup: ClusterParameterGroup,
	// Optionally configuring audit logs to be exported to CloudWatch Logs
	CloudwatchLogsExports: []logType{
		neptune.*logType_AUDIT(),
	},
	// Optionally set a retention period on exported CloudWatch Logs
	CloudwatchLogsRetention: logs.RetentionDays_ONE_MONTH,
})

For more information on monitoring, refer to https://docs.aws.amazon.com/neptune/latest/userguide/monitoring.html. For more information on audit logs, refer to https://docs.aws.amazon.com/neptune/latest/userguide/auditing.html. For more information on exporting logs to CloudWatch Logs, refer to https://docs.aws.amazon.com/neptune/latest/userguide/cloudwatch-logs.html.

Metrics

Both DatabaseCluster and DatabaseInstance provide a metric() method to help with cluster-level and instance-level monitoring.

var cluster databaseCluster
var instance databaseInstance


cluster.Metric(jsii.String("SparqlRequestsPerSec")) // cluster-level SparqlErrors metric
instance.Metric(jsii.String("SparqlRequestsPerSec"))

For more details on the available metrics, refer to https://docs.aws.amazon.com/neptune/latest/userguide/cw-metrics.html

Copy tags to snapshot

By setting copyTagsToSnapshot to true, all tags of the cluster are copied to the snapshots when they are created.

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	CopyTagsToSnapshot: jsii.Boolean(true),
})

Neptune Serverless

You can configure a Neptune Serverless cluster using the dedicated instance type along with the serverlessScalingConfiguration property.

Visit Using Amazon Neptune Serverless for more details.

cluster := neptune.NewDatabaseCluster(this, jsii.String("ServerlessDatabase"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_SERVERLESS(),
	ServerlessScalingConfiguration: &ServerlessScalingConfiguration{
		MinCapacity: jsii.Number(1),
		MaxCapacity: jsii.Number(5),
	},
})

Documentation

Overview

The CDK Construct Library for AWS::Neptune

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ClusterParameterGroup_IsConstruct 

func ClusterParameterGroup_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ClusterParameterGroup_IsOwnedResource 

func ClusterParameterGroup_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ClusterParameterGroup_IsResource 

func ClusterParameterGroup_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func DatabaseClusterBase_IsConstruct 

func DatabaseClusterBase_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func DatabaseClusterBase_IsOwnedResource 

func DatabaseClusterBase_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func DatabaseClusterBase_IsResource 

func DatabaseClusterBase_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func DatabaseCluster_DEFAULT_NUM_INSTANCES 

func DatabaseCluster_DEFAULT_NUM_INSTANCES() *float64

func DatabaseCluster_IsConstruct 

func DatabaseCluster_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func DatabaseCluster_IsOwnedResource 

func DatabaseCluster_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func DatabaseCluster_IsResource 

func DatabaseCluster_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func DatabaseInstanceBase_IsConstruct 

func DatabaseInstanceBase_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func DatabaseInstanceBase_IsOwnedResource 

func DatabaseInstanceBase_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func DatabaseInstanceBase_IsResource 

func DatabaseInstanceBase_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func DatabaseInstance_IsConstruct 

func DatabaseInstance_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func DatabaseInstance_IsOwnedResource 

func DatabaseInstance_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func DatabaseInstance_IsResource 

func DatabaseInstance_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func NewClusterParameterGroup_Override 

func NewClusterParameterGroup_Override(c ClusterParameterGroup, scope constructs.Construct, id *string, props *ClusterParameterGroupProps)

Experimental.

func NewDatabaseClusterBase_Override 

func NewDatabaseClusterBase_Override(d DatabaseClusterBase, scope constructs.Construct, id *string, props *awscdk.ResourceProps)

Experimental.

func NewDatabaseCluster_Override 

func NewDatabaseCluster_Override(d DatabaseCluster, scope constructs.Construct, id *string, props *DatabaseClusterProps)

Experimental.

func NewDatabaseInstanceBase_Override 

func NewDatabaseInstanceBase_Override(d DatabaseInstanceBase, scope constructs.Construct, id *string, props *awscdk.ResourceProps)

Experimental.

func NewDatabaseInstance_Override 

func NewDatabaseInstance_Override(d DatabaseInstance, scope constructs.Construct, id *string, props *DatabaseInstanceProps)

Experimental.

func NewEndpoint_Override 

func NewEndpoint_Override(e Endpoint, address *string, port *float64)

Experimental.

func NewEngineVersion_Override 

func NewEngineVersion_Override(e EngineVersion, version *string)

Constructor for specifying a custom engine version. Experimental.

func NewLogType_Override 

func NewLogType_Override(l LogType, value *string)

Constructor for specifying a custom log type. Experimental.

func NewParameterGroupFamily_Override 

func NewParameterGroupFamily_Override(p ParameterGroupFamily, family *string)

Constructor for specifying a custom parameter group famil. Experimental.

func NewParameterGroup_Override 

func NewParameterGroup_Override(p ParameterGroup, scope constructs.Construct, id *string, props *ParameterGroupProps)

Experimental.

func NewSubnetGroup_Override 

func NewSubnetGroup_Override(s SubnetGroup, scope constructs.Construct, id *string, props *SubnetGroupProps)

Experimental.

func ParameterGroup_IsConstruct 

func ParameterGroup_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func ParameterGroup_IsOwnedResource 

func ParameterGroup_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func ParameterGroup_IsResource 

func ParameterGroup_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func SubnetGroup_IsConstruct 

func SubnetGroup_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`. Experimental.

func SubnetGroup_IsOwnedResource 

func SubnetGroup_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise. Experimental.

func SubnetGroup_IsResource 

func SubnetGroup_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

Types

type ClusterParameterGroup 

type ClusterParameterGroup interface {
	awscdk.Resource
	IClusterParameterGroup
	// The name of the parameter group.
	// Experimental.
	ClusterParameterGroupName() *string
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A cluster parameter group.

Example: 

clusterParams := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

dbParams := neptune.NewParameterGroup(this, jsii.String("DbParams"), &ParameterGroupProps{
	Description: jsii.String("Db parameter group"),
	Parameters: map[string]*string{
		"neptune_query_timeout": jsii.String("120000"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	ClusterParameterGroup: clusterParams,
	ParameterGroup: dbParams,
})

Experimental.

func NewClusterParameterGroup 

func NewClusterParameterGroup(scope constructs.Construct, id *string, props *ClusterParameterGroupProps) ClusterParameterGroup

Experimental.

type ClusterParameterGroupProps 

type ClusterParameterGroupProps struct {
	// The parameters in this parameter group.
	// Experimental.
	Parameters *map[string]*string `field:"required" json:"parameters" yaml:"parameters"`
	// The name of the parameter group.
	// Default: A CDK generated name for the parameter group.
	//
	// Experimental.
	ClusterParameterGroupName *string `field:"optional" json:"clusterParameterGroupName" yaml:"clusterParameterGroupName"`
	// Description for this parameter group.
	// Default: a CDK generated description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Parameter group family.
	// Default: - NEPTUNE_1.
	//
	// Experimental.
	Family ParameterGroupFamily `field:"optional" json:"family" yaml:"family"`
}

Marker class for cluster parameter group.

Example: 

clusterParams := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

dbParams := neptune.NewParameterGroup(this, jsii.String("DbParams"), &ParameterGroupProps{
	Description: jsii.String("Db parameter group"),
	Parameters: map[string]*string{
		"neptune_query_timeout": jsii.String("120000"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	ClusterParameterGroup: clusterParams,
	ParameterGroup: dbParams,
})

Experimental.

type DatabaseCluster 

type DatabaseCluster interface {
	DatabaseClusterBase
	IDatabaseCluster
	// The endpoint to use for read/write operations.
	// Experimental.
	ClusterEndpoint() Endpoint
	// Identifier of the cluster.
	// Experimental.
	ClusterIdentifier() *string
	// Endpoint to use for load-balanced read-only operations.
	// Experimental.
	ClusterReadEndpoint() Endpoint
	// The resource id for the cluster;
	//
	// for example: cluster-ABCD1234EFGH5678IJKL90MNOP. The cluster ID uniquely
	// identifies the cluster and is used in things like IAM authentication policies.
	// Experimental.
	ClusterResourceIdentifier() *string
	// The connections object to implement IConnectable.
	// Experimental.
	Connections() awsec2.Connections
	// Experimental.
	EnableIamAuthentication() *bool
	// Experimental.
	SetEnableIamAuthentication(val *bool)
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// Endpoints which address each individual instance.
	// Experimental.
	InstanceEndpoints() *[]Endpoint
	// Identifiers of the instance.
	// Experimental.
	InstanceIdentifiers() *[]*string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Subnet group used by the DB.
	// Experimental.
	SubnetGroup() ISubnetGroup
	// The VPC where the DB subnet group is created.
	// Experimental.
	Vpc() awsec2.IVpc
	// The subnets used by the DB subnet group.
	// Experimental.
	VpcSubnets() *awsec2.SubnetSelection
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity the specified actions.
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions ...*string) awsiam.Grant
	// Grant the given identity connection access to the database.
	// Experimental.
	GrantConnect(grantee awsiam.IGrantable) awsiam.Grant
	// Return the given named metric associated with this DatabaseCluster instance.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Create a clustered database with a given number of instances.

Example: 

cluster := neptune.NewDatabaseCluster(this, jsii.String("ServerlessDatabase"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_SERVERLESS(),
	ServerlessScalingConfiguration: &ServerlessScalingConfiguration{
		MinCapacity: jsii.Number(1),
		MaxCapacity: jsii.Number(5),
	},
})

Experimental.

func NewDatabaseCluster 

func NewDatabaseCluster(scope constructs.Construct, id *string, props *DatabaseClusterProps) DatabaseCluster

Experimental.

type DatabaseClusterAttributes 

type DatabaseClusterAttributes struct {
	// Cluster endpoint address.
	// Experimental.
	ClusterEndpointAddress *string `field:"required" json:"clusterEndpointAddress" yaml:"clusterEndpointAddress"`
	// Identifier for the cluster.
	// Experimental.
	ClusterIdentifier *string `field:"required" json:"clusterIdentifier" yaml:"clusterIdentifier"`
	// Resource Identifier for the cluster.
	// Experimental.
	ClusterResourceIdentifier *string `field:"required" json:"clusterResourceIdentifier" yaml:"clusterResourceIdentifier"`
	// The database port.
	// Experimental.
	Port *float64 `field:"required" json:"port" yaml:"port"`
	// Reader endpoint address.
	// Experimental.
	ReaderEndpointAddress *string `field:"required" json:"readerEndpointAddress" yaml:"readerEndpointAddress"`
	// The security group of the database cluster.
	// Experimental.
	SecurityGroup awsec2.ISecurityGroup `field:"required" json:"securityGroup" yaml:"securityGroup"`
}

Properties that describe an existing cluster instance.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var securityGroup securityGroup

databaseClusterAttributes := &DatabaseClusterAttributes{
	ClusterEndpointAddress: jsii.String("clusterEndpointAddress"),
	ClusterIdentifier: jsii.String("clusterIdentifier"),
	ClusterResourceIdentifier: jsii.String("clusterResourceIdentifier"),
	Port: jsii.Number(123),
	ReaderEndpointAddress: jsii.String("readerEndpointAddress"),
	SecurityGroup: securityGroup,
}

Experimental.

type DatabaseClusterBase 

type DatabaseClusterBase interface {
	awscdk.Resource
	IDatabaseCluster
	// The endpoint to use for read/write operations.
	// Experimental.
	ClusterEndpoint() Endpoint
	// Identifier of the cluster.
	// Experimental.
	ClusterIdentifier() *string
	// Endpoint to use for load-balanced read-only operations.
	// Experimental.
	ClusterReadEndpoint() Endpoint
	// Resource identifier of the cluster.
	// Experimental.
	ClusterResourceIdentifier() *string
	// The connections object to implement IConnectable.
	// Experimental.
	Connections() awsec2.Connections
	// Experimental.
	EnableIamAuthentication() *bool
	// Experimental.
	SetEnableIamAuthentication(val *bool)
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grant the given identity the specified actions.
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions ...*string) awsiam.Grant
	// Grant the given identity connection access to the database.
	// Experimental.
	GrantConnect(grantee awsiam.IGrantable) awsiam.Grant
	// Return the given named metric associated with this DatabaseCluster instance.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A new or imported database cluster.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"
import "github.com/aws/aws-cdk-go/awscdk"

var securityGroup securityGroup

databaseClusterBase := neptune_alpha.DatabaseClusterBase_FromDatabaseClusterAttributes(this, jsii.String("MyDatabaseClusterBase"), &DatabaseClusterAttributes{
	ClusterEndpointAddress: jsii.String("clusterEndpointAddress"),
	ClusterIdentifier: jsii.String("clusterIdentifier"),
	ClusterResourceIdentifier: jsii.String("clusterResourceIdentifier"),
	Port: jsii.Number(123),
	ReaderEndpointAddress: jsii.String("readerEndpointAddress"),
	SecurityGroup: securityGroup,
})

Experimental.

type DatabaseClusterProps 

type DatabaseClusterProps struct {
	// What type of instance to start for the replicas.
	// Experimental.
	InstanceType InstanceType `field:"required" json:"instanceType" yaml:"instanceType"`
	// What subnets to run the Neptune instances in.
	//
	// Must be at least 2 subnets in two different AZs.
	// Experimental.
	Vpc awsec2.IVpc `field:"required" json:"vpc" yaml:"vpc"`
	// A list of AWS Identity and Access Management (IAM) role that can be used by the cluster to access other AWS services.
	// Default: - No role is attached to the cluster.
	//
	// Experimental.
	AssociatedRoles *[]awsiam.IRole `field:"optional" json:"associatedRoles" yaml:"associatedRoles"`
	// If set to true, Neptune will automatically update the engine of the entire cluster to the latest minor version after a stabilization window of 2 to 3 weeks.
	// Default: - false.
	//
	// Experimental.
	AutoMinorVersionUpgrade *bool `field:"optional" json:"autoMinorVersionUpgrade" yaml:"autoMinorVersionUpgrade"`
	// How many days to retain the backup.
	// Default: - cdk.Duration.days(1)
	//
	// Experimental.
	BackupRetention awscdk.Duration `field:"optional" json:"backupRetention" yaml:"backupRetention"`
	// The list of log types that need to be enabled for exporting to CloudWatch Logs.
	// See: https://docs.aws.amazon.com/neptune/latest/userguide/auditing.html#auditing-enable
	//
	// Default: - no log exports.
	//
	// Experimental.
	CloudwatchLogsExports *[]LogType `field:"optional" json:"cloudwatchLogsExports" yaml:"cloudwatchLogsExports"`
	// The number of days log events are kept in CloudWatch Logs.
	//
	// When updating
	// this property, unsetting it doesn't remove the log retention policy. To
	// remove the retention policy, set the value to `Infinity`.
	// Default: - logs never expire.
	//
	// Experimental.
	CloudwatchLogsRetention awslogs.RetentionDays `field:"optional" json:"cloudwatchLogsRetention" yaml:"cloudwatchLogsRetention"`
	// The IAM role for the Lambda function associated with the custom resource that sets the retention policy.
	// Default: - a new role is created.
	//
	// Experimental.
	CloudwatchLogsRetentionRole awsiam.IRole `field:"optional" json:"cloudwatchLogsRetentionRole" yaml:"cloudwatchLogsRetentionRole"`
	// Additional parameters to pass to the database engine.
	// Default: - No parameter group.
	//
	// Experimental.
	ClusterParameterGroup IClusterParameterGroup `field:"optional" json:"clusterParameterGroup" yaml:"clusterParameterGroup"`
	// Whether to copy tags to the snapshot when a snapshot is created.
	// Default: - false.
	//
	// Experimental.
	CopyTagsToSnapshot *bool `field:"optional" json:"copyTagsToSnapshot" yaml:"copyTagsToSnapshot"`
	// An optional identifier for the cluster.
	// Default: - A name is automatically generated.
	//
	// Experimental.
	DbClusterName *string `field:"optional" json:"dbClusterName" yaml:"dbClusterName"`
	// Indicates whether the DB cluster should have deletion protection enabled.
	// Default: - true if “removalPolicy“ is RETAIN, false otherwise.
	//
	// Experimental.
	DeletionProtection *bool `field:"optional" json:"deletionProtection" yaml:"deletionProtection"`
	// What version of the database to start.
	// Default: - The default engine version.
	//
	// Experimental.
	EngineVersion EngineVersion `field:"optional" json:"engineVersion" yaml:"engineVersion"`
	// Map AWS Identity and Access Management (IAM) accounts to database accounts.
	// Default: - `false`.
	//
	// Experimental.
	IamAuthentication *bool `field:"optional" json:"iamAuthentication" yaml:"iamAuthentication"`
	// Base identifier for instances.
	//
	// Every replica is named by appending the replica number to this string, 1-based.
	// Default: - `dbClusterName` is used with the word "Instance" appended. If `dbClusterName` is not provided, the
	// identifier is automatically generated.
	//
	// Experimental.
	InstanceIdentifierBase *string `field:"optional" json:"instanceIdentifierBase" yaml:"instanceIdentifierBase"`
	// Number of Neptune compute instances.
	// Default: 1.
	//
	// Experimental.
	Instances *float64 `field:"optional" json:"instances" yaml:"instances"`
	// The KMS key for storage encryption.
	// Default: - default master key.
	//
	// Experimental.
	KmsKey awskms.IKey `field:"optional" json:"kmsKey" yaml:"kmsKey"`
	// The DB parameter group to associate with the instance.
	// Default: no parameter group.
	//
	// Experimental.
	ParameterGroup IParameterGroup `field:"optional" json:"parameterGroup" yaml:"parameterGroup"`
	// A daily time range in 24-hours UTC format in which backups preferably execute.
	//
	// Must be at least 30 minutes long.
	//
	// Example: '01:00-02:00'.
	// Default: - a 30-minute window selected at random from an 8-hour block of
	// time for each AWS Region. To see the time blocks available, see
	//
	// Experimental.
	PreferredBackupWindow *string `field:"optional" json:"preferredBackupWindow" yaml:"preferredBackupWindow"`
	// A weekly time range in which maintenance should preferably execute.
	//
	// Must be at least 30 minutes long.
	//
	// Example: 'tue:04:17-tue:04:47'.
	// Default: - 30-minute window selected at random from an 8-hour block of time for
	// each AWS Region, occurring on a random day of the week.
	//
	// Experimental.
	PreferredMaintenanceWindow *string `field:"optional" json:"preferredMaintenanceWindow" yaml:"preferredMaintenanceWindow"`
	// The removal policy to apply when the cluster and its instances are removed or replaced during a stack update, or when the stack is deleted.
	//
	// This
	// removal policy also applies to the implicit security group created for the
	// cluster if one is not supplied as a parameter.
	// Default: - Retain cluster.
	//
	// Experimental.
	RemovalPolicy awscdk.RemovalPolicy `field:"optional" json:"removalPolicy" yaml:"removalPolicy"`
	// Security group.
	// Default: a new security group is created.
	//
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// Specify minimum and maximum NCUs capacity for a serverless cluster.
	//
	// See https://docs.aws.amazon.com/neptune/latest/userguide/neptune-serverless-capacity-scaling.html
	// Default: - required if instanceType is db.serverless
	//
	// Experimental.
	ServerlessScalingConfiguration *ServerlessScalingConfiguration `field:"optional" json:"serverlessScalingConfiguration" yaml:"serverlessScalingConfiguration"`
	// Whether to enable storage encryption.
	// Default: true.
	//
	// Experimental.
	StorageEncrypted *bool `field:"optional" json:"storageEncrypted" yaml:"storageEncrypted"`
	// Existing subnet group for the cluster.
	// Default: - a new subnet group will be created.
	//
	// Experimental.
	SubnetGroup ISubnetGroup `field:"optional" json:"subnetGroup" yaml:"subnetGroup"`
	// Where to place the instances within the VPC.
	// Default: private subnets.
	//
	// Experimental.
	VpcSubnets *awsec2.SubnetSelection `field:"optional" json:"vpcSubnets" yaml:"vpcSubnets"`
}

Properties for a new database cluster.

Example: 

cluster := neptune.NewDatabaseCluster(this, jsii.String("ServerlessDatabase"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_SERVERLESS(),
	ServerlessScalingConfiguration: &ServerlessScalingConfiguration{
		MinCapacity: jsii.Number(1),
		MaxCapacity: jsii.Number(5),
	},
})

Experimental.

type DatabaseInstance 

type DatabaseInstance interface {
	DatabaseInstanceBase
	IDatabaseInstance
	// The instance's database cluster.
	// Experimental.
	Cluster() IDatabaseCluster
	// The instance endpoint address.
	// Experimental.
	DbInstanceEndpointAddress() *string
	// The instance endpoint port.
	// Experimental.
	DbInstanceEndpointPort() *string
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The instance endpoint.
	// Experimental.
	InstanceEndpoint() Endpoint
	// The instance identifier.
	// Experimental.
	InstanceIdentifier() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Return the given named metric associated with this database instance.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A database instance.

Example: 

replica1 := neptune.NewDatabaseInstance(this, jsii.String("Instance"), &DatabaseInstanceProps{
	Cluster: Cluster,
	InstanceType: neptune.InstanceType_R5_LARGE(),
})

Experimental.

func NewDatabaseInstance 

func NewDatabaseInstance(scope constructs.Construct, id *string, props *DatabaseInstanceProps) DatabaseInstance

Experimental.

type DatabaseInstanceAttributes 

type DatabaseInstanceAttributes struct {
	// The endpoint address.
	// Experimental.
	InstanceEndpointAddress *string `field:"required" json:"instanceEndpointAddress" yaml:"instanceEndpointAddress"`
	// The instance identifier.
	// Experimental.
	InstanceIdentifier *string `field:"required" json:"instanceIdentifier" yaml:"instanceIdentifier"`
	// The database port.
	// Experimental.
	Port *float64 `field:"required" json:"port" yaml:"port"`
}

Properties that describe an existing instance.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"

databaseInstanceAttributes := &DatabaseInstanceAttributes{
	InstanceEndpointAddress: jsii.String("instanceEndpointAddress"),
	InstanceIdentifier: jsii.String("instanceIdentifier"),
	Port: jsii.Number(123),
}

Experimental.

type DatabaseInstanceBase 

type DatabaseInstanceBase interface {
	awscdk.Resource
	IDatabaseInstance
	// The instance endpoint address.
	// Experimental.
	DbInstanceEndpointAddress() *string
	// The instance endpoint port.
	// Experimental.
	DbInstanceEndpointPort() *string
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The instance endpoint.
	// Experimental.
	InstanceEndpoint() Endpoint
	// The instance identifier.
	// Experimental.
	InstanceIdentifier() *string
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Return the given named metric associated with this database instance.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

A new or imported database instance.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"

databaseInstanceBase := neptune_alpha.DatabaseInstanceBase_FromDatabaseInstanceAttributes(this, jsii.String("MyDatabaseInstanceBase"), &DatabaseInstanceAttributes{
	InstanceEndpointAddress: jsii.String("instanceEndpointAddress"),
	InstanceIdentifier: jsii.String("instanceIdentifier"),
	Port: jsii.Number(123),
})

Experimental.

type DatabaseInstanceProps 

type DatabaseInstanceProps struct {
	// The Neptune database cluster the instance should launch into.
	// Experimental.
	Cluster IDatabaseCluster `field:"required" json:"cluster" yaml:"cluster"`
	// What type of instance to start for the replicas.
	// Experimental.
	InstanceType InstanceType `field:"required" json:"instanceType" yaml:"instanceType"`
	// The name of the Availability Zone where the DB instance will be located.
	// Default: - no preference.
	//
	// Experimental.
	AvailabilityZone *string `field:"optional" json:"availabilityZone" yaml:"availabilityZone"`
	// A name for the DB instance.
	//
	// If you specify a name, AWS CloudFormation
	// converts it to lowercase.
	// Default: - a CloudFormation generated name.
	//
	// Experimental.
	DbInstanceName *string `field:"optional" json:"dbInstanceName" yaml:"dbInstanceName"`
	// The DB parameter group to associate with the instance.
	// Default: no parameter group.
	//
	// Experimental.
	ParameterGroup IParameterGroup `field:"optional" json:"parameterGroup" yaml:"parameterGroup"`
	// The CloudFormation policy to apply when the instance is removed from the stack or replaced during an update.
	// Default: RemovalPolicy.Retain
	//
	// Experimental.
	RemovalPolicy awscdk.RemovalPolicy `field:"optional" json:"removalPolicy" yaml:"removalPolicy"`
}

Construction properties for a DatabaseInstanceNew.

Example: 

replica1 := neptune.NewDatabaseInstance(this, jsii.String("Instance"), &DatabaseInstanceProps{
	Cluster: Cluster,
	InstanceType: neptune.InstanceType_R5_LARGE(),
})

Experimental.

type Endpoint 

type Endpoint interface {
	// The hostname of the endpoint.
	// Experimental.
	Hostname() *string
	// The port of the endpoint.
	// Experimental.
	Port() *float64
	// The combination of "HOSTNAME:PORT" for this endpoint.
	// Experimental.
	SocketAddress() *string
}

Connection endpoint of a neptune cluster or instance.

Consists of a combination of hostname and port.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"

endpoint := neptune_alpha.NewEndpoint(jsii.String("address"), jsii.Number(123))

Experimental.

func NewEndpoint 

func NewEndpoint(address *string, port *float64) Endpoint

Experimental.

type EngineVersion 

type EngineVersion interface {
	// the engine version of Neptune.
	// Experimental.
	Version() *string
}

Possible Instances Types to use in Neptune cluster used for defining `DatabaseClusterProps.engineVersion`.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"

engineVersion := neptune_alpha.EngineVersion_V1_0_1_0()

Experimental.

func EngineVersion_V1_0_1_0 

func EngineVersion_V1_0_1_0() EngineVersion

func EngineVersion_V1_0_1_1 

func EngineVersion_V1_0_1_1() EngineVersion

func EngineVersion_V1_0_1_2 

func EngineVersion_V1_0_1_2() EngineVersion

func EngineVersion_V1_0_2_1 

func EngineVersion_V1_0_2_1() EngineVersion

func EngineVersion_V1_0_2_2 

func EngineVersion_V1_0_2_2() EngineVersion

func EngineVersion_V1_0_3_0 

func EngineVersion_V1_0_3_0() EngineVersion

func EngineVersion_V1_0_4_0 

func EngineVersion_V1_0_4_0() EngineVersion

func EngineVersion_V1_0_4_1 

func EngineVersion_V1_0_4_1() EngineVersion

func EngineVersion_V1_0_5_0 

func EngineVersion_V1_0_5_0() EngineVersion

func EngineVersion_V1_1_0_0 

func EngineVersion_V1_1_0_0() EngineVersion

func EngineVersion_V1_1_1_0 

func EngineVersion_V1_1_1_0() EngineVersion

func EngineVersion_V1_2_0_0 

func EngineVersion_V1_2_0_0() EngineVersion

func EngineVersion_V1_2_0_1 

func EngineVersion_V1_2_0_1() EngineVersion

func EngineVersion_V1_2_0_2 

func EngineVersion_V1_2_0_2() EngineVersion

func EngineVersion_V1_2_1_0 

func EngineVersion_V1_2_1_0() EngineVersion

func EngineVersion_V1_3_0_0 

func EngineVersion_V1_3_0_0() EngineVersion

func EngineVersion_V1_3_1_0 

func EngineVersion_V1_3_1_0() EngineVersion

func NewEngineVersion 

func NewEngineVersion(version *string) EngineVersion

Constructor for specifying a custom engine version. Experimental.

type IClusterParameterGroup 

type IClusterParameterGroup interface {
	awscdk.IResource
	// The name of this parameter group.
	// Experimental.
	ClusterParameterGroupName() *string
}

A parameter group. Experimental.

func ClusterParameterGroup_FromClusterParameterGroupName 

func ClusterParameterGroup_FromClusterParameterGroupName(scope constructs.Construct, id *string, clusterParameterGroupName *string) IClusterParameterGroup

Imports a parameter group. Experimental.

type IDatabaseCluster 

type IDatabaseCluster interface {
	awsec2.IConnectable
	awscdk.IResource
	// Grant the given identity the specified actions.
	// See: https://docs.aws.amazon.com/neptune/latest/userguide/iam-dp-actions.html
	//
	// Experimental.
	Grant(grantee awsiam.IGrantable, actions ...*string) awsiam.Grant
	// Grant the given identity connection access to the database.
	// Experimental.
	GrantConnect(grantee awsiam.IGrantable) awsiam.Grant
	// Return the given named metric associated with this DatabaseCluster instance.
	// See: https://docs.aws.amazon.com/neptune/latest/userguide/cw-dimensions.html
	//
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// The endpoint to use for read/write operations.
	// Experimental.
	ClusterEndpoint() Endpoint
	// Identifier of the cluster.
	// Experimental.
	ClusterIdentifier() *string
	// Endpoint to use for load-balanced read-only operations.
	// Experimental.
	ClusterReadEndpoint() Endpoint
	// Resource identifier of the cluster.
	// Experimental.
	ClusterResourceIdentifier() *string
}

Create a clustered database with a given number of instances. Experimental.

func DatabaseClusterBase_FromDatabaseClusterAttributes 

func DatabaseClusterBase_FromDatabaseClusterAttributes(scope constructs.Construct, id *string, attrs *DatabaseClusterAttributes) IDatabaseCluster

Import an existing DatabaseCluster from properties. Experimental.

func DatabaseCluster_FromDatabaseClusterAttributes 

func DatabaseCluster_FromDatabaseClusterAttributes(scope constructs.Construct, id *string, attrs *DatabaseClusterAttributes) IDatabaseCluster

Import an existing DatabaseCluster from properties. Experimental.

type IDatabaseInstance 

type IDatabaseInstance interface {
	awscdk.IResource
	// Return the given named metric associated with this database instance.
	// See: https://docs.aws.amazon.com/neptune/latest/userguide/cw-dimensions.html
	//
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// The instance endpoint address.
	// Experimental.
	DbInstanceEndpointAddress() *string
	// The instance endpoint port.
	// Experimental.
	DbInstanceEndpointPort() *string
	// The instance endpoint.
	// Experimental.
	InstanceEndpoint() Endpoint
	// The instance identifier.
	// Experimental.
	InstanceIdentifier() *string
}

A database instance. Experimental.

func DatabaseInstanceBase_FromDatabaseInstanceAttributes 

func DatabaseInstanceBase_FromDatabaseInstanceAttributes(scope constructs.Construct, id *string, attrs *DatabaseInstanceAttributes) IDatabaseInstance

Import an existing database instance. Experimental.

func DatabaseInstance_FromDatabaseInstanceAttributes 

func DatabaseInstance_FromDatabaseInstanceAttributes(scope constructs.Construct, id *string, attrs *DatabaseInstanceAttributes) IDatabaseInstance

Import an existing database instance. Experimental.

type IParameterGroup 

type IParameterGroup interface {
	awscdk.IResource
	// The name of this parameter group.
	// Experimental.
	ParameterGroupName() *string
}

A parameter group. Experimental.

func ParameterGroup_FromParameterGroupName 

func ParameterGroup_FromParameterGroupName(scope constructs.Construct, id *string, parameterGroupName *string) IParameterGroup

Imports a parameter group. Experimental.

type ISubnetGroup 

type ISubnetGroup interface {
	awscdk.IResource
	// The name of the subnet group.
	// Experimental.
	SubnetGroupName() *string
}

Interface for a subnet group. Experimental.

func SubnetGroup_FromSubnetGroupName 

func SubnetGroup_FromSubnetGroupName(scope constructs.Construct, id *string, subnetGroupName *string) ISubnetGroup

Imports an existing subnet group by name. Experimental.

type InstanceType 

type InstanceType interface {
}

Possible Instances Types to use in Neptune cluster used for defining `DatabaseInstanceProps.instanceType`.

Example: 

cluster := neptune.NewDatabaseCluster(this, jsii.String("ServerlessDatabase"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_SERVERLESS(),
	ServerlessScalingConfiguration: &ServerlessScalingConfiguration{
		MinCapacity: jsii.Number(1),
		MaxCapacity: jsii.Number(5),
	},
})

Experimental.

func InstanceType_Of 

func InstanceType_Of(instanceType *string) InstanceType

Build an InstanceType from given string or token, such as CfnParameter. Experimental.

func InstanceType_R4_2XLARGE 

func InstanceType_R4_2XLARGE() InstanceType

func InstanceType_R4_4XLARGE 

func InstanceType_R4_4XLARGE() InstanceType

func InstanceType_R4_8XLARGE 

func InstanceType_R4_8XLARGE() InstanceType

func InstanceType_R4_LARGE 

func InstanceType_R4_LARGE() InstanceType

func InstanceType_R4_XLARGE 

func InstanceType_R4_XLARGE() InstanceType

func InstanceType_R5_12XLARGE 

func InstanceType_R5_12XLARGE() InstanceType

func InstanceType_R5_24XLARGE 

func InstanceType_R5_24XLARGE() InstanceType

func InstanceType_R5_2XLARGE 

func InstanceType_R5_2XLARGE() InstanceType

func InstanceType_R5_4XLARGE 

func InstanceType_R5_4XLARGE() InstanceType

func InstanceType_R5_8XLARGE 

func InstanceType_R5_8XLARGE() InstanceType

func InstanceType_R5_LARGE 

func InstanceType_R5_LARGE() InstanceType

func InstanceType_R5_XLARGE 

func InstanceType_R5_XLARGE() InstanceType

func InstanceType_R6G_12XLARGE 

func InstanceType_R6G_12XLARGE() InstanceType

func InstanceType_R6G_16XLARGE 

func InstanceType_R6G_16XLARGE() InstanceType

func InstanceType_R6G_2XLARGE 

func InstanceType_R6G_2XLARGE() InstanceType

func InstanceType_R6G_4XLARGE 

func InstanceType_R6G_4XLARGE() InstanceType

func InstanceType_R6G_8XLARGE 

func InstanceType_R6G_8XLARGE() InstanceType

func InstanceType_R6G_LARGE 

func InstanceType_R6G_LARGE() InstanceType

func InstanceType_R6G_XLARGE 

func InstanceType_R6G_XLARGE() InstanceType

func InstanceType_SERVERLESS 

func InstanceType_SERVERLESS() InstanceType

func InstanceType_T3_MEDIUM 

func InstanceType_T3_MEDIUM() InstanceType

func InstanceType_T4G_MEDIUM 

func InstanceType_T4G_MEDIUM() InstanceType

type LogType 

type LogType interface {
	// the log type.
	// Experimental.
	Value() *string
}

Neptune log types that can be exported to CloudWatch logs.

Example: 

// Cluster parameter group with the neptune_enable_audit_log param set to 1
clusterParameterGroup := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	// Audit logs are enabled via the clusterParameterGroup
	ClusterParameterGroup: ClusterParameterGroup,
	// Optionally configuring audit logs to be exported to CloudWatch Logs
	CloudwatchLogsExports: []logType{
		neptune.*logType_AUDIT(),
	},
	// Optionally set a retention period on exported CloudWatch Logs
	CloudwatchLogsRetention: logs.RetentionDays_ONE_MONTH,
})

See: https://docs.aws.amazon.com/neptune/latest/userguide/cloudwatch-logs.html

Experimental.

func LogType_AUDIT 

func LogType_AUDIT() LogType

func NewLogType 

func NewLogType(value *string) LogType

Constructor for specifying a custom log type. Experimental.

type ParameterGroup 

type ParameterGroup interface {
	awscdk.Resource
	IParameterGroup
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// The name of the parameter group.
	// Experimental.
	ParameterGroupName() *string
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

DB parameter group.

Example: 

clusterParams := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

dbParams := neptune.NewParameterGroup(this, jsii.String("DbParams"), &ParameterGroupProps{
	Description: jsii.String("Db parameter group"),
	Parameters: map[string]*string{
		"neptune_query_timeout": jsii.String("120000"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	ClusterParameterGroup: clusterParams,
	ParameterGroup: dbParams,
})

Experimental.

func NewParameterGroup 

func NewParameterGroup(scope constructs.Construct, id *string, props *ParameterGroupProps) ParameterGroup

Experimental.

type ParameterGroupFamily 

type ParameterGroupFamily interface {
	// the family of the parameter group Neptune.
	// Experimental.
	Family() *string
}

The DB parameter group family that a DB parameter group is compatible with.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"

parameterGroupFamily := neptune_alpha.ParameterGroupFamily_NEPTUNE_1()

Experimental.

func NewParameterGroupFamily 

func NewParameterGroupFamily(family *string) ParameterGroupFamily

Constructor for specifying a custom parameter group famil. Experimental.

func ParameterGroupFamily_NEPTUNE_1 

func ParameterGroupFamily_NEPTUNE_1() ParameterGroupFamily

func ParameterGroupFamily_NEPTUNE_1_2 

func ParameterGroupFamily_NEPTUNE_1_2() ParameterGroupFamily

func ParameterGroupFamily_NEPTUNE_1_3 

func ParameterGroupFamily_NEPTUNE_1_3() ParameterGroupFamily

type ParameterGroupProps 

type ParameterGroupProps struct {
	// The parameters in this parameter group.
	// Experimental.
	Parameters *map[string]*string `field:"required" json:"parameters" yaml:"parameters"`
	// Description for this parameter group.
	// Default: a CDK generated description.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Parameter group family.
	// Default: - NEPTUNE_1.
	//
	// Experimental.
	Family ParameterGroupFamily `field:"optional" json:"family" yaml:"family"`
	// The name of the parameter group.
	// Default: A CDK generated name for the parameter group.
	//
	// Experimental.
	ParameterGroupName *string `field:"optional" json:"parameterGroupName" yaml:"parameterGroupName"`
}

Marker class for cluster parameter group.

Example: 

clusterParams := neptune.NewClusterParameterGroup(this, jsii.String("ClusterParams"), &ClusterParameterGroupProps{
	Description: jsii.String("Cluster parameter group"),
	Parameters: map[string]*string{
		"neptune_enable_audit_log": jsii.String("1"),
	},
})

dbParams := neptune.NewParameterGroup(this, jsii.String("DbParams"), &ParameterGroupProps{
	Description: jsii.String("Db parameter group"),
	Parameters: map[string]*string{
		"neptune_query_timeout": jsii.String("120000"),
	},
})

cluster := neptune.NewDatabaseCluster(this, jsii.String("Database"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_R5_LARGE(),
	ClusterParameterGroup: clusterParams,
	ParameterGroup: dbParams,
})

Experimental.

type ServerlessScalingConfiguration 

type ServerlessScalingConfiguration struct {
	// Maximum NCU capacity (min value 2.5 - max value 128).
	// Experimental.
	MaxCapacity *float64 `field:"required" json:"maxCapacity" yaml:"maxCapacity"`
	// Minimum NCU capacity (min value 1).
	// Experimental.
	MinCapacity *float64 `field:"required" json:"minCapacity" yaml:"minCapacity"`
}

Example: 

cluster := neptune.NewDatabaseCluster(this, jsii.String("ServerlessDatabase"), &DatabaseClusterProps{
	Vpc: Vpc,
	InstanceType: neptune.InstanceType_SERVERLESS(),
	ServerlessScalingConfiguration: &ServerlessScalingConfiguration{
		MinCapacity: jsii.Number(1),
		MaxCapacity: jsii.Number(5),
	},
})

Experimental.

type SubnetGroup 

type SubnetGroup interface {
	awscdk.Resource
	ISubnetGroup
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	// Experimental.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// The name of the subnet group.
	// Experimental.
	SubnetGroupName() *string
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	// Experimental.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
}

Class for creating a RDS DB subnet group.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var subnet subnet
var subnetFilter subnetFilter
var vpc vpc

subnetGroup := neptune_alpha.NewSubnetGroup(this, jsii.String("MySubnetGroup"), &SubnetGroupProps{
	Vpc: vpc,

	// the properties below are optional
	Description: jsii.String("description"),
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	SubnetGroupName: jsii.String("subnetGroupName"),
	VpcSubnets: &SubnetSelection{
		AvailabilityZones: []*string{
			jsii.String("availabilityZones"),
		},
		OnePerAz: jsii.Boolean(false),
		SubnetFilters: []*subnetFilter{
			subnetFilter,
		},
		SubnetGroupName: jsii.String("subnetGroupName"),
		Subnets: []iSubnet{
			subnet,
		},
		SubnetType: awscdk.Aws_ec2.SubnetType_PRIVATE_ISOLATED,
	},
})

Experimental.

func NewSubnetGroup 

func NewSubnetGroup(scope constructs.Construct, id *string, props *SubnetGroupProps) SubnetGroup

Experimental.

type SubnetGroupProps 

type SubnetGroupProps struct {
	// The VPC to place the subnet group in.
	// Experimental.
	Vpc awsec2.IVpc `field:"required" json:"vpc" yaml:"vpc"`
	// Description of the subnet group.
	// Default: - a name is generated.
	//
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// The removal policy to apply when the subnet group are removed from the stack or replaced during an update.
	// Default: RemovalPolicy.DESTROY
	//
	// Experimental.
	RemovalPolicy awscdk.RemovalPolicy `field:"optional" json:"removalPolicy" yaml:"removalPolicy"`
	// The name of the subnet group.
	// Default: - a name is generated.
	//
	// Experimental.
	SubnetGroupName *string `field:"optional" json:"subnetGroupName" yaml:"subnetGroupName"`
	// Which subnets within the VPC to associate with this group.
	// Default: - private subnets.
	//
	// Experimental.
	VpcSubnets *awsec2.SubnetSelection `field:"optional" json:"vpcSubnets" yaml:"vpcSubnets"`
}

Properties for creating a SubnetGroup.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import neptune_alpha "github.com/aws/aws-cdk-go/awscdkneptunealpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var subnet subnet
var subnetFilter subnetFilter
var vpc vpc

subnetGroupProps := &SubnetGroupProps{
	Vpc: vpc,

	// the properties below are optional
	Description: jsii.String("description"),
	RemovalPolicy: cdk.RemovalPolicy_DESTROY,
	SubnetGroupName: jsii.String("subnetGroupName"),
	VpcSubnets: &SubnetSelection{
		AvailabilityZones: []*string{
			jsii.String("availabilityZones"),
		},
		OnePerAz: jsii.Boolean(false),
		SubnetFilters: []*subnetFilter{
			subnetFilter,
		},
		SubnetGroupName: jsii.String("subnetGroupName"),
		Subnets: []iSubnet{
			subnet,
		},
		SubnetType: awscdk.Aws_ec2.SubnetType_PRIVATE_ISOLATED,
	},
}

Experimental.

Source Files

View all Source files

Directories

Path Synopsis
Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.
 Package jsii contains the functionaility needed for jsii packages to initialize their dependencies and themselves.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.