Cluster class

Provides an Neptune Cluster Resource. A Cluster Resource defines attributes that are applied to the entire cluster of Neptune Cluster Instances.

Changes to a Neptune Cluster can occur when you manually change a parameter, such as backupRetentionPeriod, and are reflected in the next maintenance window. Because of this, this provider may report a difference in its planning phase because a modification has not yet taken place. You can use the applyImmediately flag to instruct the service to apply the change immediately (see documentation below).

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const _default = new aws.neptune.Cluster("default", {
    clusterIdentifier: "neptune-cluster-demo",
    engine: "neptune",
    backupRetentionPeriod: 5,
    preferredBackupWindow: "07:00-09:00",
    skipFinalSnapshot: true,
    iamDatabaseAuthenticationEnabled: true,
    applyImmediately: true,
});
import pulumi
import pulumi_aws as aws

default = aws.neptune.Cluster("default",
    cluster_identifier="neptune-cluster-demo",
    engine="neptune",
    backup_retention_period=5,
    preferred_backup_window="07:00-09:00",
    skip_final_snapshot=True,
    iam_database_authentication_enabled=True,
    apply_immediately=True)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var @default = new Aws.Neptune.Cluster("default", new()
    {
        ClusterIdentifier = "neptune-cluster-demo",
        Engine = "neptune",
        BackupRetentionPeriod = 5,
        PreferredBackupWindow = "07:00-09:00",
        SkipFinalSnapshot = true,
        IamDatabaseAuthenticationEnabled = true,
        ApplyImmediately = true,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/neptune"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := neptune.NewCluster(ctx, "default", &neptune.ClusterArgs{
			ClusterIdentifier:                pulumi.String("neptune-cluster-demo"),
			Engine:                           pulumi.String("neptune"),
			BackupRetentionPeriod:            pulumi.Int(5),
			PreferredBackupWindow:            pulumi.String("07:00-09:00"),
			SkipFinalSnapshot:                pulumi.Bool(true),
			IamDatabaseAuthenticationEnabled: pulumi.Bool(true),
			ApplyImmediately:                 pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_neptune_cluster" "default" {
  cluster_identifier                  = "neptune-cluster-demo"
  engine                              = "neptune"
  backup_retention_period             = 5
  preferred_backup_window             = "07:00-09:00"
  skip_final_snapshot                 = true
  iam_database_authentication_enabled = true
  apply_immediately                   = true
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.neptune.Cluster;
import com.pulumi.aws.neptune.ClusterArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var default_ = new Cluster("default", ClusterArgs.builder()
            .clusterIdentifier("neptune-cluster-demo")
            .engine("neptune")
            .backupRetentionPeriod(5)
            .preferredBackupWindow("07:00-09:00")
            .skipFinalSnapshot(true)
            .iamDatabaseAuthenticationEnabled(true)
            .applyImmediately(true)
            .build());

    }
}
resources:
  default:
    type: aws:neptune:Cluster
    properties:
      clusterIdentifier: neptune-cluster-demo
      engine: neptune
      backupRetentionPeriod: 5
      preferredBackupWindow: 07:00-09:00
      skipFinalSnapshot: true
      iamDatabaseAuthenticationEnabled: true
      applyImmediately: true

> Note: AWS Neptune does not support user name/password–based access control. See the AWS Docs for more information.

Import

Using pulumi import, import aws.neptune.Cluster using the cluster identifier. For example:

$ pulumi import aws:neptune/cluster:Cluster example my-cluster

Constructors

Cluster(String name, {ClusterArgs? args, CustomResourceOptions? options})
Creates a new Cluster. name The Pulumi resource name. args Arguments used to configure this Cluster. The set of arguments for Cluster. options Resource options controlling this resource's behavior.
Cluster.reference(String urn)
Creates a typed reference to an existing Cluster resource.

Properties

