import * as pulumi from "@pulumi/pulumi"; /** * Provides a virtual resource that can be used to change advanced configuration * options for a DigitalOcean managed Opensearch database cluster. * * > **Note** Opensearch configurations are only removed from state when destroyed. The remote configuration is not unset. * * ## Example Usage * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as digitalocean from "@pulumi/digitalocean"; * * const exampleDatabaseCluster = new digitalocean.DatabaseCluster("example", { * name: "example-opensearch-cluster", * engine: "opensearch", * version: "2", * size: digitalocean.DatabaseSlug.DB_1VPCU2GB, * region: digitalocean.Region.NYC3, * nodeCount: 1, * }); * const example = new digitalocean.DatabaseOpensearchConfig("example", { * clusterId: exampleDatabaseCluster.id, * ismEnabled: true, * ismHistoryEnabled: true, * ismHistoryMaxAgeHours: 24, * ismHistoryMaxDocs: 2500000, * ismHistoryRolloverCheckPeriodHours: 8, * ismHistoryRolloverRetentionPeriodDays: 30, * httpMaxContentLengthBytes: 100000000, * httpMaxHeaderSizeBytes: 8192, * httpMaxInitialLineLengthBytes: 4096, * indicesQueryBoolMaxClauseCount: 1024, * searchMaxBuckets: 10000, * indicesFielddataCacheSizePercentage: 3, * indicesMemoryIndexBufferSizePercentage: 10, * indicesMemoryMinIndexBufferSizeMb: 48, * indicesMemoryMaxIndexBufferSizeMb: 3, * indicesQueriesCacheSizePercentage: 10, * indicesRecoveryMaxMbPerSec: 40, * indicesRecoveryMaxConcurrentFileChunks: 2, * actionAutoCreateIndexEnabled: true, * actionDestructiveRequiresName: false, * enableSecurityAudit: false, * threadPoolSearchSize: 1, * threadPoolSearchThrottledSize: 1, * threadPoolSearchThrottledQueueSize: 10, * threadPoolSearchQueueSize: 10, * threadPoolGetSize: 1, * threadPoolGetQueueSize: 10, * threadPoolAnalyzeSize: 1, * threadPoolAnalyzeQueueSize: 10, * threadPoolWriteSize: 1, * threadPoolWriteQueueSize: 10, * threadPoolForceMergeSize: 1, * overrideMainResponseVersion: false, * scriptMaxCompilationsRate: "use-context", * clusterMaxShardsPerNode: 100, * clusterRoutingAllocationNodeConcurrentRecoveries: 2, * pluginsAlertingFilterByBackendRolesEnabled: false, * reindexRemoteWhitelists: ["cloud.digitalocean.com:8080"], * }); * ``` * * ## Import * * A Opensearch database cluster's configuration can be imported using the `id` the parent cluster, e.g. * * ```sh * $ pulumi import digitalocean:index/databaseOpensearchConfig:DatabaseOpensearchConfig example 4b62829a-9c42-465b-aaa3-84051048e712 * ``` */ export declare class DatabaseOpensearchConfig extends pulumi.CustomResource { /** * Get an existing DatabaseOpensearchConfig 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?: DatabaseOpensearchConfigState, opts?: pulumi.CustomResourceOptions): DatabaseOpensearchConfig; /** * Returns true if the given object is an instance of DatabaseOpensearchConfig. 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 DatabaseOpensearchConfig; /** * Specifices whether to allow automatic creation of indices. Default: `true` */ readonly actionAutoCreateIndexEnabled: pulumi.Output; /** * Specifies whether to require explicit index names when deleting indices. */ readonly actionDestructiveRequiresName: pulumi.Output; /** * The ID of the target Opensearch cluster. */ readonly clusterId: pulumi.Output; /** * Maximum number of shards allowed per data node. */ readonly clusterMaxShardsPerNode: pulumi.Output; /** * Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2` */ readonly clusterRoutingAllocationNodeConcurrentRecoveries: pulumi.Output; /** * Specifies whether to allow security audit logging. Default: `false` */ readonly enableSecurityAudit: pulumi.Output; /** * Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000` */ readonly httpMaxContentLengthBytes: pulumi.Output; /** * Maximum size of allowed headers, in bytes. Default: `8192` */ readonly httpMaxHeaderSizeBytes: pulumi.Output; /** * Maximum length of an HTTP URL, in bytes. Default: `4096` */ readonly httpMaxInitialLineLengthBytes: pulumi.Output; /** * Maximum amount of heap memory used for field data cache, expressed as a percentage. Decreasing the value too much will increase overhead of loading field data. Increasing the value too much will decrease amount of heap available for other operations. */ readonly indicesFielddataCacheSizePercentage: pulumi.Output; /** * Total amount of heap used for indexing buffer before writing segments to disk, expressed as a percentage. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance. Default: `10` */ readonly indicesMemoryIndexBufferSizePercentage: pulumi.Output; /** * Maximum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. The default is unbounded. */ readonly indicesMemoryMaxIndexBufferSizeMb: pulumi.Output; /** * Minimum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. Default: `48` */ readonly indicesMemoryMinIndexBufferSizeMb: pulumi.Output; /** * Maximum amount of heap used for query cache. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other functionality. Default: `10` */ readonly indicesQueriesCacheSizePercentage: pulumi.Output; /** * Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024` */ readonly indicesQueryBoolMaxClauseCount: pulumi.Output; /** * Maximum number of file chunks sent in parallel for each recovery. Default: `2` */ readonly indicesRecoveryMaxConcurrentFileChunks: pulumi.Output; /** * Limits total inbound and outbound recovery traffic for each node, expressed in mb per second. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Default: `40` */ readonly indicesRecoveryMaxMbPerSec: pulumi.Output; /** * Specifies whether ISM is enabled or not. Default: `true` */ readonly ismEnabled: pulumi.Output; /** * Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true` */ readonly ismHistoryEnabled: pulumi.Output; /** * Maximum age before rolling over the audit history index, in hours. Default: `24` */ readonly ismHistoryMaxAgeHours: pulumi.Output; /** * Maximum number of documents before rolling over the audit history index. Default: `2500000` */ readonly ismHistoryMaxDocs: pulumi.Output; /** * The time between rollover checks for the audit history index, in hours. Default: `8` */ readonly ismHistoryRolloverCheckPeriodHours: pulumi.Output; /** * Length of time long audit history indices are kept, in days. Default: `30` */ readonly ismHistoryRolloverRetentionPeriodDays: pulumi.Output; /** * Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false` */ readonly overrideMainResponseVersion: pulumi.Output; /** * Enable or disable filtering of alerting by backend roles. Default: `false` */ readonly pluginsAlertingFilterByBackendRolesEnabled: pulumi.Output; /** * Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart. */ readonly reindexRemoteWhitelists: pulumi.Output; /** * Limits the number of inline script compilations within a period of time. Default is `use-context` */ readonly scriptMaxCompilationsRate: pulumi.Output; /** * Maximum number of aggregation buckets allowed in a single response. Default: `10000` */ readonly searchMaxBuckets: pulumi.Output; /** * Size of queue for operations in the analyze thread pool. */ readonly threadPoolAnalyzeQueueSize: pulumi.Output; /** * Number of workers in the analyze operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolAnalyzeSize: pulumi.Output; /** * Number of workers in the force merge operation thread pool. This pool is used for forcing a merge between shards of one or more indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolForceMergeSize: pulumi.Output; /** * Size of queue for operations in the get thread pool. */ readonly threadPoolGetQueueSize: pulumi.Output; /** * Number of workers in the get operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolGetSize: pulumi.Output; /** * Size of queue for operations in the search thread pool. */ readonly threadPoolSearchQueueSize: pulumi.Output; /** * Number of workers in the search operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolSearchSize: pulumi.Output; /** * Size of queue for operations in the search throttled thread pool. */ readonly threadPoolSearchThrottledQueueSize: pulumi.Output; /** * Number of workers in the search throttled operation thread pool. This pool is used for searching frozen indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolSearchThrottledSize: pulumi.Output; /** * Size of queue for operations in the write thread pool. */ readonly threadPoolWriteQueueSize: pulumi.Output; /** * Number of workers in the write operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ readonly threadPoolWriteSize: pulumi.Output; /** * Create a DatabaseOpensearchConfig 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: DatabaseOpensearchConfigArgs, opts?: pulumi.CustomResourceOptions); } /** * Input properties used for looking up and filtering DatabaseOpensearchConfig resources. */ export interface DatabaseOpensearchConfigState { /** * Specifices whether to allow automatic creation of indices. Default: `true` */ actionAutoCreateIndexEnabled?: pulumi.Input; /** * Specifies whether to require explicit index names when deleting indices. */ actionDestructiveRequiresName?: pulumi.Input; /** * The ID of the target Opensearch cluster. */ clusterId?: pulumi.Input; /** * Maximum number of shards allowed per data node. */ clusterMaxShardsPerNode?: pulumi.Input; /** * Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2` */ clusterRoutingAllocationNodeConcurrentRecoveries?: pulumi.Input; /** * Specifies whether to allow security audit logging. Default: `false` */ enableSecurityAudit?: pulumi.Input; /** * Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000` */ httpMaxContentLengthBytes?: pulumi.Input; /** * Maximum size of allowed headers, in bytes. Default: `8192` */ httpMaxHeaderSizeBytes?: pulumi.Input; /** * Maximum length of an HTTP URL, in bytes. Default: `4096` */ httpMaxInitialLineLengthBytes?: pulumi.Input; /** * Maximum amount of heap memory used for field data cache, expressed as a percentage. Decreasing the value too much will increase overhead of loading field data. Increasing the value too much will decrease amount of heap available for other operations. */ indicesFielddataCacheSizePercentage?: pulumi.Input; /** * Total amount of heap used for indexing buffer before writing segments to disk, expressed as a percentage. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance. Default: `10` */ indicesMemoryIndexBufferSizePercentage?: pulumi.Input; /** * Maximum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. The default is unbounded. */ indicesMemoryMaxIndexBufferSizeMb?: pulumi.Input; /** * Minimum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. Default: `48` */ indicesMemoryMinIndexBufferSizeMb?: pulumi.Input; /** * Maximum amount of heap used for query cache. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other functionality. Default: `10` */ indicesQueriesCacheSizePercentage?: pulumi.Input; /** * Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024` */ indicesQueryBoolMaxClauseCount?: pulumi.Input; /** * Maximum number of file chunks sent in parallel for each recovery. Default: `2` */ indicesRecoveryMaxConcurrentFileChunks?: pulumi.Input; /** * Limits total inbound and outbound recovery traffic for each node, expressed in mb per second. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Default: `40` */ indicesRecoveryMaxMbPerSec?: pulumi.Input; /** * Specifies whether ISM is enabled or not. Default: `true` */ ismEnabled?: pulumi.Input; /** * Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true` */ ismHistoryEnabled?: pulumi.Input; /** * Maximum age before rolling over the audit history index, in hours. Default: `24` */ ismHistoryMaxAgeHours?: pulumi.Input; /** * Maximum number of documents before rolling over the audit history index. Default: `2500000` */ ismHistoryMaxDocs?: pulumi.Input; /** * The time between rollover checks for the audit history index, in hours. Default: `8` */ ismHistoryRolloverCheckPeriodHours?: pulumi.Input; /** * Length of time long audit history indices are kept, in days. Default: `30` */ ismHistoryRolloverRetentionPeriodDays?: pulumi.Input; /** * Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false` */ overrideMainResponseVersion?: pulumi.Input; /** * Enable or disable filtering of alerting by backend roles. Default: `false` */ pluginsAlertingFilterByBackendRolesEnabled?: pulumi.Input; /** * Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart. */ reindexRemoteWhitelists?: pulumi.Input[]>; /** * Limits the number of inline script compilations within a period of time. Default is `use-context` */ scriptMaxCompilationsRate?: pulumi.Input; /** * Maximum number of aggregation buckets allowed in a single response. Default: `10000` */ searchMaxBuckets?: pulumi.Input; /** * Size of queue for operations in the analyze thread pool. */ threadPoolAnalyzeQueueSize?: pulumi.Input; /** * Number of workers in the analyze operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolAnalyzeSize?: pulumi.Input; /** * Number of workers in the force merge operation thread pool. This pool is used for forcing a merge between shards of one or more indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolForceMergeSize?: pulumi.Input; /** * Size of queue for operations in the get thread pool. */ threadPoolGetQueueSize?: pulumi.Input; /** * Number of workers in the get operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolGetSize?: pulumi.Input; /** * Size of queue for operations in the search thread pool. */ threadPoolSearchQueueSize?: pulumi.Input; /** * Number of workers in the search operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolSearchSize?: pulumi.Input; /** * Size of queue for operations in the search throttled thread pool. */ threadPoolSearchThrottledQueueSize?: pulumi.Input; /** * Number of workers in the search throttled operation thread pool. This pool is used for searching frozen indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolSearchThrottledSize?: pulumi.Input; /** * Size of queue for operations in the write thread pool. */ threadPoolWriteQueueSize?: pulumi.Input; /** * Number of workers in the write operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolWriteSize?: pulumi.Input; } /** * The set of arguments for constructing a DatabaseOpensearchConfig resource. */ export interface DatabaseOpensearchConfigArgs { /** * Specifices whether to allow automatic creation of indices. Default: `true` */ actionAutoCreateIndexEnabled?: pulumi.Input; /** * Specifies whether to require explicit index names when deleting indices. */ actionDestructiveRequiresName?: pulumi.Input; /** * The ID of the target Opensearch cluster. */ clusterId: pulumi.Input; /** * Maximum number of shards allowed per data node. */ clusterMaxShardsPerNode?: pulumi.Input; /** * Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2` */ clusterRoutingAllocationNodeConcurrentRecoveries?: pulumi.Input; /** * Specifies whether to allow security audit logging. Default: `false` */ enableSecurityAudit?: pulumi.Input; /** * Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000` */ httpMaxContentLengthBytes?: pulumi.Input; /** * Maximum size of allowed headers, in bytes. Default: `8192` */ httpMaxHeaderSizeBytes?: pulumi.Input; /** * Maximum length of an HTTP URL, in bytes. Default: `4096` */ httpMaxInitialLineLengthBytes?: pulumi.Input; /** * Maximum amount of heap memory used for field data cache, expressed as a percentage. Decreasing the value too much will increase overhead of loading field data. Increasing the value too much will decrease amount of heap available for other operations. */ indicesFielddataCacheSizePercentage?: pulumi.Input; /** * Total amount of heap used for indexing buffer before writing segments to disk, expressed as a percentage. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance. Default: `10` */ indicesMemoryIndexBufferSizePercentage?: pulumi.Input; /** * Maximum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. The default is unbounded. */ indicesMemoryMaxIndexBufferSizeMb?: pulumi.Input; /** * Minimum amount of heap used for indexing buffer before writing segments to disk, in mb. Works in conjunction with indices_memory_index_buffer_size_percentage, each being enforced. Default: `48` */ indicesMemoryMinIndexBufferSizeMb?: pulumi.Input; /** * Maximum amount of heap used for query cache. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other functionality. Default: `10` */ indicesQueriesCacheSizePercentage?: pulumi.Input; /** * Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024` */ indicesQueryBoolMaxClauseCount?: pulumi.Input; /** * Maximum number of file chunks sent in parallel for each recovery. Default: `2` */ indicesRecoveryMaxConcurrentFileChunks?: pulumi.Input; /** * Limits total inbound and outbound recovery traffic for each node, expressed in mb per second. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Default: `40` */ indicesRecoveryMaxMbPerSec?: pulumi.Input; /** * Specifies whether ISM is enabled or not. Default: `true` */ ismEnabled?: pulumi.Input; /** * Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true` */ ismHistoryEnabled?: pulumi.Input; /** * Maximum age before rolling over the audit history index, in hours. Default: `24` */ ismHistoryMaxAgeHours?: pulumi.Input; /** * Maximum number of documents before rolling over the audit history index. Default: `2500000` */ ismHistoryMaxDocs?: pulumi.Input; /** * The time between rollover checks for the audit history index, in hours. Default: `8` */ ismHistoryRolloverCheckPeriodHours?: pulumi.Input; /** * Length of time long audit history indices are kept, in days. Default: `30` */ ismHistoryRolloverRetentionPeriodDays?: pulumi.Input; /** * Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false` */ overrideMainResponseVersion?: pulumi.Input; /** * Enable or disable filtering of alerting by backend roles. Default: `false` */ pluginsAlertingFilterByBackendRolesEnabled?: pulumi.Input; /** * Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart. */ reindexRemoteWhitelists?: pulumi.Input[]>; /** * Limits the number of inline script compilations within a period of time. Default is `use-context` */ scriptMaxCompilationsRate?: pulumi.Input; /** * Maximum number of aggregation buckets allowed in a single response. Default: `10000` */ searchMaxBuckets?: pulumi.Input; /** * Size of queue for operations in the analyze thread pool. */ threadPoolAnalyzeQueueSize?: pulumi.Input; /** * Number of workers in the analyze operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolAnalyzeSize?: pulumi.Input; /** * Number of workers in the force merge operation thread pool. This pool is used for forcing a merge between shards of one or more indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolForceMergeSize?: pulumi.Input; /** * Size of queue for operations in the get thread pool. */ threadPoolGetQueueSize?: pulumi.Input; /** * Number of workers in the get operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolGetSize?: pulumi.Input; /** * Size of queue for operations in the search thread pool. */ threadPoolSearchQueueSize?: pulumi.Input; /** * Number of workers in the search operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolSearchSize?: pulumi.Input; /** * Size of queue for operations in the search throttled thread pool. */ threadPoolSearchThrottledQueueSize?: pulumi.Input; /** * Number of workers in the search throttled operation thread pool. This pool is used for searching frozen indices. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolSearchThrottledSize?: pulumi.Input; /** * Size of queue for operations in the write thread pool. */ threadPoolWriteQueueSize?: pulumi.Input; /** * Number of workers in the write operation thread pool. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value. */ threadPoolWriteSize?: pulumi.Input; }