import * as pulumi from "@pulumi/pulumi"; /** * Manages a cluster's (persistent) settings. * * ## Example Usage * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as opensearch from "@piclemx/pulumi-opensearch"; * * const global = new opensearch.ClusterSettings("global", { * actionAutoCreateIndex: "my-index-000001,index10,-index1*,+ind*", * clusterMaxShardsPerNode: 10, * }); * ``` */ export declare class ClusterSettings extends pulumi.CustomResource { /** * Get an existing ClusterSettings resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param state Any extra arguments used during the lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input, state?: ClusterSettingsState, opts?: pulumi.CustomResourceOptions): ClusterSettings; /** * Returns true if the given object is an instance of ClusterSettings. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is ClusterSettings; /** * Whether to automatically create an index if it doesn’t already exist and apply any configured index template */ readonly actionAutoCreateIndex: pulumi.Output; /** * When set to true, you must specify the index name to delete an index and it is not possible to delete all indices with _all or use wildcards */ readonly actionDestructiveRequiresName: pulumi.Output; /** * Make the whole cluster read only and metadata is not allowed to be modified */ readonly clusterBlocksReadOnly: pulumi.Output; /** * Make the whole cluster read only, but allows to delete indices to free up resources */ readonly clusterBlocksReadOnlyAllowDelete: pulumi.Output; /** * If false, you cannot close open indices */ readonly clusterIndicesCloseEnable: pulumi.Output; /** * A time string controlling how often OpenSearch should check on disk usage for each node in the cluster */ readonly clusterInfoUpdateInterval: pulumi.Output; /** * The total number of primary and replica shards for the cluster, this number is multiplied by the number of non-frozen data nodes; shards for closed indices do not count toward this limit */ readonly clusterMaxShardsPerNode: pulumi.Output; /** * The total number of primary and replica frozen shards, for the cluster; Ssards for closed indices do not count toward this limit, a cluster with no frozen data nodes is unlimited. */ readonly clusterMaxShardsPerNodeFrozen: pulumi.Output; /** * Specifies which operations are rejected when there is no active master in a cluster (all, write) */ readonly clusterNoMasterBlock: pulumi.Output; /** * Whether allocation for persistent tasks is active (all, none) */ readonly clusterPersistentTasksAllocationEnable: pulumi.Output; /** * A time string controling how often assignment checks are performed to react to whether persistent tasks can be assigned to nodes */ readonly clusterPersistentTasksAllocationRecheckInterval: pulumi.Output; /** * Specify when shard rebalancing is allowed (always, indices*primaries*active, indices*all*active) */ readonly clusterRoutingAllocationAllowRebalance: pulumi.Output; /** * Use custom node attributes to take hardware configuration into account when allocating shards */ readonly clusterRoutingAllocationAwarenessAttributes: pulumi.Output; /** * Weight factor for the number of shards per index allocated on a node, increasing this raises the tendency to equalize the number of shards per index across all nodes */ readonly clusterRoutingAllocationBalanceIndex: pulumi.Output; /** * Weight factor for the total number of shards allocated on a node, increasing this raises the tendency to equalize the number of shards across all nodes */ readonly clusterRoutingAllocationBalanceShard: pulumi.Output; /** * Minimal optimization value of operations that should be performed, raising this will cause the cluster to be less aggressive about optimizing the shard balance */ readonly clusterRoutingAllocationBalanceThreshold: pulumi.Output; /** * How many concurrent shard rebalances are allowed cluster wide */ readonly clusterRoutingAllocationClusterConcurrentRebalance: pulumi.Output; /** * Whether the allocator will take into account shards that are currently being relocated to the target node when computing a node’s disk usage */ readonly clusterRoutingAllocationDiskIncludeRelocations: pulumi.Output; /** * Whether the disk allocation decider is active */ readonly clusterRoutingAllocationDiskThresholdEnabled: pulumi.Output; /** * Allocator will attempt to relocate shards away from a node whose disk usage is above this percentage disk used */ readonly clusterRoutingAllocationDiskWatermarkHigh: pulumi.Output; /** * Allocator will not allocate shards to nodes that have more than this percentage disk used */ readonly clusterRoutingAllocationDiskWatermarkLow: pulumi.Output; /** * Enable or disable allocation for specific kinds of shards (all, primaries, new_primaries, none) */ readonly clusterRoutingAllocationEnable: pulumi.Output; /** * How many incoming recoveries where the target shard (likely the replica unless a shard is relocating) are allocated on the node */ readonly clusterRoutingAllocationNodeConcurrentIncomingRecoveries: pulumi.Output; /** * How many outgoing recoveries where the source shard (likely the primary unless a shard is relocating) are allocated on the node */ readonly clusterRoutingAllocationNodeConcurrentOutgoingRecoveries: pulumi.Output; /** * A shortcut to set both incoming and outgoing recoveries */ readonly clusterRoutingAllocationNodeConcurrentRecoveries: pulumi.Output; /** * Set a (usually) higher rate for primary recovery on node restart (usually from disk, so fast) */ readonly clusterRoutingAllocationNodeInitialPrimariesRecoveries: pulumi.Output; /** * Perform a check to prevent allocation of multiple instances of the same shard on a single host, if multiple nodes are started on the host */ readonly clusterRoutingAllocationSameShardHost: pulumi.Output; /** * Maximum number of primary and replica shards allocated to each node */ readonly clusterRoutingAllocationTotalShardsPerNode: pulumi.Output; /** * Allow rebalancing for specific kinds of shards (all, primaries, replicas, none) */ readonly clusterRoutingRebalanceEnable: pulumi.Output; /** * The percentage of memory above which if loading a field into the field data cache would cause the cache to exceed this limit, an error is returned */ readonly indicesBreakerFielddataLimit: pulumi.Output; /** * A constant that all field data estimations are multiplied by */ readonly indicesBreakerFielddataOverhead: pulumi.Output; /** * The percentabge of memory above which per-request data structures (e.g. calculating aggregations) are prevented from exceeding */ readonly indicesBreakerRequestLimit: pulumi.Output; /** * A constant that all request estimations are multiplied by */ readonly indicesBreakerRequestOverhead: pulumi.Output; /** * The percentage of total amount of memory that can be used across all breakers */ readonly indicesBreakerTotalLimit: pulumi.Output; /** * Maximum total inbound and outbound recovery traffic for each node, in mb */ readonly indicesRecoveryMaxBytesPerSec: pulumi.Output; /** * The percentage limit of memory usage on a node of all currently active incoming requests on transport or HTTP level */ readonly networkBreakerInflightRequestsLimit: pulumi.Output; /** * A constant that all in flight requests estimations are multiplied by */ readonly networkBreakerInflightRequestsOverhead: pulumi.Output; /** * Limit for the number of unique dynamic scripts within a certain interval that are allowed to be compiled, expressed as compilations divided by a time string */ readonly scriptMaxCompilationsRate: pulumi.Output; /** * A time string setting a cluster-wide default timeout for all search requests */ readonly searchDefaultSearchTimeout: pulumi.Output; /** * Create a ClusterSettings resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ constructor(name: string, args?: ClusterSettingsArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering ClusterSettings resources. */ export interface ClusterSettingsState { /** * Whether to automatically create an index if it doesn’t already exist and apply any configured index template */ actionAutoCreateIndex?: pulumi.Input; /** * When set to true, you must specify the index name to delete an index and it is not possible to delete all indices with _all or use wildcards */ actionDestructiveRequiresName?: pulumi.Input; /** * Make the whole cluster read only and metadata is not allowed to be modified */ clusterBlocksReadOnly?: pulumi.Input; /** * Make the whole cluster read only, but allows to delete indices to free up resources */ clusterBlocksReadOnlyAllowDelete?: pulumi.Input; /** * If false, you cannot close open indices */ clusterIndicesCloseEnable?: pulumi.Input; /** * A time string controlling how often OpenSearch should check on disk usage for each node in the cluster */ clusterInfoUpdateInterval?: pulumi.Input; /** * The total number of primary and replica shards for the cluster, this number is multiplied by the number of non-frozen data nodes; shards for closed indices do not count toward this limit */ clusterMaxShardsPerNode?: pulumi.Input; /** * The total number of primary and replica frozen shards, for the cluster; Ssards for closed indices do not count toward this limit, a cluster with no frozen data nodes is unlimited. */ clusterMaxShardsPerNodeFrozen?: pulumi.Input; /** * Specifies which operations are rejected when there is no active master in a cluster (all, write) */ clusterNoMasterBlock?: pulumi.Input; /** * Whether allocation for persistent tasks is active (all, none) */ clusterPersistentTasksAllocationEnable?: pulumi.Input; /** * A time string controling how often assignment checks are performed to react to whether persistent tasks can be assigned to nodes */ clusterPersistentTasksAllocationRecheckInterval?: pulumi.Input; /** * Specify when shard rebalancing is allowed (always, indices*primaries*active, indices*all*active) */ clusterRoutingAllocationAllowRebalance?: pulumi.Input; /** * Use custom node attributes to take hardware configuration into account when allocating shards */ clusterRoutingAllocationAwarenessAttributes?: pulumi.Input; /** * Weight factor for the number of shards per index allocated on a node, increasing this raises the tendency to equalize the number of shards per index across all nodes */ clusterRoutingAllocationBalanceIndex?: pulumi.Input; /** * Weight factor for the total number of shards allocated on a node, increasing this raises the tendency to equalize the number of shards across all nodes */ clusterRoutingAllocationBalanceShard?: pulumi.Input; /** * Minimal optimization value of operations that should be performed, raising this will cause the cluster to be less aggressive about optimizing the shard balance */ clusterRoutingAllocationBalanceThreshold?: pulumi.Input; /** * How many concurrent shard rebalances are allowed cluster wide */ clusterRoutingAllocationClusterConcurrentRebalance?: pulumi.Input; /** * Whether the allocator will take into account shards that are currently being relocated to the target node when computing a node’s disk usage */ clusterRoutingAllocationDiskIncludeRelocations?: pulumi.Input; /** * Whether the disk allocation decider is active */ clusterRoutingAllocationDiskThresholdEnabled?: pulumi.Input; /** * Allocator will attempt to relocate shards away from a node whose disk usage is above this percentage disk used */ clusterRoutingAllocationDiskWatermarkHigh?: pulumi.Input; /** * Allocator will not allocate shards to nodes that have more than this percentage disk used */ clusterRoutingAllocationDiskWatermarkLow?: pulumi.Input; /** * Enable or disable allocation for specific kinds of shards (all, primaries, new_primaries, none) */ clusterRoutingAllocationEnable?: pulumi.Input; /** * How many incoming recoveries where the target shard (likely the replica unless a shard is relocating) are allocated on the node */ clusterRoutingAllocationNodeConcurrentIncomingRecoveries?: pulumi.Input; /** * How many outgoing recoveries where the source shard (likely the primary unless a shard is relocating) are allocated on the node */ clusterRoutingAllocationNodeConcurrentOutgoingRecoveries?: pulumi.Input; /** * A shortcut to set both incoming and outgoing recoveries */ clusterRoutingAllocationNodeConcurrentRecoveries?: pulumi.Input; /** * Set a (usually) higher rate for primary recovery on node restart (usually from disk, so fast) */ clusterRoutingAllocationNodeInitialPrimariesRecoveries?: pulumi.Input; /** * Perform a check to prevent allocation of multiple instances of the same shard on a single host, if multiple nodes are started on the host */ clusterRoutingAllocationSameShardHost?: pulumi.Input; /** * Maximum number of primary and replica shards allocated to each node */ clusterRoutingAllocationTotalShardsPerNode?: pulumi.Input; /** * Allow rebalancing for specific kinds of shards (all, primaries, replicas, none) */ clusterRoutingRebalanceEnable?: pulumi.Input; /** * The percentage of memory above which if loading a field into the field data cache would cause the cache to exceed this limit, an error is returned */ indicesBreakerFielddataLimit?: pulumi.Input; /** * A constant that all field data estimations are multiplied by */ indicesBreakerFielddataOverhead?: pulumi.Input; /** * The percentabge of memory above which per-request data structures (e.g. calculating aggregations) are prevented from exceeding */ indicesBreakerRequestLimit?: pulumi.Input; /** * A constant that all request estimations are multiplied by */ indicesBreakerRequestOverhead?: pulumi.Input; /** * The percentage of total amount of memory that can be used across all breakers */ indicesBreakerTotalLimit?: pulumi.Input; /** * Maximum total inbound and outbound recovery traffic for each node, in mb */ indicesRecoveryMaxBytesPerSec?: pulumi.Input; /** * The percentage limit of memory usage on a node of all currently active incoming requests on transport or HTTP level */ networkBreakerInflightRequestsLimit?: pulumi.Input; /** * A constant that all in flight requests estimations are multiplied by */ networkBreakerInflightRequestsOverhead?: pulumi.Input; /** * Limit for the number of unique dynamic scripts within a certain interval that are allowed to be compiled, expressed as compilations divided by a time string */ scriptMaxCompilationsRate?: pulumi.Input; /** * A time string setting a cluster-wide default timeout for all search requests */ searchDefaultSearchTimeout?: pulumi.Input; } /** * The set of arguments for constructing a ClusterSettings resource. */ export interface ClusterSettingsArgs { /** * Whether to automatically create an index if it doesn’t already exist and apply any configured index template */ actionAutoCreateIndex?: pulumi.Input; /** * When set to true, you must specify the index name to delete an index and it is not possible to delete all indices with _all or use wildcards */ actionDestructiveRequiresName?: pulumi.Input; /** * Make the whole cluster read only and metadata is not allowed to be modified */ clusterBlocksReadOnly?: pulumi.Input; /** * Make the whole cluster read only, but allows to delete indices to free up resources */ clusterBlocksReadOnlyAllowDelete?: pulumi.Input; /** * If false, you cannot close open indices */ clusterIndicesCloseEnable?: pulumi.Input; /** * A time string controlling how often OpenSearch should check on disk usage for each node in the cluster */ clusterInfoUpdateInterval?: pulumi.Input; /** * The total number of primary and replica shards for the cluster, this number is multiplied by the number of non-frozen data nodes; shards for closed indices do not count toward this limit */ clusterMaxShardsPerNode?: pulumi.Input; /** * The total number of primary and replica frozen shards, for the cluster; Ssards for closed indices do not count toward this limit, a cluster with no frozen data nodes is unlimited. */ clusterMaxShardsPerNodeFrozen?: pulumi.Input; /** * Specifies which operations are rejected when there is no active master in a cluster (all, write) */ clusterNoMasterBlock?: pulumi.Input; /** * Whether allocation for persistent tasks is active (all, none) */ clusterPersistentTasksAllocationEnable?: pulumi.Input; /** * A time string controling how often assignment checks are performed to react to whether persistent tasks can be assigned to nodes */ clusterPersistentTasksAllocationRecheckInterval?: pulumi.Input; /** * Specify when shard rebalancing is allowed (always, indices*primaries*active, indices*all*active) */ clusterRoutingAllocationAllowRebalance?: pulumi.Input; /** * Use custom node attributes to take hardware configuration into account when allocating shards */ clusterRoutingAllocationAwarenessAttributes?: pulumi.Input; /** * Weight factor for the number of shards per index allocated on a node, increasing this raises the tendency to equalize the number of shards per index across all nodes */ clusterRoutingAllocationBalanceIndex?: pulumi.Input; /** * Weight factor for the total number of shards allocated on a node, increasing this raises the tendency to equalize the number of shards across all nodes */ clusterRoutingAllocationBalanceShard?: pulumi.Input; /** * Minimal optimization value of operations that should be performed, raising this will cause the cluster to be less aggressive about optimizing the shard balance */ clusterRoutingAllocationBalanceThreshold?: pulumi.Input; /** * How many concurrent shard rebalances are allowed cluster wide */ clusterRoutingAllocationClusterConcurrentRebalance?: pulumi.Input; /** * Whether the allocator will take into account shards that are currently being relocated to the target node when computing a node’s disk usage */ clusterRoutingAllocationDiskIncludeRelocations?: pulumi.Input; /** * Whether the disk allocation decider is active */ clusterRoutingAllocationDiskThresholdEnabled?: pulumi.Input; /** * Allocator will attempt to relocate shards away from a node whose disk usage is above this percentage disk used */ clusterRoutingAllocationDiskWatermarkHigh?: pulumi.Input; /** * Allocator will not allocate shards to nodes that have more than this percentage disk used */ clusterRoutingAllocationDiskWatermarkLow?: pulumi.Input; /** * Enable or disable allocation for specific kinds of shards (all, primaries, new_primaries, none) */ clusterRoutingAllocationEnable?: pulumi.Input; /** * How many incoming recoveries where the target shard (likely the replica unless a shard is relocating) are allocated on the node */ clusterRoutingAllocationNodeConcurrentIncomingRecoveries?: pulumi.Input; /** * How many outgoing recoveries where the source shard (likely the primary unless a shard is relocating) are allocated on the node */ clusterRoutingAllocationNodeConcurrentOutgoingRecoveries?: pulumi.Input; /** * A shortcut to set both incoming and outgoing recoveries */ clusterRoutingAllocationNodeConcurrentRecoveries?: pulumi.Input; /** * Set a (usually) higher rate for primary recovery on node restart (usually from disk, so fast) */ clusterRoutingAllocationNodeInitialPrimariesRecoveries?: pulumi.Input; /** * Perform a check to prevent allocation of multiple instances of the same shard on a single host, if multiple nodes are started on the host */ clusterRoutingAllocationSameShardHost?: pulumi.Input; /** * Maximum number of primary and replica shards allocated to each node */ clusterRoutingAllocationTotalShardsPerNode?: pulumi.Input; /** * Allow rebalancing for specific kinds of shards (all, primaries, replicas, none) */ clusterRoutingRebalanceEnable?: pulumi.Input; /** * The percentage of memory above which if loading a field into the field data cache would cause the cache to exceed this limit, an error is returned */ indicesBreakerFielddataLimit?: pulumi.Input; /** * A constant that all field data estimations are multiplied by */ indicesBreakerFielddataOverhead?: pulumi.Input; /** * The percentabge of memory above which per-request data structures (e.g. calculating aggregations) are prevented from exceeding */ indicesBreakerRequestLimit?: pulumi.Input; /** * A constant that all request estimations are multiplied by */ indicesBreakerRequestOverhead?: pulumi.Input; /** * The percentage of total amount of memory that can be used across all breakers */ indicesBreakerTotalLimit?: pulumi.Input; /** * Maximum total inbound and outbound recovery traffic for each node, in mb */ indicesRecoveryMaxBytesPerSec?: pulumi.Input; /** * The percentage limit of memory usage on a node of all currently active incoming requests on transport or HTTP level */ networkBreakerInflightRequestsLimit?: pulumi.Input; /** * A constant that all in flight requests estimations are multiplied by */ networkBreakerInflightRequestsOverhead?: pulumi.Input; /** * Limit for the number of unique dynamic scripts within a certain interval that are allowed to be compiled, expressed as compilations divided by a time string */ scriptMaxCompilationsRate?: pulumi.Input; /** * A time string setting a cluster-wide default timeout for all search requests */ searchDefaultSearchTimeout?: pulumi.Input; }