aws.finspace.KxCluster
Explore with Pulumi AI
Resource for managing an AWS FinSpace Kx Cluster.
Example Usage
Basic Usage
Coming soon!
Coming soon!
Coming soon!
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.finspace.KxCluster;
import com.pulumi.aws.finspace.KxClusterArgs;
import com.pulumi.aws.finspace.inputs.KxClusterCapacityConfigurationArgs;
import com.pulumi.aws.finspace.inputs.KxClusterVpcConfigurationArgs;
import com.pulumi.aws.finspace.inputs.KxClusterCacheStorageConfigurationArgs;
import com.pulumi.aws.finspace.inputs.KxClusterDatabaseArgs;
import com.pulumi.aws.finspace.inputs.KxClusterCodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new KxCluster("example", KxClusterArgs.builder()
            .name("my-tf-kx-cluster")
            .environmentId(exampleAwsFinspaceKxEnvironment.id())
            .type("HDB")
            .releaseLabel("1.0")
            .azMode("SINGLE")
            .availabilityZoneId("use1-az2")
            .capacityConfiguration(KxClusterCapacityConfigurationArgs.builder()
                .nodeType("kx.s.2xlarge")
                .nodeCount(2)
                .build())
            .vpcConfiguration(KxClusterVpcConfigurationArgs.builder()
                .vpcId(test.id())
                .securityGroupIds(exampleAwsSecurityGroup.id())
                .subnetIds(exampleAwsSubnet.id())
                .ipAddressType("IP_V4")
                .build())
            .cacheStorageConfigurations(KxClusterCacheStorageConfigurationArgs.builder()
                .type("CACHE_1000")
                .size(1200)
                .build())
            .databases(KxClusterDatabaseArgs.builder()
                .databaseName(exampleAwsFinspaceKxDatabase.name())
                .cacheConfiguration(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                .build())
            .code(KxClusterCodeArgs.builder()
                .s3Bucket(testAwsS3Bucket.id())
                .s3Key(object.key())
                .build())
            .build());
    }
}
resources:
  example:
    type: aws:finspace:KxCluster
    properties:
      name: my-tf-kx-cluster
      environmentId: ${exampleAwsFinspaceKxEnvironment.id}
      type: HDB
      releaseLabel: '1.0'
      azMode: SINGLE
      availabilityZoneId: use1-az2
      capacityConfiguration:
        nodeType: kx.s.2xlarge
        nodeCount: 2
      vpcConfiguration:
        vpcId: ${test.id}
        securityGroupIds:
          - ${exampleAwsSecurityGroup.id}
        subnetIds:
          - ${exampleAwsSubnet.id}
        ipAddressType: IP_V4
      cacheStorageConfigurations:
        - type: CACHE_1000
          size: 1200
      databases:
        - databaseName: ${exampleAwsFinspaceKxDatabase.name}
          cacheConfiguration:
            - cacheType: CACHE_1000
              dbPaths: /
      code:
        s3Bucket: ${testAwsS3Bucket.id}
        s3Key: ${object.key}
Create KxCluster Resource
Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.
Constructor syntax
new KxCluster(name: string, args: KxClusterArgs, opts?: CustomResourceOptions);@overload
def KxCluster(resource_name: str,
              args: KxClusterArgs,
              opts: Optional[ResourceOptions] = None)
@overload
def KxCluster(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              environment_id: Optional[str] = None,
              vpc_configuration: Optional[KxClusterVpcConfigurationArgs] = None,
              az_mode: Optional[str] = None,
              type: Optional[str] = None,
              release_label: Optional[str] = None,
              execution_role: Optional[str] = None,
              name: Optional[str] = None,
              databases: Optional[Sequence[KxClusterDatabaseArgs]] = None,
              description: Optional[str] = None,
              code: Optional[KxClusterCodeArgs] = None,
              auto_scaling_configuration: Optional[KxClusterAutoScalingConfigurationArgs] = None,
              initialization_script: Optional[str] = None,
              command_line_arguments: Optional[Mapping[str, str]] = None,
              capacity_configuration: Optional[KxClusterCapacityConfigurationArgs] = None,
              savedown_storage_configuration: Optional[KxClusterSavedownStorageConfigurationArgs] = None,
              scaling_group_configuration: Optional[KxClusterScalingGroupConfigurationArgs] = None,
              tags: Optional[Mapping[str, str]] = None,
              tickerplant_log_configurations: Optional[Sequence[KxClusterTickerplantLogConfigurationArgs]] = None,
              cache_storage_configurations: Optional[Sequence[KxClusterCacheStorageConfigurationArgs]] = None,
              availability_zone_id: Optional[str] = None)func NewKxCluster(ctx *Context, name string, args KxClusterArgs, opts ...ResourceOption) (*KxCluster, error)public KxCluster(string name, KxClusterArgs args, CustomResourceOptions? opts = null)