allowMajorVersionUpgrade ↔ Output<bool>
Whether upgrades between different major versions are allowed. You must set it to true when providing an engineVersion parameter that uses a different major version than the DB cluster's current version. Default is false.
latefinal
applyImmediately ↔ Output<bool>
Whether any cluster modifications are applied immediately, or during the next maintenance window. Default is false.
latefinal
arn ↔ Output<String>
Neptune Cluster ARN
latefinal
availabilityZones ↔ Output<List<String>>
List of EC2 Availability Zones that instances in the Neptune cluster can be created in.
latefinal
backupRetentionPeriod ↔ Output<int?>
Days to retain backups for. Default 1
latefinal
childResources → Set<Resource>
finalinherited
clusterIdentifier ↔ Output<String>
Cluster identifier. If omitted, Terraform will assign a random, unique identifier.
latefinal
clusterIdentifierPrefix ↔ Output<String>
Creates a unique cluster identifier beginning with the specified prefix. Conflicts with clusterIdentifier.
latefinal
clusterMembers ↔ Output<List<String>>
List of Neptune Instances that are a part of this cluster
latefinal
clusterResourceId ↔ Output<String>
Neptune Cluster Resource ID
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
copyTagsToSnapshot ↔ Output<bool?>
If set to true, tags are copied to any snapshot of the DB cluster that is created.
latefinal
deletionProtection ↔ Output<bool?>
Value that indicates whether the DB cluster has deletion protection enabled.The database can't be deleted when deletion protection is enabled. By default, deletion protection is disabled.
latefinal
enableCloudwatchLogsExports ↔ Output<List<String>?>
List of the log types this DB cluster is configured to export to Cloudwatch Logs. Currently only supports audit and slowquery.
latefinal
endpoint ↔ Output<String>
DNS address of the Neptune instance
latefinal
engine ↔ Output<String?>
Name of the database engine to be used for this Neptune cluster. Defaults to neptune.
latefinal
engineVersion ↔ Output<String>
Database engine version.
latefinal
finalSnapshotIdentifier ↔ Output<String?>
Name of your final Neptune snapshot when this Neptune cluster is deleted. If omitted, no final snapshot will be made.
latefinal
globalClusterIdentifier ↔ Output<String?>
Global cluster identifier specified on aws.neptune.GlobalCluster.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
hostedZoneId ↔ Output<String>
Route53 Hosted Zone ID of the endpoint
latefinal
iamDatabaseAuthenticationEnabled ↔ Output<bool?>
Whether or not mappings of AWS Identity and Access Management (IAM) accounts to database accounts is enabled.
latefinal
iamRoles ↔ Output<List<String>?>
List of ARNs for the IAM roles to associate to the Neptune Cluster.
latefinal
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
kmsKeyArn ↔ Output<String>
ARN for the KMS encryption key. When specifying kmsKeyArn, storageEncrypted needs to be set to true.
latefinal
neptuneClusterParameterGroupName ↔ Output<String>
Cluster parameter group to associate with the cluster.
latefinal
neptuneInstanceParameterGroupName ↔ Output<String?>
Name of DB parameter group to apply to all instances in the cluster. When upgrading, AWS does not return this value, so do not reference it in other arguments—either leave it unset, configure each instance directly, or ensure it matches the engineVersion.
latefinal
neptuneSubnetGroupName ↔ Output<String>
Neptune subnet group to associate with this Neptune instance.
latefinal
port ↔ Output<int?>
Port on which the Neptune accepts connections. Default is 8182.
latefinal
preferredBackupWindow ↔ Output<String>
Daily time range during which automated backups are created if automated backups are enabled using the BackupRetentionPeriod parameter. Time in UTC. Default: A 30-minute window selected at random from an 8-hour block of time per regionE.g., 04:00-09:00
latefinal
preferredMaintenanceWindow ↔ Output<String>
Weekly time range during which system maintenance can occur, in (UTC) e.g., wed:04:00-wed:04:30
latefinal
readerEndpoint ↔ Output<String>
Read-only endpoint for the Neptune cluster, automatically load-balanced across replicas
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
replicationSourceIdentifier ↔ Output<String?>
ARN of a source Neptune cluster or Neptune instance if this Neptune cluster is to be created as a Read Replica.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
serverlessV2ScalingConfiguration ↔ Output<ClusterServerlessV2ScalingConfiguration?>
If set, create the Neptune cluster as a serverless one. See Serverless for example block attributes.
latefinal
skipFinalSnapshot ↔ Output<bool?>
Whether a final Neptune snapshot is created before the Neptune cluster is deleted. If true is specified, no Neptune snapshot is created. If false is specified, a Neptune snapshot is created before the Neptune cluster is deleted, using the value from finalSnapshotIdentifier. Default is false.
latefinal
snapshotIdentifier ↔ Output<String?>
Whether or not to create this cluster from a snapshot. You can use either the name or ARN when specifying a Neptune cluster snapshot, or the ARN when specifying a Neptune snapshot. Automated snapshots should not be used for this attribute, unless from a different cluster. Automated snapshots are deleted as part of cluster destruction when the resource is replaced.
latefinal
storageEncrypted ↔ Output<bool?>
Whether the Neptune cluster is encrypted. The default is false if not specified.
latefinal
storageType ↔ Output<String>
Storage type associated with the cluster standard/iopt1. Default: standard.
latefinal
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the Neptune cluster. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
vpcSecurityGroupIds ↔ Output<List<String>>
List of VPC security groups to associate with the Cluster
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ClusterState? state, CustomResourceOptions? options}) → Cluster
Gets an existing Cluster resource's state with the given name and id.