public KxCluster(String name, KxClusterArgs args)
public KxCluster(String name, KxClusterArgs args, CustomResourceOptions options)
type: aws:finspace:KxCluster
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.
Parameters
- name string
- The unique name of the resource.
- args KxClusterArgs
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- resource_name str
- The unique name of the resource.
- args KxClusterArgs
- The arguments to resource properties.
- opts ResourceOptions
- Bag of options to control resource's behavior.
- ctx Context
- Context object for the current deployment.
- name string
- The unique name of the resource.
- args KxClusterArgs
- The arguments to resource properties.
- opts ResourceOption
- Bag of options to control resource's behavior.
- name string
- The unique name of the resource.
- args KxClusterArgs
- The arguments to resource properties.
- opts CustomResourceOptions
- Bag of options to control resource's behavior.
- name String
- The unique name of the resource.
- args KxClusterArgs
- The arguments to resource properties.
- options CustomResourceOptions
- Bag of options to control resource's behavior.
Constructor example
The following reference example uses placeholder values for all input properties.
var kxClusterResource = new Aws.FinSpace.KxCluster("kxClusterResource", new()
{
    EnvironmentId = "string",
    VpcConfiguration = new Aws.FinSpace.Inputs.KxClusterVpcConfigurationArgs
    {
        IpAddressType = "string",
        SecurityGroupIds = new[]
        {
            "string",
        },
        SubnetIds = new[]
        {
            "string",
        },
        VpcId = "string",
    },
    AzMode = "string",
    Type = "string",
    ReleaseLabel = "string",
    ExecutionRole = "string",
    Name = "string",
    Databases = new[]
    {
        new Aws.FinSpace.Inputs.KxClusterDatabaseArgs
        {
            DatabaseName = "string",
            CacheConfigurations = new[]
            {
                new Aws.FinSpace.Inputs.KxClusterDatabaseCacheConfigurationArgs
                {
                    CacheType = "string",
                    DbPaths = new[]
                    {
                        "string",
                    },
                },
            },
            ChangesetId = "string",
            DataviewName = "string",
        },
    },
    Description = "string",
    Code = new Aws.FinSpace.Inputs.KxClusterCodeArgs
    {
        S3Bucket = "string",
        S3Key = "string",
        S3ObjectVersion = "string",
    },
    AutoScalingConfiguration = new Aws.FinSpace.Inputs.KxClusterAutoScalingConfigurationArgs
    {
        AutoScalingMetric = "string",
        MaxNodeCount = 0,
        MetricTarget = 0,
        MinNodeCount = 0,
        ScaleInCooldownSeconds = 0,
        ScaleOutCooldownSeconds = 0,
    },
    InitializationScript = "string",
    CommandLineArguments = 
    {
        { "string", "string" },
    },
    CapacityConfiguration = new Aws.FinSpace.Inputs.KxClusterCapacityConfigurationArgs
    {
        NodeCount = 0,
        NodeType = "string",
    },
    SavedownStorageConfiguration = new Aws.FinSpace.Inputs.KxClusterSavedownStorageConfigurationArgs
    {
        Size = 0,
        Type = "string",
        VolumeName = "string",
    },
    ScalingGroupConfiguration = new Aws.FinSpace.Inputs.KxClusterScalingGroupConfigurationArgs
    {
        MemoryReservation = 0,
        NodeCount = 0,
        ScalingGroupName = "string",
        Cpu = 0,
        MemoryLimit = 0,
    },
    Tags = 
    {
        { "string", "string" },
    },
    TickerplantLogConfigurations = new[]
    {
        new Aws.FinSpace.Inputs.KxClusterTickerplantLogConfigurationArgs
        {
            TickerplantLogVolumes = new[]
            {
                "string",
            },
        },
    },
    CacheStorageConfigurations = new[]
    {
        new Aws.FinSpace.Inputs.KxClusterCacheStorageConfigurationArgs
        {
            Size = 0,
            Type = "string",
        },
    },
    AvailabilityZoneId = "string",
});
example, err := finspace.NewKxCluster(ctx, "kxClusterResource", &finspace.KxClusterArgs{
	EnvironmentId: pulumi.String("string"),
	VpcConfiguration: &finspace.KxClusterVpcConfigurationArgs{
		IpAddressType: pulumi.String("string"),
		SecurityGroupIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		SubnetIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		VpcId: pulumi.String("string"),
	},
	AzMode:        pulumi.String("string"),
	Type:          pulumi.String("string"),
	ReleaseLabel:  pulumi.String("string"),
	ExecutionRole: pulumi.String("string"),
	Name:          pulumi.String("string"),
	Databases: finspace.KxClusterDatabaseArray{
		&finspace.KxClusterDatabaseArgs{
			DatabaseName: pulumi.String("string"),
			CacheConfigurations: finspace.KxClusterDatabaseCacheConfigurationArray{
				&finspace.KxClusterDatabaseCacheConfigurationArgs{
					CacheType: pulumi.String("string"),
					DbPaths: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
			},
			ChangesetId:  pulumi.String("string"),
			DataviewName: pulumi.String("string"),
		},
	},
	Description: pulumi.String("string"),
	Code: &finspace.KxClusterCodeArgs{
		S3Bucket:        pulumi.String("string"),
		S3Key:           pulumi.String("string"),
		S3ObjectVersion: pulumi.String("string"),
	},
	AutoScalingConfiguration: &finspace.KxClusterAutoScalingConfigurationArgs{
		AutoScalingMetric:       pulumi.String("string"),
		MaxNodeCount:            pulumi.Int(0),
		MetricTarget:            pulumi.Float64(0),
		MinNodeCount:            pulumi.Int(0),
		ScaleInCooldownSeconds:  pulumi.Float64(0),
		ScaleOutCooldownSeconds: pulumi.Float64(0),
	},
	InitializationScript: pulumi.String("string"),
	CommandLineArguments: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	CapacityConfiguration: &finspace.KxClusterCapacityConfigurationArgs{
		NodeCount: pulumi.Int(0),
		NodeType:  pulumi.String("string"),
	},
	SavedownStorageConfiguration: &finspace.KxClusterSavedownStorageConfigurationArgs{
		Size:       pulumi.Int(0),
		Type:       pulumi.String("string"),
		VolumeName: pulumi.String("string"),
	},
	ScalingGroupConfiguration: &finspace.KxClusterScalingGroupConfigurationArgs{
		MemoryReservation: pulumi.Int(0),
		NodeCount:         pulumi.Int(0),
		ScalingGroupName:  pulumi.String("string"),
		Cpu:               pulumi.Float64(0),
		MemoryLimit:       pulumi.Int(0),
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	TickerplantLogConfigurations: finspace.KxClusterTickerplantLogConfigurationArray{
		&finspace.KxClusterTickerplantLogConfigurationArgs{
			TickerplantLogVolumes: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
	CacheStorageConfigurations: finspace.KxClusterCacheStorageConfigurationArray{
		&finspace.KxClusterCacheStorageConfigurationArgs{
			Size: pulumi.Int(0),
			Type: pulumi.String("string"),
		},
	},
	AvailabilityZoneId: pulumi.String("string"),
})
var kxClusterResource = new KxCluster("kxClusterResource", KxClusterArgs.builder()
    .environmentId("string")
    .vpcConfiguration(KxClusterVpcConfigurationArgs.builder()
        .ipAddressType("string")
        .securityGroupIds("string")
        .subnetIds("string")
        .vpcId("string")
        .build())
    .azMode("string")
    .type("string")
    .releaseLabel("string")
    .executionRole("string")
    .name("string")
    .databases(KxClusterDatabaseArgs.builder()
        .databaseName("string")
        .cacheConfigurations(KxClusterDatabaseCacheConfigurationArgs.builder()
            .cacheType("string")
            .dbPaths("string")
            .build())
        .changesetId("string")
        .dataviewName("string")
        .build())
    .description("string")
    .code(KxClusterCodeArgs.builder()
        .s3Bucket("string")
        .s3Key("string")
        .s3ObjectVersion("string")
        .build())
    .autoScalingConfiguration(KxClusterAutoScalingConfigurationArgs.builder()
        .autoScalingMetric("string")
        .maxNodeCount(0)
        .metricTarget(0)
        .minNodeCount(0)
        .scaleInCooldownSeconds(0)
        .scaleOutCooldownSeconds(0)
        .build())
    .initializationScript("string")
    .commandLineArguments(Map.of("string", "string"))
    .capacityConfiguration(KxClusterCapacityConfigurationArgs.builder()
        .nodeCount(0)
        .nodeType("string")
        .build())
    .savedownStorageConfiguration(KxClusterSavedownStorageConfigurationArgs.builder()
        .size(0)
        .type("string")
        .volumeName("string")
        .build())
    .scalingGroupConfiguration(KxClusterScalingGroupConfigurationArgs.builder()
        .memoryReservation(0)
        .nodeCount(0)
        .scalingGroupName("string")
        .cpu(0)
        .memoryLimit(0)
        .build())
    .tags(Map.of("string", "string"))
    .tickerplantLogConfigurations(KxClusterTickerplantLogConfigurationArgs.builder()
        .tickerplantLogVolumes("string")
        .build())
    .cacheStorageConfigurations(KxClusterCacheStorageConfigurationArgs.builder()
        .size(0)
        .type("string")
        .build())
    .availabilityZoneId("string")
    .build());
kx_cluster_resource = aws.finspace.KxCluster("kxClusterResource",
    environment_id="string",
    vpc_configuration={
        "ip_address_type": "string",
        "security_group_ids": ["string"],
        "subnet_ids": ["string"],
        "vpc_id": "string",
    },
    az_mode="string",
    type="string",
    release_label="string",
    execution_role="string",
    name="string",
    databases=[{
        "database_name": "string",
        "cache_configurations": [{
            "cache_type": "string",
            "db_paths": ["string"],
        }],
        "changeset_id": "string",
        "dataview_name": "string",
    }],
    description="string",
    code={
        "s3_bucket": "string",
        "s3_key": "string",
        "s3_object_version": "string",
    },
    auto_scaling_configuration={
        "auto_scaling_metric": "string",
        "max_node_count": 0,
        "metric_target": 0,
        "min_node_count": 0,
        "scale_in_cooldown_seconds": 0,
        "scale_out_cooldown_seconds": 0,
    },
    initialization_script="string",
    command_line_arguments={
        "string": "string",
    },
    capacity_configuration={
        "node_count": 0,
        "node_type": "string",
    },
    savedown_storage_configuration={
        "size": 0,
        "type": "string",
        "volume_name": "string",
    },
    scaling_group_configuration={
        "memory_reservation": 0,
        "node_count": 0,
        "scaling_group_name": "string",
        "cpu": 0,
        "memory_limit": 0,
    },
    tags={
        "string": "string",
    },
    tickerplant_log_configurations=[{
        "tickerplant_log_volumes": ["string"],
    }],
    cache_storage_configurations=[{
        "size": 0,
        "type": "string",
    }],
    availability_zone_id="string")
const kxClusterResource = new aws.finspace.KxCluster("kxClusterResource", {
    environmentId: "string",
    vpcConfiguration: {
        ipAddressType: "string",
        securityGroupIds: ["string"],
        subnetIds: ["string"],
        vpcId: "string",
    },
    azMode: "string",
    type: "string",
    releaseLabel: "string",
    executionRole: "string",
    name: "string",
    databases: [{
        databaseName: "string",
        cacheConfigurations: [{
            cacheType: "string",
            dbPaths: ["string"],
        }],
        changesetId: "string",
        dataviewName: "string",
    }],
    description: "string",
    code: {
        s3Bucket: "string",
        s3Key: "string",
        s3ObjectVersion: "string",
    },
    autoScalingConfiguration: {
        autoScalingMetric: "string",
        maxNodeCount: 0,
        metricTarget: 0,
        minNodeCount: 0,
        scaleInCooldownSeconds: 0,
        scaleOutCooldownSeconds: 0,
    },
    initializationScript: "string",
    commandLineArguments: {
        string: "string",
    },
    capacityConfiguration: {
        nodeCount: 0,
        nodeType: "string",
    },
    savedownStorageConfiguration: {
        size: 0,
        type: "string",
        volumeName: "string",
    },
    scalingGroupConfiguration: {
        memoryReservation: 0,
        nodeCount: 0,
        scalingGroupName: "string",
        cpu: 0,
        memoryLimit: 0,
    },
    tags: {
        string: "string",
    },
    tickerplantLogConfigurations: [{
        tickerplantLogVolumes: ["string"],
    }],
    cacheStorageConfigurations: [{
        size: 0,
        type: "string",
    }],
    availabilityZoneId: "string",
});
type: aws:finspace:KxCluster
properties:
    autoScalingConfiguration:
        autoScalingMetric: string
        maxNodeCount: 0
        metricTarget: 0
        minNodeCount: 0
        scaleInCooldownSeconds: 0
        scaleOutCooldownSeconds: 0
    availabilityZoneId: string
    azMode: string
    cacheStorageConfigurations:
        - size: 0
          type: string
    capacityConfiguration:
        nodeCount: 0
        nodeType: string
    code:
        s3Bucket: string
        s3Key: string
        s3ObjectVersion: string
    commandLineArguments:
        string: string
    databases:
        - cacheConfigurations:
            - cacheType: string
              dbPaths:
                - string
          changesetId: string
          databaseName: string
          dataviewName: string
    description: string
    environmentId: string
    executionRole: string
    initializationScript: string
    name: string
    releaseLabel: string
    savedownStorageConfiguration:
        size: 0
        type: string
        volumeName: string
    scalingGroupConfiguration:
        cpu: 0
        memoryLimit: 0
        memoryReservation: 0
        nodeCount: 0
        scalingGroupName: string
    tags:
        string: string
    tickerplantLogConfigurations:
        - tickerplantLogVolumes:
            - string
    type: string
    vpcConfiguration:
        ipAddressType: string
        securityGroupIds:
            - string
        subnetIds:
            - string
        vpcId: string
KxCluster Resource Properties
To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.
Inputs
In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.
The KxCluster resource accepts the following input properties:
- AzMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- EnvironmentId string
- Unique identifier for the KX environment.
- ReleaseLabel string
- Version of FinSpace Managed kdb to run.
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- VpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- AutoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- AvailabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- CacheStorage List<KxConfigurations Cluster Cache Storage Configuration> 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- CapacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- Code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- CommandLine Dictionary<string, string>Arguments 
- List of key-value pairs to make available inside the cluster.
- Databases
List<KxCluster Database> 
- KX database that will be available for querying. Defined below.
- Description string
- Description of the cluster.
- ExecutionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- InitializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- Name string
- Unique name for the cluster that you want to create.
- SavedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- ScalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- Dictionary<string, string>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- TickerplantLog List<KxConfigurations Cluster Tickerplant Log Configuration> 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- AzMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- EnvironmentId string
- Unique identifier for the KX environment.
- ReleaseLabel string
- Version of FinSpace Managed kdb to run.
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- VpcConfiguration KxCluster Vpc Configuration Args 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- AutoScaling KxConfiguration Cluster Auto Scaling Configuration Args 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- AvailabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- CacheStorage []KxConfigurations Cluster Cache Storage Configuration Args 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- CapacityConfiguration KxCluster Capacity Configuration Args 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- Code
KxCluster Code Args 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- CommandLine map[string]stringArguments 
- List of key-value pairs to make available inside the cluster.
- Databases
[]KxCluster Database Args 
- KX database that will be available for querying. Defined below.
- Description string
- Description of the cluster.
- ExecutionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- InitializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- Name string
- Unique name for the cluster that you want to create.
- SavedownStorage KxConfiguration Cluster Savedown Storage Configuration Args 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- ScalingGroup KxConfiguration Cluster Scaling Group Configuration Args 
- The structure that stores the configuration details of a scaling group.
- map[string]string
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- TickerplantLog []KxConfigurations Cluster Tickerplant Log Configuration Args 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- azMode String
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- environmentId String
- Unique identifier for the KX environment.
- releaseLabel String
- Version of FinSpace Managed kdb to run.
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- autoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone StringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- cacheStorage List<KxConfigurations Cluster Cache Storage Configuration> 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine Map<String,String>Arguments 
- List of key-value pairs to make available inside the cluster.
- databases
List<KxCluster Database> 
- KX database that will be available for querying. Defined below.
- description String
- Description of the cluster.
- executionRole String
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript String
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- name String
- Unique name for the cluster that you want to create.
- savedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- Map<String,String>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- tickerplantLog List<KxConfigurations Cluster Tickerplant Log Configuration> 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- azMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- environmentId string
- Unique identifier for the KX environment.
- releaseLabel string
- Version of FinSpace Managed kdb to run.
- type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- autoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- cacheStorage KxConfigurations Cluster Cache Storage Configuration[] 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine {[key: string]: string}Arguments 
- List of key-value pairs to make available inside the cluster.
- databases
KxCluster Database[] 
- KX database that will be available for querying. Defined below.
- description string
- Description of the cluster.
- executionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- name string
- Unique name for the cluster that you want to create.
- savedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- {[key: string]: string}
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- tickerplantLog KxConfigurations Cluster Tickerplant Log Configuration[] 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- az_mode str
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- environment_id str
- Unique identifier for the KX environment.
- release_label str
- Version of FinSpace Managed kdb to run.
- type str
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpc_configuration KxCluster Vpc Configuration Args 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- auto_scaling_ Kxconfiguration Cluster Auto Scaling Configuration Args 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availability_zone_ strid 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- cache_storage_ Sequence[Kxconfigurations Cluster Cache Storage Configuration Args] 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacity_configuration KxCluster Capacity Configuration Args 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code Args 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- command_line_ Mapping[str, str]arguments 
- List of key-value pairs to make available inside the cluster.
- databases
Sequence[KxCluster Database Args] 
- KX database that will be available for querying. Defined below.
- description str
- Description of the cluster.
- execution_role str
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initialization_script str
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- name str
- Unique name for the cluster that you want to create.
- savedown_storage_ Kxconfiguration Cluster Savedown Storage Configuration Args 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scaling_group_ Kxconfiguration Cluster Scaling Group Configuration Args 
- The structure that stores the configuration details of a scaling group.
- Mapping[str, str]
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- tickerplant_log_ Sequence[Kxconfigurations Cluster Tickerplant Log Configuration Args] 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- azMode String
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- environmentId String
- Unique identifier for the KX environment.
- releaseLabel String
- Version of FinSpace Managed kdb to run.
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration Property Map
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- autoScaling Property MapConfiguration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone StringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- cacheStorage List<Property Map>Configurations 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration Property Map
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code Property Map
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine Map<String>Arguments 
- List of key-value pairs to make available inside the cluster.
- databases List<Property Map>
- KX database that will be available for querying. Defined below.
- description String
- Description of the cluster.
- executionRole String
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript String
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- name String
- Unique name for the cluster that you want to create.
- savedownStorage Property MapConfiguration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup Property MapConfiguration 
- The structure that stores the configuration details of a scaling group.
- Map<String>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- tickerplantLog List<Property Map>Configurations 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
Outputs
All input properties are implicitly available as output properties. Additionally, the KxCluster resource produces the following output properties:
- Arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- CreatedTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Id string
- The provider-assigned unique ID for this managed resource.
- LastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Status string
- StatusReason string
- Dictionary<string, string>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- Arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- CreatedTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Id string
- The provider-assigned unique ID for this managed resource.
- LastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Status string
- StatusReason string
- map[string]string
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- arn String
- Amazon Resource Name (ARN) identifier of the KX cluster.
- createdTimestamp String
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- id String
- The provider-assigned unique ID for this managed resource.
- lastModified StringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- status String
- statusReason String
- Map<String,String>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- createdTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- id string
- The provider-assigned unique ID for this managed resource.
- lastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- status string
- statusReason string
- {[key: string]: string}
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- arn str
- Amazon Resource Name (ARN) identifier of the KX cluster.
- created_timestamp str
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- id str
- The provider-assigned unique ID for this managed resource.
- last_modified_ strtimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- status str
- status_reason str
- Mapping[str, str]
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- arn String
- Amazon Resource Name (ARN) identifier of the KX cluster.
- createdTimestamp String
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- id String
- The provider-assigned unique ID for this managed resource.
- lastModified StringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- status String
- statusReason String
- Map<String>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
Look up Existing KxCluster Resource
Get an existing KxCluster resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.
public static get(name: string, id: Input<ID>, state?: KxClusterState, opts?: CustomResourceOptions): KxCluster@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        arn: Optional[str] = None,
        auto_scaling_configuration: Optional[KxClusterAutoScalingConfigurationArgs] = None,
        availability_zone_id: Optional[str] = None,
        az_mode: Optional[str] = None,
        cache_storage_configurations: Optional[Sequence[KxClusterCacheStorageConfigurationArgs]] = None,
        capacity_configuration: Optional[KxClusterCapacityConfigurationArgs] = None,
        code: Optional[KxClusterCodeArgs] = None,
        command_line_arguments: Optional[Mapping[str, str]] = None,
        created_timestamp: Optional[str] = None,
        databases: Optional[Sequence[KxClusterDatabaseArgs]] = None,
        description: Optional[str] = None,
        environment_id: Optional[str] = None,
        execution_role: Optional[str] = None,
        initialization_script: Optional[str] = None,
        last_modified_timestamp: Optional[str] = None,
        name: Optional[str] = None,
        release_label: Optional[str] = None,
        savedown_storage_configuration: Optional[KxClusterSavedownStorageConfigurationArgs] = None,
        scaling_group_configuration: Optional[KxClusterScalingGroupConfigurationArgs] = None,
        status: Optional[str] = None,
        status_reason: Optional[str] = None,
        tags: Optional[Mapping[str, str]] = None,
        tags_all: Optional[Mapping[str, str]] = None,
        tickerplant_log_configurations: Optional[Sequence[KxClusterTickerplantLogConfigurationArgs]] = None,
        type: Optional[str] = None,
        vpc_configuration: Optional[KxClusterVpcConfigurationArgs] = None) -> KxClusterfunc GetKxCluster(ctx *Context, name string, id IDInput, state *KxClusterState, opts ...ResourceOption) (*KxCluster, error)public static KxCluster Get(string name, Input<string> id, KxClusterState? state, CustomResourceOptions? opts = null)public static KxCluster get(String name, Output<String> id, KxClusterState state, CustomResourceOptions options)resources:  _:    type: aws:finspace:KxCluster    get:      id: ${id}- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- resource_name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- name
- The unique name of the resulting resource.
- id
- The unique provider ID of the resource to lookup.
- state
- Any extra arguments used during the lookup.
- opts
- A bag of options that control this resource's behavior.
- Arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- AutoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- AvailabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- AzMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- CacheStorage List<KxConfigurations Cluster Cache Storage Configuration> 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- CapacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- Code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- CommandLine Dictionary<string, string>Arguments 
- List of key-value pairs to make available inside the cluster.
- CreatedTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Databases
List<KxCluster Database> 
- KX database that will be available for querying. Defined below.
- Description string
- Description of the cluster.
- EnvironmentId string
- Unique identifier for the KX environment.
- ExecutionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- InitializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- LastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Name string
- Unique name for the cluster that you want to create.
- ReleaseLabel string
- Version of FinSpace Managed kdb to run.
- SavedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- ScalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- Status string
- StatusReason string
- Dictionary<string, string>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- Dictionary<string, string>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- TickerplantLog List<KxConfigurations Cluster Tickerplant Log Configuration> 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- VpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- Arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- AutoScaling KxConfiguration Cluster Auto Scaling Configuration Args 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- AvailabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- AzMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- CacheStorage []KxConfigurations Cluster Cache Storage Configuration Args 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- CapacityConfiguration KxCluster Capacity Configuration Args 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- Code
KxCluster Code Args 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- CommandLine map[string]stringArguments 
- List of key-value pairs to make available inside the cluster.
- CreatedTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Databases
[]KxCluster Database Args 
- KX database that will be available for querying. Defined below.
- Description string
- Description of the cluster.
- EnvironmentId string
- Unique identifier for the KX environment.
- ExecutionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- InitializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- LastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- Name string
- Unique name for the cluster that you want to create.
- ReleaseLabel string
- Version of FinSpace Managed kdb to run.
- SavedownStorage KxConfiguration Cluster Savedown Storage Configuration Args 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- ScalingGroup KxConfiguration Cluster Scaling Group Configuration Args 
- The structure that stores the configuration details of a scaling group.
- Status string
- StatusReason string
- map[string]string
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- map[string]string
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- TickerplantLog []KxConfigurations Cluster Tickerplant Log Configuration Args 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- VpcConfiguration KxCluster Vpc Configuration Args 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- arn String
- Amazon Resource Name (ARN) identifier of the KX cluster.
- autoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone StringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- azMode String
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- cacheStorage List<KxConfigurations Cluster Cache Storage Configuration> 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine Map<String,String>Arguments 
- List of key-value pairs to make available inside the cluster.
- createdTimestamp String
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- databases
List<KxCluster Database> 
- KX database that will be available for querying. Defined below.
- description String
- Description of the cluster.
- environmentId String
- Unique identifier for the KX environment.
- executionRole String
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript String
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- lastModified StringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- name String
- Unique name for the cluster that you want to create.
- releaseLabel String
- Version of FinSpace Managed kdb to run.
- savedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- status String
- statusReason String
- Map<String,String>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- Map<String,String>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- tickerplantLog List<KxConfigurations Cluster Tickerplant Log Configuration> 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- arn string
- Amazon Resource Name (ARN) identifier of the KX cluster.
- autoScaling KxConfiguration Cluster Auto Scaling Configuration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone stringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- azMode string
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- cacheStorage KxConfigurations Cluster Cache Storage Configuration[] 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration KxCluster Capacity Configuration 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine {[key: string]: string}Arguments 
- List of key-value pairs to make available inside the cluster.
- createdTimestamp string
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- databases
KxCluster Database[] 
- KX database that will be available for querying. Defined below.
- description string
- Description of the cluster.
- environmentId string
- Unique identifier for the KX environment.
- executionRole string
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript string
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- lastModified stringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- name string
- Unique name for the cluster that you want to create.
- releaseLabel string
- Version of FinSpace Managed kdb to run.
- savedownStorage KxConfiguration Cluster Savedown Storage Configuration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup KxConfiguration Cluster Scaling Group Configuration 
- The structure that stores the configuration details of a scaling group.
- status string
- statusReason string
- {[key: string]: string}
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- {[key: string]: string}
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- tickerplantLog KxConfigurations Cluster Tickerplant Log Configuration[] 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration KxCluster Vpc Configuration 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- arn str
- Amazon Resource Name (ARN) identifier of the KX cluster.
- auto_scaling_ Kxconfiguration Cluster Auto Scaling Configuration Args 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availability_zone_ strid 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- az_mode str
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- cache_storage_ Sequence[Kxconfigurations Cluster Cache Storage Configuration Args] 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacity_configuration KxCluster Capacity Configuration Args 
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code
KxCluster Code Args 
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- command_line_ Mapping[str, str]arguments 
- List of key-value pairs to make available inside the cluster.
- created_timestamp str
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- databases
Sequence[KxCluster Database Args] 
- KX database that will be available for querying. Defined below.
- description str
- Description of the cluster.
- environment_id str
- Unique identifier for the KX environment.
- execution_role str
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initialization_script str
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- last_modified_ strtimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- name str
- Unique name for the cluster that you want to create.
- release_label str
- Version of FinSpace Managed kdb to run.
- savedown_storage_ Kxconfiguration Cluster Savedown Storage Configuration Args 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scaling_group_ Kxconfiguration Cluster Scaling Group Configuration Args 
- The structure that stores the configuration details of a scaling group.
- status str
- status_reason str
- Mapping[str, str]
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- Mapping[str, str]
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- tickerplant_log_ Sequence[Kxconfigurations Cluster Tickerplant Log Configuration Args] 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- type str
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpc_configuration KxCluster Vpc Configuration Args 
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
- arn String
- Amazon Resource Name (ARN) identifier of the KX cluster.
- autoScaling Property MapConfiguration 
- Configuration based on which FinSpace will scale in or scale out nodes in your cluster. See auto_scaling_configuration.
- availabilityZone StringId 
- The availability zone identifiers for the requested regions. Required when az_modeis set to SINGLE.
- azMode String
- The number of availability zones you want to assign per cluster. This can be one of the following:- SINGLE - Assigns one availability zone per cluster.
- MULTI - Assigns all the availability zones per cluster.
 
- cacheStorage List<Property Map>Configurations 
- Configurations for a read only cache storage associated with a cluster. This cache will be stored as an FSx Lustre that reads from the S3 store. See cache_storage_configuration.
- capacityConfiguration Property Map
- Structure for the metadata of a cluster. Includes information like the CPUs needed, memory of instances, and number of instances. See capacity_configuration.
- code Property Map
- Details of the custom code that you want to use inside a cluster when analyzing data. Consists of the S3 source bucket, location, object version, and the relative path from where the custom code is loaded into the cluster. See code.
- commandLine Map<String>Arguments 
- List of key-value pairs to make available inside the cluster.
- createdTimestamp String
- Timestamp at which the cluster is created in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- databases List<Property Map>
- KX database that will be available for querying. Defined below.
- description String
- Description of the cluster.
- environmentId String
- Unique identifier for the KX environment.
- executionRole String
- An IAM role that defines a set of permissions associated with a cluster. These permissions are assumed when a cluster attempts to access another cluster.
- initializationScript String
- Path to Q program that will be run at launch of a cluster. This is a relative path within .zip file that contains the custom code, which will be loaded on the cluster. It must include the file name itself. For example, somedir/init.q.
- lastModified StringTimestamp 
- Last timestamp at which the cluster was updated in FinSpace. Value determined as epoch time in seconds. For example, the value for Monday, November 1, 2021 12:00:00 PM UTC is specified as 1635768000.
- name String
- Unique name for the cluster that you want to create.
- releaseLabel String
- Version of FinSpace Managed kdb to run.
- savedownStorage Property MapConfiguration 
- Size and type of the temporary storage that is used to hold data during the savedown process. This parameter is required when you choose typeas RDB. All the data written to this storage space is lost when the cluster node is restarted. See savedown_storage_configuration.
- scalingGroup Property MapConfiguration 
- The structure that stores the configuration details of a scaling group.
- status String
- statusReason String
- Map<String>
- Key-value mapping of resource tags. If configured with a provider default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- Map<String>
- Map of tags assigned to the resource, including those inherited from the provider default_tagsconfiguration block.
- tickerplantLog List<Property Map>Configurations 
- A configuration to store Tickerplant logs. It consists of a list of volumes that will be mounted to your cluster. For the cluster type Tickerplant , the location of the TP volume on the cluster will be available by using the global variable .aws.tp_log_path.
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- vpcConfiguration Property Map
- Configuration details about the network where the Privatelink endpoint of the cluster resides. See vpc_configuration. - The following arguments are optional: 
Supporting Types
KxClusterAutoScalingConfiguration, KxClusterAutoScalingConfigurationArgs          
- AutoScaling stringMetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- MaxNode intCount 
- Highest number of nodes to scale. Cannot be greater than 5
- MetricTarget double
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- MinNode intCount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- ScaleIn doubleCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- ScaleOut doubleCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
- AutoScaling stringMetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- MaxNode intCount 
- Highest number of nodes to scale. Cannot be greater than 5
- MetricTarget float64
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- MinNode intCount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- ScaleIn float64Cooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- ScaleOut float64Cooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
- autoScaling StringMetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- maxNode IntegerCount 
- Highest number of nodes to scale. Cannot be greater than 5
- metricTarget Double
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- minNode IntegerCount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- scaleIn DoubleCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- scaleOut DoubleCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
- autoScaling stringMetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- maxNode numberCount 
- Highest number of nodes to scale. Cannot be greater than 5
- metricTarget number
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- minNode numberCount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- scaleIn numberCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- scaleOut numberCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
- auto_scaling_ strmetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- max_node_ intcount 
- Highest number of nodes to scale. Cannot be greater than 5
- metric_target float
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- min_node_ intcount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- scale_in_ floatcooldown_ seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- scale_out_ floatcooldown_ seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
- autoScaling StringMetric 
- Metric your cluster will track in order to scale in and out. For example, CPU_UTILIZATION_PERCENTAGE is the average CPU usage across all nodes in a cluster.
- maxNode NumberCount 
- Highest number of nodes to scale. Cannot be greater than 5
- metricTarget Number
- Desired value of chosen auto_scaling_metric. When metric drops below this value, cluster will scale in. When metric goes above this value, cluster will scale out. Can be set between 0 and 100 percent.
- minNode NumberCount 
- Lowest number of nodes to scale. Must be at least 1 and less than the max_node_count. If nodes in cluster belong to multiple availability zones, thenmin_node_countmust be at least 3.
- scaleIn NumberCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale in event before initiating another scaling event.
- scaleOut NumberCooldown Seconds 
- Duration in seconds that FinSpace will wait after a scale out event before initiating another scaling event.
KxClusterCacheStorageConfiguration, KxClusterCacheStorageConfigurationArgs          
- Size int
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- Size int
- Type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- size Integer
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- size number
- type string
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- size int
- type str
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
- size Number
- type String
- Type of KDB database. The following types are available:- HDB - Historical Database. The data is only accessible with read-only permissions from one of the FinSpace managed KX databases mounted to the cluster.
- RDB - Realtime Database. This type of database captures all the data from a ticker plant and stores it in memory until the end of day, after which it writes all of its data to a disk and reloads the HDB. This cluster type requires local storage for temporary storage of data during the savedown process. If you specify this field in your request, you must provide the savedownStorageConfigurationparameter.
- GATEWAY - A gateway cluster allows you to access data across processes in kdb systems. It allows you to create your own routing logic using the initialization scripts and custom code. This type of cluster does not require a writable local storage.
- GP - A general purpose cluster allows you to quickly iterate on code during development by granting greater access to system commands and enabling a fast reload of custom code. This cluster type can optionally mount databases including cache and savedown storage. For this cluster type, the node count is fixed at 1. It does not support autoscaling and supports only SINGLEAZ mode.
- Tickerplant – A tickerplant cluster allows you to subscribe to feed handlers based on IAM permissions. It can publish to RDBs, other Tickerplants, and real-time subscribers (RTS). Tickerplants can persist messages to log, which is readable by any RDB environment. It supports only single-node that is only one kdb process.
 
KxClusterCapacityConfiguration, KxClusterCapacityConfigurationArgs        
- NodeCount int
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- NodeType string
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
- NodeCount int
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- NodeType string
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
- nodeCount Integer
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- nodeType String
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
- nodeCount number
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- nodeType string
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
- node_count int
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- node_type str
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
- nodeCount Number
- Number of instances running in a cluster. Must be at least 1 and at most 5.
- nodeType String
- Determines the hardware of the host computer used for your cluster instance. Each node type offers different memory and storage capabilities. Choose a node type based on the requirements of the application or software that you plan to run on your instance. - You can only specify one of the following values: - kx.s.large – The node type with a configuration of 12 GiB memory and 2 vCPUs.
- kx.s.xlarge – The node type with a configuration of 27 GiB memory and 4 vCPUs.
- kx.s.2xlarge – The node type with a configuration of 54 GiB memory and 8 vCPUs.
- kx.s.4xlarge – The node type with a configuration of 108 GiB memory and 16 vCPUs.
- kx.s.8xlarge – The node type with a configuration of 216 GiB memory and 32 vCPUs.
- kx.s.16xlarge – The node type with a configuration of 432 GiB memory and 64 vCPUs.
- kx.s.32xlarge – The node type with a configuration of 864 GiB memory and 128 vCPUs.
 
KxClusterCode, KxClusterCodeArgs      
- S3Bucket string
- Unique name for the S3 bucket.
- S3Key string
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- S3ObjectVersion string
- Version of an S3 Object.
- S3Bucket string
- Unique name for the S3 bucket.
- S3Key string
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- S3ObjectVersion string
- Version of an S3 Object.
- s3Bucket String
- Unique name for the S3 bucket.
- s3Key String
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- s3ObjectVersion String
- Version of an S3 Object.
- s3Bucket string
- Unique name for the S3 bucket.
- s3Key string
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- s3ObjectVersion string
- Version of an S3 Object.
- s3_bucket str
- Unique name for the S3 bucket.
- s3_key str
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- s3_object_ strversion 
- Version of an S3 Object.
- s3Bucket String
- Unique name for the S3 bucket.
- s3Key String
- Full S3 path (excluding bucket) to the .zip file that contains the code to be loaded onto the cluster when it’s started.
- s3ObjectVersion String
- Version of an S3 Object.
KxClusterDatabase, KxClusterDatabaseArgs      
- DatabaseName string
- Name of the KX database.
- CacheConfigurations List<KxCluster Database Cache Configuration> 
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- ChangesetId string
- A unique identifier of the changeset that is associated with the cluster.
- DataviewName string
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
- DatabaseName string
- Name of the KX database.
- CacheConfigurations []KxCluster Database Cache Configuration 
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- ChangesetId string
- A unique identifier of the changeset that is associated with the cluster.
- DataviewName string
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
- databaseName String
- Name of the KX database.
- cacheConfigurations List<KxCluster Database Cache Configuration> 
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- changesetId String
- A unique identifier of the changeset that is associated with the cluster.
- dataviewName String
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
- databaseName string
- Name of the KX database.
- cacheConfigurations KxCluster Database Cache Configuration[] 
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- changesetId string
- A unique identifier of the changeset that is associated with the cluster.
- dataviewName string
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
- database_name str
- Name of the KX database.
- cache_configurations Sequence[KxCluster Database Cache Configuration] 
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- changeset_id str
- A unique identifier of the changeset that is associated with the cluster.
- dataview_name str
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
- databaseName String
- Name of the KX database.
- cacheConfigurations List<Property Map>
- Configuration details for the disk cache to increase performance reading from a KX database mounted to the cluster. See cache_configurations.
- changesetId String
- A unique identifier of the changeset that is associated with the cluster.
- dataviewName String
- The name of the dataview to be used for caching historical data on disk. You cannot update to a different dataview name once a cluster is created. Use lifecycleignore_changesfor database to prevent any undesirable behaviors.
KxClusterDatabaseCacheConfiguration, KxClusterDatabaseCacheConfigurationArgs          
- cache_type str
- Type of disk cache.
- db_paths Sequence[str]
- Paths within the database to cache.
KxClusterSavedownStorageConfiguration, KxClusterSavedownStorageConfigurationArgs          
- Size int
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- Type string
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- VolumeName string
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
- Size int
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- Type string
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- VolumeName string
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
- size Integer
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- type String
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- volumeName String
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
- size number
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- type string
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- volumeName string
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
- size int
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- type str
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- volume_name str
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
- size Number
- Size of temporary storage in gigabytes. Must be between 10 and 16000.
- type String
- Type of writeable storage space for temporarily storing your savedown data. The valid values are:- SDS01 - This type represents 3000 IOPS and io2 ebs volume type.
 
- volumeName String
- The name of the kdb volume that you want to use as writeable save-down storage for clusters.
KxClusterScalingGroupConfiguration, KxClusterScalingGroupConfigurationArgs          
- MemoryReservation int
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- NodeCount int
- The number of kdb cluster nodes.
- ScalingGroup stringName 
- A unique identifier for the kdb scaling group.
- Cpu double
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- MemoryLimit int
- An optional hard limit on the amount of memory a kdb cluster can use.
- MemoryReservation int
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- NodeCount int
- The number of kdb cluster nodes.
- ScalingGroup stringName 
- A unique identifier for the kdb scaling group.
- Cpu float64
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- MemoryLimit int
- An optional hard limit on the amount of memory a kdb cluster can use.
- memoryReservation Integer
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- nodeCount Integer
- The number of kdb cluster nodes.
- scalingGroup StringName 
- A unique identifier for the kdb scaling group.
- cpu Double
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- memoryLimit Integer
- An optional hard limit on the amount of memory a kdb cluster can use.
- memoryReservation number
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- nodeCount number
- The number of kdb cluster nodes.
- scalingGroup stringName 
- A unique identifier for the kdb scaling group.
- cpu number
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- memoryLimit number
- An optional hard limit on the amount of memory a kdb cluster can use.
- memory_reservation int
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- node_count int
- The number of kdb cluster nodes.
- scaling_group_ strname 
- A unique identifier for the kdb scaling group.
- cpu float
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- memory_limit int
- An optional hard limit on the amount of memory a kdb cluster can use.
- memoryReservation Number
- A reservation of the minimum amount of memory that should be available on the scaling group for a kdb cluster to be successfully placed in a scaling group.
- nodeCount Number
- The number of kdb cluster nodes.
- scalingGroup StringName 
- A unique identifier for the kdb scaling group.
- cpu Number
- The number of vCPUs that you want to reserve for each node of this kdb cluster on the scaling group host.
- memoryLimit Number
- An optional hard limit on the amount of memory a kdb cluster can use.
KxClusterTickerplantLogConfiguration, KxClusterTickerplantLogConfigurationArgs          
- TickerplantLog List<string>Volumes 
- TickerplantLog []stringVolumes 
- tickerplantLog List<String>Volumes 
- tickerplantLog string[]Volumes 
- tickerplant_log_ Sequence[str]volumes 
- tickerplantLog List<String>Volumes 
KxClusterVpcConfiguration, KxClusterVpcConfigurationArgs        
- IpAddress stringType 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- SecurityGroup List<string>Ids 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- SubnetIds List<string>
- VpcId string
- Identifier of the VPC endpoint
- IpAddress stringType 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- SecurityGroup []stringIds 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- SubnetIds []string
- VpcId string
- Identifier of the VPC endpoint
- ipAddress StringType 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- securityGroup List<String>Ids 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- subnetIds List<String>
- vpcId String
- Identifier of the VPC endpoint
- ipAddress stringType 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- securityGroup string[]Ids 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- subnetIds string[]
- vpcId string
- Identifier of the VPC endpoint
- ip_address_ strtype 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- security_group_ Sequence[str]ids 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- subnet_ids Sequence[str]
- vpc_id str
- Identifier of the VPC endpoint
- ipAddress StringType 
- IP address type for cluster network configuration parameters. The following type is available: IP_V4 - IP address version 4.
- securityGroup List<String>Ids 
- Unique identifier of the VPC security group applied to the VPC endpoint ENI for the cluster.- subnet_ids- (Required) Identifier of the subnet that the Privatelink VPC endpoint uses to connect to the cluster.
 
- subnetIds List<String>
- vpcId String
- Identifier of the VPC endpoint
Import
Using pulumi import, import an AWS FinSpace Kx Cluster using the id (environment ID and cluster name, comma-delimited). For example:
$ pulumi import aws:finspace/kxCluster:KxCluster example n3ceo7wqxoxcti5tujqwzs,my-tf-kx-cluster
To learn more about importing existing cloud resources, see Importing resources.
Package Details
- Repository
- AWS Classic pulumi/pulumi-aws
- License
- Apache-2.0
- Notes
- This Pulumi package is based on the awsTerraform Provider.