pulumi-digitalocean 4.49.0a1751946418__py3-none-any.whl → 4.50.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-digitalocean might be problematic. Click here for more details.
- pulumi_digitalocean/__init__.py +81 -1
- pulumi_digitalocean/_enums.py +9 -9
- pulumi_digitalocean/_inputs.py +11204 -8486
- pulumi_digitalocean/app.py +137 -88
- pulumi_digitalocean/cdn.py +104 -105
- pulumi_digitalocean/certificate.py +137 -138
- pulumi_digitalocean/config/__init__.py +1 -1
- pulumi_digitalocean/config/__init__.pyi +1 -2
- pulumi_digitalocean/config/vars.py +10 -11
- pulumi_digitalocean/container_registry.py +88 -89
- pulumi_digitalocean/container_registry_docker_credentials.py +70 -71
- pulumi_digitalocean/custom_image.py +175 -176
- pulumi_digitalocean/database_cluster.py +374 -347
- pulumi_digitalocean/database_connection_pool.py +157 -158
- pulumi_digitalocean/database_db.py +35 -36
- pulumi_digitalocean/database_firewall.py +21 -22
- pulumi_digitalocean/database_kafka_config.py +307 -308
- pulumi_digitalocean/database_kafka_topic.py +81 -82
- pulumi_digitalocean/database_mongodb_config.py +103 -104
- pulumi_digitalocean/database_mysql_config.py +477 -478
- pulumi_digitalocean/database_online_migration.py +460 -0
- pulumi_digitalocean/database_opensearch_config.py +664 -665
- pulumi_digitalocean/database_postgresql_config.py +857 -858
- pulumi_digitalocean/database_redis_config.py +209 -206
- pulumi_digitalocean/database_replica.py +197 -198
- pulumi_digitalocean/database_user.py +91 -92
- pulumi_digitalocean/database_valkey_config.py +804 -0
- pulumi_digitalocean/dns_record.py +180 -181
- pulumi_digitalocean/domain.py +53 -54
- pulumi_digitalocean/droplet.py +388 -389
- pulumi_digitalocean/droplet_autoscale.py +53 -54
- pulumi_digitalocean/droplet_snapshot.py +71 -72
- pulumi_digitalocean/firewall.py +78 -79
- pulumi_digitalocean/floating_ip.py +61 -62
- pulumi_digitalocean/floating_ip_assignment.py +35 -36
- pulumi_digitalocean/genai_agent.py +452 -453
- pulumi_digitalocean/genai_agent_knowledge_base_attachment.py +198 -0
- pulumi_digitalocean/genai_agent_route.py +354 -0
- pulumi_digitalocean/genai_function.py +464 -0
- pulumi_digitalocean/genai_knowledge_base.py +627 -0
- pulumi_digitalocean/genai_knowledge_base_data_source.py +220 -0
- pulumi_digitalocean/genai_openai_api_key.py +386 -0
- pulumi_digitalocean/get_account.py +17 -18
- pulumi_digitalocean/get_app.py +27 -28
- pulumi_digitalocean/get_certificate.py +21 -22
- pulumi_digitalocean/get_container_registry.py +21 -22
- pulumi_digitalocean/get_database_ca.py +11 -12
- pulumi_digitalocean/get_database_cluster.py +75 -62
- pulumi_digitalocean/get_database_connection_pool.py +35 -36
- pulumi_digitalocean/get_database_metrics_credentials.py +120 -0
- pulumi_digitalocean/get_database_replica.py +45 -46
- pulumi_digitalocean/get_database_user.py +26 -27
- pulumi_digitalocean/get_domain.py +15 -16
- pulumi_digitalocean/get_domains.py +6 -7
- pulumi_digitalocean/get_droplet.py +71 -72
- pulumi_digitalocean/get_droplet_autoscale.py +22 -23
- pulumi_digitalocean/get_droplet_snapshot.py +37 -38
- pulumi_digitalocean/get_droplets.py +12 -13
- pulumi_digitalocean/get_firewall.py +30 -31
- pulumi_digitalocean/get_floating_ip.py +15 -16
- pulumi_digitalocean/get_genai_agent.py +89 -90
- pulumi_digitalocean/get_genai_agent_versions.py +128 -0
- pulumi_digitalocean/get_genai_agents.py +10 -11
- pulumi_digitalocean/get_genai_agents_by_openai_api_key.py +97 -0
- pulumi_digitalocean/get_genai_knowledge_base.py +259 -0
- pulumi_digitalocean/get_genai_knowledge_base_data_sources.py +97 -0
- pulumi_digitalocean/get_genai_knowledge_bases.py +113 -0
- pulumi_digitalocean/get_genai_openai_api_key.py +152 -0
- pulumi_digitalocean/get_genai_openai_api_keys.py +113 -0
- pulumi_digitalocean/get_image.py +49 -50
- pulumi_digitalocean/get_images.py +6 -7
- pulumi_digitalocean/get_kubernetes_cluster.py +53 -54
- pulumi_digitalocean/get_kubernetes_versions.py +13 -14
- pulumi_digitalocean/get_load_balancer.py +59 -60
- pulumi_digitalocean/get_partner_attachment.py +30 -31
- pulumi_digitalocean/get_partner_attachment_service_key.py +13 -14
- pulumi_digitalocean/get_project.py +31 -32
- pulumi_digitalocean/get_projects.py +6 -7
- pulumi_digitalocean/get_record.py +31 -32
- pulumi_digitalocean/get_records.py +12 -13
- pulumi_digitalocean/get_region.py +17 -18
- pulumi_digitalocean/get_regions.py +6 -7
- pulumi_digitalocean/get_reserved_ip.py +15 -16
- pulumi_digitalocean/get_reserved_ipv6.py +15 -16
- pulumi_digitalocean/get_sizes.py +6 -7
- pulumi_digitalocean/get_spaces_bucket.py +21 -22
- pulumi_digitalocean/get_spaces_bucket_object.py +57 -58
- pulumi_digitalocean/get_spaces_bucket_objects.py +45 -46
- pulumi_digitalocean/get_spaces_buckets.py +6 -7
- pulumi_digitalocean/get_spaces_key.py +14 -15
- pulumi_digitalocean/get_ssh_key.py +13 -14
- pulumi_digitalocean/get_ssh_keys.py +6 -7
- pulumi_digitalocean/get_tag.py +21 -22
- pulumi_digitalocean/get_tags.py +6 -7
- pulumi_digitalocean/get_volume.py +33 -34
- pulumi_digitalocean/get_volume_snapshot.py +39 -40
- pulumi_digitalocean/get_vpc.py +29 -30
- pulumi_digitalocean/get_vpc_nat_gateway.py +33 -34
- pulumi_digitalocean/get_vpc_peering.py +23 -24
- pulumi_digitalocean/kubernetes_cluster.py +293 -294
- pulumi_digitalocean/kubernetes_node_pool.py +168 -169
- pulumi_digitalocean/load_balancer.py +374 -375
- pulumi_digitalocean/monitor_alert.py +149 -150
- pulumi_digitalocean/outputs.py +20079 -12647
- pulumi_digitalocean/partner_attachment.py +150 -151
- pulumi_digitalocean/project.py +139 -140
- pulumi_digitalocean/project_resources.py +35 -36
- pulumi_digitalocean/provider.py +84 -85
- pulumi_digitalocean/pulumi-plugin.json +1 -1
- pulumi_digitalocean/reserved_ip.py +61 -62
- pulumi_digitalocean/reserved_ip_assignment.py +35 -36
- pulumi_digitalocean/reserved_ipv6.py +53 -54
- pulumi_digitalocean/reserved_ipv6_assignment.py +35 -36
- pulumi_digitalocean/spaces_bucket.py +105 -106
- pulumi_digitalocean/spaces_bucket_cors_configuration.py +38 -39
- pulumi_digitalocean/spaces_bucket_logging.py +69 -70
- pulumi_digitalocean/spaces_bucket_object.py +282 -283
- pulumi_digitalocean/spaces_bucket_policy.py +52 -53
- pulumi_digitalocean/spaces_key.py +48 -49
- pulumi_digitalocean/ssh_key.py +44 -45
- pulumi_digitalocean/tag.py +72 -73
- pulumi_digitalocean/uptime_alert.py +106 -107
- pulumi_digitalocean/uptime_check.py +86 -87
- pulumi_digitalocean/volume.py +181 -182
- pulumi_digitalocean/volume_attachment.py +35 -36
- pulumi_digitalocean/volume_snapshot.py +88 -89
- pulumi_digitalocean/vpc.py +96 -97
- pulumi_digitalocean/vpc_nat_gateway.py +152 -153
- pulumi_digitalocean/vpc_peering.py +53 -54
- {pulumi_digitalocean-4.49.0a1751946418.dist-info → pulumi_digitalocean-4.50.0.dist-info}/METADATA +1 -1
- pulumi_digitalocean-4.50.0.dist-info/RECORD +135 -0
- pulumi_digitalocean-4.49.0a1751946418.dist-info/RECORD +0 -119
- {pulumi_digitalocean-4.49.0a1751946418.dist-info → pulumi_digitalocean-4.50.0.dist-info}/WHEEL +0 -0
- {pulumi_digitalocean-4.49.0a1751946418.dist-info → pulumi_digitalocean-4.50.0.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -20,86 +19,86 @@ __all__ = ['DatabaseOpensearchConfigArgs', 'DatabaseOpensearchConfig']
|
|
|
20
19
|
@pulumi.input_type
|
|
21
20
|
class DatabaseOpensearchConfigArgs:
|
|
22
21
|
def __init__(__self__, *,
|
|
23
|
-
cluster_id: pulumi.Input[
|
|
24
|
-
action_auto_create_index_enabled: Optional[pulumi.Input[
|
|
25
|
-
action_destructive_requires_name: Optional[pulumi.Input[
|
|
26
|
-
cluster_max_shards_per_node: Optional[pulumi.Input[
|
|
27
|
-
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[
|
|
28
|
-
enable_security_audit: Optional[pulumi.Input[
|
|
29
|
-
http_max_content_length_bytes: Optional[pulumi.Input[
|
|
30
|
-
http_max_header_size_bytes: Optional[pulumi.Input[
|
|
31
|
-
http_max_initial_line_length_bytes: Optional[pulumi.Input[
|
|
32
|
-
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[
|
|
33
|
-
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[
|
|
34
|
-
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[
|
|
35
|
-
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[
|
|
36
|
-
indices_queries_cache_size_percentage: Optional[pulumi.Input[
|
|
37
|
-
indices_query_bool_max_clause_count: Optional[pulumi.Input[
|
|
38
|
-
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[
|
|
39
|
-
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[
|
|
40
|
-
ism_enabled: Optional[pulumi.Input[
|
|
41
|
-
ism_history_enabled: Optional[pulumi.Input[
|
|
42
|
-
ism_history_max_age_hours: Optional[pulumi.Input[
|
|
43
|
-
ism_history_max_docs: Optional[pulumi.Input[
|
|
44
|
-
ism_history_rollover_check_period_hours: Optional[pulumi.Input[
|
|
45
|
-
ism_history_rollover_retention_period_days: Optional[pulumi.Input[
|
|
46
|
-
override_main_response_version: Optional[pulumi.Input[
|
|
47
|
-
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[
|
|
48
|
-
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
49
|
-
script_max_compilations_rate: Optional[pulumi.Input[
|
|
50
|
-
search_max_buckets: Optional[pulumi.Input[
|
|
51
|
-
thread_pool_analyze_queue_size: Optional[pulumi.Input[
|
|
52
|
-
thread_pool_analyze_size: Optional[pulumi.Input[
|
|
53
|
-
thread_pool_force_merge_size: Optional[pulumi.Input[
|
|
54
|
-
thread_pool_get_queue_size: Optional[pulumi.Input[
|
|
55
|
-
thread_pool_get_size: Optional[pulumi.Input[
|
|
56
|
-
thread_pool_search_queue_size: Optional[pulumi.Input[
|
|
57
|
-
thread_pool_search_size: Optional[pulumi.Input[
|
|
58
|
-
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[
|
|
59
|
-
thread_pool_search_throttled_size: Optional[pulumi.Input[
|
|
60
|
-
thread_pool_write_queue_size: Optional[pulumi.Input[
|
|
61
|
-
thread_pool_write_size: Optional[pulumi.Input[
|
|
22
|
+
cluster_id: pulumi.Input[_builtins.str],
|
|
23
|
+
action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
24
|
+
action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
25
|
+
cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
26
|
+
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
|
|
27
|
+
enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
|
+
http_max_content_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
29
|
+
http_max_header_size_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
http_max_initial_line_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
33
|
+
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
indices_queries_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
36
|
+
indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
|
+
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
|
|
38
|
+
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
|
|
39
|
+
ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
40
|
+
ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
41
|
+
ism_history_max_age_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
42
|
+
ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
|
|
43
|
+
ism_history_rollover_check_period_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
44
|
+
ism_history_rollover_retention_period_days: Optional[pulumi.Input[_builtins.int]] = None,
|
|
45
|
+
override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
46
|
+
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
47
|
+
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
48
|
+
script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
|
|
50
|
+
thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
51
|
+
thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
|
+
thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
53
|
+
thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
54
|
+
thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
55
|
+
thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
56
|
+
thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
57
|
+
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
58
|
+
thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
59
|
+
thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
60
|
+
thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None):
|
|
62
61
|
"""
|
|
63
62
|
The set of arguments for constructing a DatabaseOpensearchConfig resource.
|
|
64
|
-
:param pulumi.Input[
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
68
|
-
:param pulumi.Input[
|
|
69
|
-
:param pulumi.Input[
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[
|
|
77
|
-
:param pulumi.Input[
|
|
78
|
-
:param pulumi.Input[
|
|
79
|
-
:param pulumi.Input[
|
|
80
|
-
:param pulumi.Input[
|
|
81
|
-
:param pulumi.Input[
|
|
82
|
-
:param pulumi.Input[
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
86
|
-
:param pulumi.Input[
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
89
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
90
|
-
:param pulumi.Input[
|
|
91
|
-
:param pulumi.Input[
|
|
92
|
-
:param pulumi.Input[
|
|
93
|
-
:param pulumi.Input[
|
|
94
|
-
:param pulumi.Input[
|
|
95
|
-
:param pulumi.Input[
|
|
96
|
-
:param pulumi.Input[
|
|
97
|
-
:param pulumi.Input[
|
|
98
|
-
:param pulumi.Input[
|
|
99
|
-
:param pulumi.Input[
|
|
100
|
-
:param pulumi.Input[
|
|
101
|
-
:param pulumi.Input[
|
|
102
|
-
:param pulumi.Input[
|
|
63
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Opensearch cluster.
|
|
64
|
+
:param pulumi.Input[_builtins.bool] action_auto_create_index_enabled: Specifices whether to allow automatic creation of indices. Default: `true`
|
|
65
|
+
:param pulumi.Input[_builtins.bool] action_destructive_requires_name: Specifies whether to require explicit index names when deleting indices.
|
|
66
|
+
:param pulumi.Input[_builtins.int] cluster_max_shards_per_node: Maximum number of shards allowed per data node.
|
|
67
|
+
:param pulumi.Input[_builtins.int] cluster_routing_allocation_node_concurrent_recoveries: Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
68
|
+
:param pulumi.Input[_builtins.bool] enable_security_audit: Specifies whether to allow security audit logging. Default: `false`
|
|
69
|
+
:param pulumi.Input[_builtins.int] http_max_content_length_bytes: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
70
|
+
:param pulumi.Input[_builtins.int] http_max_header_size_bytes: Maximum size of allowed headers, in bytes. Default: `8192`
|
|
71
|
+
:param pulumi.Input[_builtins.int] http_max_initial_line_length_bytes: Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
72
|
+
:param pulumi.Input[_builtins.int] indices_fielddata_cache_size_percentage: 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.
|
|
73
|
+
:param pulumi.Input[_builtins.int] indices_memory_index_buffer_size_percentage: 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`
|
|
74
|
+
:param pulumi.Input[_builtins.int] indices_memory_max_index_buffer_size_mb: 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.
|
|
75
|
+
:param pulumi.Input[_builtins.int] indices_memory_min_index_buffer_size_mb: 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`
|
|
76
|
+
:param pulumi.Input[_builtins.int] indices_queries_cache_size_percentage: 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`
|
|
77
|
+
:param pulumi.Input[_builtins.int] indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
78
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_concurrent_file_chunks: Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
79
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_mb_per_sec: 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`
|
|
80
|
+
:param pulumi.Input[_builtins.bool] ism_enabled: Specifies whether ISM is enabled or not. Default: `true`
|
|
81
|
+
:param pulumi.Input[_builtins.bool] ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
82
|
+
:param pulumi.Input[_builtins.int] ism_history_max_age_hours: Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
83
|
+
:param pulumi.Input[_builtins.int] ism_history_max_docs: Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
84
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_check_period_hours: The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
85
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_retention_period_days: Length of time long audit history indices are kept, in days. Default: `30`
|
|
86
|
+
:param pulumi.Input[_builtins.bool] override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
87
|
+
:param pulumi.Input[_builtins.bool] plugins_alerting_filter_by_backend_roles_enabled: Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
88
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] reindex_remote_whitelists: Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
89
|
+
:param pulumi.Input[_builtins.str] script_max_compilations_rate: Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
90
|
+
:param pulumi.Input[_builtins.int] search_max_buckets: Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
91
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_queue_size: Size of queue for operations in the analyze thread pool.
|
|
92
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_size: 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.
|
|
93
|
+
:param pulumi.Input[_builtins.int] thread_pool_force_merge_size: 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.
|
|
94
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_queue_size: Size of queue for operations in the get thread pool.
|
|
95
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_size: 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.
|
|
96
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_queue_size: Size of queue for operations in the search thread pool.
|
|
97
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_size: 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.
|
|
98
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_queue_size: Size of queue for operations in the search throttled thread pool.
|
|
99
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_size: 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.
|
|
100
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_queue_size: Size of queue for operations in the write thread pool.
|
|
101
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_size: 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.
|
|
103
102
|
"""
|
|
104
103
|
pulumi.set(__self__, "cluster_id", cluster_id)
|
|
105
104
|
if action_auto_create_index_enabled is not None:
|
|
@@ -179,558 +178,558 @@ class DatabaseOpensearchConfigArgs:
|
|
|
179
178
|
if thread_pool_write_size is not None:
|
|
180
179
|
pulumi.set(__self__, "thread_pool_write_size", thread_pool_write_size)
|
|
181
180
|
|
|
182
|
-
@property
|
|
181
|
+
@_builtins.property
|
|
183
182
|
@pulumi.getter(name="clusterId")
|
|
184
|
-
def cluster_id(self) -> pulumi.Input[
|
|
183
|
+
def cluster_id(self) -> pulumi.Input[_builtins.str]:
|
|
185
184
|
"""
|
|
186
185
|
The ID of the target Opensearch cluster.
|
|
187
186
|
"""
|
|
188
187
|
return pulumi.get(self, "cluster_id")
|
|
189
188
|
|
|
190
189
|
@cluster_id.setter
|
|
191
|
-
def cluster_id(self, value: pulumi.Input[
|
|
190
|
+
def cluster_id(self, value: pulumi.Input[_builtins.str]):
|
|
192
191
|
pulumi.set(self, "cluster_id", value)
|
|
193
192
|
|
|
194
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
195
194
|
@pulumi.getter(name="actionAutoCreateIndexEnabled")
|
|
196
|
-
def action_auto_create_index_enabled(self) -> Optional[pulumi.Input[
|
|
195
|
+
def action_auto_create_index_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
197
196
|
"""
|
|
198
197
|
Specifices whether to allow automatic creation of indices. Default: `true`
|
|
199
198
|
"""
|
|
200
199
|
return pulumi.get(self, "action_auto_create_index_enabled")
|
|
201
200
|
|
|
202
201
|
@action_auto_create_index_enabled.setter
|
|
203
|
-
def action_auto_create_index_enabled(self, value: Optional[pulumi.Input[
|
|
202
|
+
def action_auto_create_index_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
204
203
|
pulumi.set(self, "action_auto_create_index_enabled", value)
|
|
205
204
|
|
|
206
|
-
@property
|
|
205
|
+
@_builtins.property
|
|
207
206
|
@pulumi.getter(name="actionDestructiveRequiresName")
|
|
208
|
-
def action_destructive_requires_name(self) -> Optional[pulumi.Input[
|
|
207
|
+
def action_destructive_requires_name(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
209
208
|
"""
|
|
210
209
|
Specifies whether to require explicit index names when deleting indices.
|
|
211
210
|
"""
|
|
212
211
|
return pulumi.get(self, "action_destructive_requires_name")
|
|
213
212
|
|
|
214
213
|
@action_destructive_requires_name.setter
|
|
215
|
-
def action_destructive_requires_name(self, value: Optional[pulumi.Input[
|
|
214
|
+
def action_destructive_requires_name(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
216
215
|
pulumi.set(self, "action_destructive_requires_name", value)
|
|
217
216
|
|
|
218
|
-
@property
|
|
217
|
+
@_builtins.property
|
|
219
218
|
@pulumi.getter(name="clusterMaxShardsPerNode")
|
|
220
|
-
def cluster_max_shards_per_node(self) -> Optional[pulumi.Input[
|
|
219
|
+
def cluster_max_shards_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
221
220
|
"""
|
|
222
221
|
Maximum number of shards allowed per data node.
|
|
223
222
|
"""
|
|
224
223
|
return pulumi.get(self, "cluster_max_shards_per_node")
|
|
225
224
|
|
|
226
225
|
@cluster_max_shards_per_node.setter
|
|
227
|
-
def cluster_max_shards_per_node(self, value: Optional[pulumi.Input[
|
|
226
|
+
def cluster_max_shards_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
228
227
|
pulumi.set(self, "cluster_max_shards_per_node", value)
|
|
229
228
|
|
|
230
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
231
230
|
@pulumi.getter(name="clusterRoutingAllocationNodeConcurrentRecoveries")
|
|
232
|
-
def cluster_routing_allocation_node_concurrent_recoveries(self) -> Optional[pulumi.Input[
|
|
231
|
+
def cluster_routing_allocation_node_concurrent_recoveries(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
233
232
|
"""
|
|
234
233
|
Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
235
234
|
"""
|
|
236
235
|
return pulumi.get(self, "cluster_routing_allocation_node_concurrent_recoveries")
|
|
237
236
|
|
|
238
237
|
@cluster_routing_allocation_node_concurrent_recoveries.setter
|
|
239
|
-
def cluster_routing_allocation_node_concurrent_recoveries(self, value: Optional[pulumi.Input[
|
|
238
|
+
def cluster_routing_allocation_node_concurrent_recoveries(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
240
239
|
pulumi.set(self, "cluster_routing_allocation_node_concurrent_recoveries", value)
|
|
241
240
|
|
|
242
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
243
242
|
@pulumi.getter(name="enableSecurityAudit")
|
|
244
|
-
def enable_security_audit(self) -> Optional[pulumi.Input[
|
|
243
|
+
def enable_security_audit(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
245
244
|
"""
|
|
246
245
|
Specifies whether to allow security audit logging. Default: `false`
|
|
247
246
|
"""
|
|
248
247
|
return pulumi.get(self, "enable_security_audit")
|
|
249
248
|
|
|
250
249
|
@enable_security_audit.setter
|
|
251
|
-
def enable_security_audit(self, value: Optional[pulumi.Input[
|
|
250
|
+
def enable_security_audit(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
252
251
|
pulumi.set(self, "enable_security_audit", value)
|
|
253
252
|
|
|
254
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
255
254
|
@pulumi.getter(name="httpMaxContentLengthBytes")
|
|
256
|
-
def http_max_content_length_bytes(self) -> Optional[pulumi.Input[
|
|
255
|
+
def http_max_content_length_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
257
256
|
"""
|
|
258
257
|
Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
259
258
|
"""
|
|
260
259
|
return pulumi.get(self, "http_max_content_length_bytes")
|
|
261
260
|
|
|
262
261
|
@http_max_content_length_bytes.setter
|
|
263
|
-
def http_max_content_length_bytes(self, value: Optional[pulumi.Input[
|
|
262
|
+
def http_max_content_length_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
264
263
|
pulumi.set(self, "http_max_content_length_bytes", value)
|
|
265
264
|
|
|
266
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
267
266
|
@pulumi.getter(name="httpMaxHeaderSizeBytes")
|
|
268
|
-
def http_max_header_size_bytes(self) -> Optional[pulumi.Input[
|
|
267
|
+
def http_max_header_size_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
269
268
|
"""
|
|
270
269
|
Maximum size of allowed headers, in bytes. Default: `8192`
|
|
271
270
|
"""
|
|
272
271
|
return pulumi.get(self, "http_max_header_size_bytes")
|
|
273
272
|
|
|
274
273
|
@http_max_header_size_bytes.setter
|
|
275
|
-
def http_max_header_size_bytes(self, value: Optional[pulumi.Input[
|
|
274
|
+
def http_max_header_size_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
276
275
|
pulumi.set(self, "http_max_header_size_bytes", value)
|
|
277
276
|
|
|
278
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
279
278
|
@pulumi.getter(name="httpMaxInitialLineLengthBytes")
|
|
280
|
-
def http_max_initial_line_length_bytes(self) -> Optional[pulumi.Input[
|
|
279
|
+
def http_max_initial_line_length_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
281
280
|
"""
|
|
282
281
|
Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
283
282
|
"""
|
|
284
283
|
return pulumi.get(self, "http_max_initial_line_length_bytes")
|
|
285
284
|
|
|
286
285
|
@http_max_initial_line_length_bytes.setter
|
|
287
|
-
def http_max_initial_line_length_bytes(self, value: Optional[pulumi.Input[
|
|
286
|
+
def http_max_initial_line_length_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
288
287
|
pulumi.set(self, "http_max_initial_line_length_bytes", value)
|
|
289
288
|
|
|
290
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
291
290
|
@pulumi.getter(name="indicesFielddataCacheSizePercentage")
|
|
292
|
-
def indices_fielddata_cache_size_percentage(self) -> Optional[pulumi.Input[
|
|
291
|
+
def indices_fielddata_cache_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
293
292
|
"""
|
|
294
293
|
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.
|
|
295
294
|
"""
|
|
296
295
|
return pulumi.get(self, "indices_fielddata_cache_size_percentage")
|
|
297
296
|
|
|
298
297
|
@indices_fielddata_cache_size_percentage.setter
|
|
299
|
-
def indices_fielddata_cache_size_percentage(self, value: Optional[pulumi.Input[
|
|
298
|
+
def indices_fielddata_cache_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
300
299
|
pulumi.set(self, "indices_fielddata_cache_size_percentage", value)
|
|
301
300
|
|
|
302
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
303
302
|
@pulumi.getter(name="indicesMemoryIndexBufferSizePercentage")
|
|
304
|
-
def indices_memory_index_buffer_size_percentage(self) -> Optional[pulumi.Input[
|
|
303
|
+
def indices_memory_index_buffer_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
305
304
|
"""
|
|
306
305
|
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`
|
|
307
306
|
"""
|
|
308
307
|
return pulumi.get(self, "indices_memory_index_buffer_size_percentage")
|
|
309
308
|
|
|
310
309
|
@indices_memory_index_buffer_size_percentage.setter
|
|
311
|
-
def indices_memory_index_buffer_size_percentage(self, value: Optional[pulumi.Input[
|
|
310
|
+
def indices_memory_index_buffer_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
312
311
|
pulumi.set(self, "indices_memory_index_buffer_size_percentage", value)
|
|
313
312
|
|
|
314
|
-
@property
|
|
313
|
+
@_builtins.property
|
|
315
314
|
@pulumi.getter(name="indicesMemoryMaxIndexBufferSizeMb")
|
|
316
|
-
def indices_memory_max_index_buffer_size_mb(self) -> Optional[pulumi.Input[
|
|
315
|
+
def indices_memory_max_index_buffer_size_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
317
316
|
"""
|
|
318
317
|
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.
|
|
319
318
|
"""
|
|
320
319
|
return pulumi.get(self, "indices_memory_max_index_buffer_size_mb")
|
|
321
320
|
|
|
322
321
|
@indices_memory_max_index_buffer_size_mb.setter
|
|
323
|
-
def indices_memory_max_index_buffer_size_mb(self, value: Optional[pulumi.Input[
|
|
322
|
+
def indices_memory_max_index_buffer_size_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
324
323
|
pulumi.set(self, "indices_memory_max_index_buffer_size_mb", value)
|
|
325
324
|
|
|
326
|
-
@property
|
|
325
|
+
@_builtins.property
|
|
327
326
|
@pulumi.getter(name="indicesMemoryMinIndexBufferSizeMb")
|
|
328
|
-
def indices_memory_min_index_buffer_size_mb(self) -> Optional[pulumi.Input[
|
|
327
|
+
def indices_memory_min_index_buffer_size_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
329
328
|
"""
|
|
330
329
|
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`
|
|
331
330
|
"""
|
|
332
331
|
return pulumi.get(self, "indices_memory_min_index_buffer_size_mb")
|
|
333
332
|
|
|
334
333
|
@indices_memory_min_index_buffer_size_mb.setter
|
|
335
|
-
def indices_memory_min_index_buffer_size_mb(self, value: Optional[pulumi.Input[
|
|
334
|
+
def indices_memory_min_index_buffer_size_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
336
335
|
pulumi.set(self, "indices_memory_min_index_buffer_size_mb", value)
|
|
337
336
|
|
|
338
|
-
@property
|
|
337
|
+
@_builtins.property
|
|
339
338
|
@pulumi.getter(name="indicesQueriesCacheSizePercentage")
|
|
340
|
-
def indices_queries_cache_size_percentage(self) -> Optional[pulumi.Input[
|
|
339
|
+
def indices_queries_cache_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
341
340
|
"""
|
|
342
341
|
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`
|
|
343
342
|
"""
|
|
344
343
|
return pulumi.get(self, "indices_queries_cache_size_percentage")
|
|
345
344
|
|
|
346
345
|
@indices_queries_cache_size_percentage.setter
|
|
347
|
-
def indices_queries_cache_size_percentage(self, value: Optional[pulumi.Input[
|
|
346
|
+
def indices_queries_cache_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
348
347
|
pulumi.set(self, "indices_queries_cache_size_percentage", value)
|
|
349
348
|
|
|
350
|
-
@property
|
|
349
|
+
@_builtins.property
|
|
351
350
|
@pulumi.getter(name="indicesQueryBoolMaxClauseCount")
|
|
352
|
-
def indices_query_bool_max_clause_count(self) -> Optional[pulumi.Input[
|
|
351
|
+
def indices_query_bool_max_clause_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
353
352
|
"""
|
|
354
353
|
Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
355
354
|
"""
|
|
356
355
|
return pulumi.get(self, "indices_query_bool_max_clause_count")
|
|
357
356
|
|
|
358
357
|
@indices_query_bool_max_clause_count.setter
|
|
359
|
-
def indices_query_bool_max_clause_count(self, value: Optional[pulumi.Input[
|
|
358
|
+
def indices_query_bool_max_clause_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
360
359
|
pulumi.set(self, "indices_query_bool_max_clause_count", value)
|
|
361
360
|
|
|
362
|
-
@property
|
|
361
|
+
@_builtins.property
|
|
363
362
|
@pulumi.getter(name="indicesRecoveryMaxConcurrentFileChunks")
|
|
364
|
-
def indices_recovery_max_concurrent_file_chunks(self) -> Optional[pulumi.Input[
|
|
363
|
+
def indices_recovery_max_concurrent_file_chunks(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
365
364
|
"""
|
|
366
365
|
Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
367
366
|
"""
|
|
368
367
|
return pulumi.get(self, "indices_recovery_max_concurrent_file_chunks")
|
|
369
368
|
|
|
370
369
|
@indices_recovery_max_concurrent_file_chunks.setter
|
|
371
|
-
def indices_recovery_max_concurrent_file_chunks(self, value: Optional[pulumi.Input[
|
|
370
|
+
def indices_recovery_max_concurrent_file_chunks(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
372
371
|
pulumi.set(self, "indices_recovery_max_concurrent_file_chunks", value)
|
|
373
372
|
|
|
374
|
-
@property
|
|
373
|
+
@_builtins.property
|
|
375
374
|
@pulumi.getter(name="indicesRecoveryMaxMbPerSec")
|
|
376
|
-
def indices_recovery_max_mb_per_sec(self) -> Optional[pulumi.Input[
|
|
375
|
+
def indices_recovery_max_mb_per_sec(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
377
376
|
"""
|
|
378
377
|
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`
|
|
379
378
|
"""
|
|
380
379
|
return pulumi.get(self, "indices_recovery_max_mb_per_sec")
|
|
381
380
|
|
|
382
381
|
@indices_recovery_max_mb_per_sec.setter
|
|
383
|
-
def indices_recovery_max_mb_per_sec(self, value: Optional[pulumi.Input[
|
|
382
|
+
def indices_recovery_max_mb_per_sec(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
384
383
|
pulumi.set(self, "indices_recovery_max_mb_per_sec", value)
|
|
385
384
|
|
|
386
|
-
@property
|
|
385
|
+
@_builtins.property
|
|
387
386
|
@pulumi.getter(name="ismEnabled")
|
|
388
|
-
def ism_enabled(self) -> Optional[pulumi.Input[
|
|
387
|
+
def ism_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
389
388
|
"""
|
|
390
389
|
Specifies whether ISM is enabled or not. Default: `true`
|
|
391
390
|
"""
|
|
392
391
|
return pulumi.get(self, "ism_enabled")
|
|
393
392
|
|
|
394
393
|
@ism_enabled.setter
|
|
395
|
-
def ism_enabled(self, value: Optional[pulumi.Input[
|
|
394
|
+
def ism_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
396
395
|
pulumi.set(self, "ism_enabled", value)
|
|
397
396
|
|
|
398
|
-
@property
|
|
397
|
+
@_builtins.property
|
|
399
398
|
@pulumi.getter(name="ismHistoryEnabled")
|
|
400
|
-
def ism_history_enabled(self) -> Optional[pulumi.Input[
|
|
399
|
+
def ism_history_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
401
400
|
"""
|
|
402
401
|
Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
403
402
|
"""
|
|
404
403
|
return pulumi.get(self, "ism_history_enabled")
|
|
405
404
|
|
|
406
405
|
@ism_history_enabled.setter
|
|
407
|
-
def ism_history_enabled(self, value: Optional[pulumi.Input[
|
|
406
|
+
def ism_history_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
408
407
|
pulumi.set(self, "ism_history_enabled", value)
|
|
409
408
|
|
|
410
|
-
@property
|
|
409
|
+
@_builtins.property
|
|
411
410
|
@pulumi.getter(name="ismHistoryMaxAgeHours")
|
|
412
|
-
def ism_history_max_age_hours(self) -> Optional[pulumi.Input[
|
|
411
|
+
def ism_history_max_age_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
413
412
|
"""
|
|
414
413
|
Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
415
414
|
"""
|
|
416
415
|
return pulumi.get(self, "ism_history_max_age_hours")
|
|
417
416
|
|
|
418
417
|
@ism_history_max_age_hours.setter
|
|
419
|
-
def ism_history_max_age_hours(self, value: Optional[pulumi.Input[
|
|
418
|
+
def ism_history_max_age_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
420
419
|
pulumi.set(self, "ism_history_max_age_hours", value)
|
|
421
420
|
|
|
422
|
-
@property
|
|
421
|
+
@_builtins.property
|
|
423
422
|
@pulumi.getter(name="ismHistoryMaxDocs")
|
|
424
|
-
def ism_history_max_docs(self) -> Optional[pulumi.Input[
|
|
423
|
+
def ism_history_max_docs(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
425
424
|
"""
|
|
426
425
|
Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
427
426
|
"""
|
|
428
427
|
return pulumi.get(self, "ism_history_max_docs")
|
|
429
428
|
|
|
430
429
|
@ism_history_max_docs.setter
|
|
431
|
-
def ism_history_max_docs(self, value: Optional[pulumi.Input[
|
|
430
|
+
def ism_history_max_docs(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
432
431
|
pulumi.set(self, "ism_history_max_docs", value)
|
|
433
432
|
|
|
434
|
-
@property
|
|
433
|
+
@_builtins.property
|
|
435
434
|
@pulumi.getter(name="ismHistoryRolloverCheckPeriodHours")
|
|
436
|
-
def ism_history_rollover_check_period_hours(self) -> Optional[pulumi.Input[
|
|
435
|
+
def ism_history_rollover_check_period_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
437
436
|
"""
|
|
438
437
|
The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
439
438
|
"""
|
|
440
439
|
return pulumi.get(self, "ism_history_rollover_check_period_hours")
|
|
441
440
|
|
|
442
441
|
@ism_history_rollover_check_period_hours.setter
|
|
443
|
-
def ism_history_rollover_check_period_hours(self, value: Optional[pulumi.Input[
|
|
442
|
+
def ism_history_rollover_check_period_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
444
443
|
pulumi.set(self, "ism_history_rollover_check_period_hours", value)
|
|
445
444
|
|
|
446
|
-
@property
|
|
445
|
+
@_builtins.property
|
|
447
446
|
@pulumi.getter(name="ismHistoryRolloverRetentionPeriodDays")
|
|
448
|
-
def ism_history_rollover_retention_period_days(self) -> Optional[pulumi.Input[
|
|
447
|
+
def ism_history_rollover_retention_period_days(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
449
448
|
"""
|
|
450
449
|
Length of time long audit history indices are kept, in days. Default: `30`
|
|
451
450
|
"""
|
|
452
451
|
return pulumi.get(self, "ism_history_rollover_retention_period_days")
|
|
453
452
|
|
|
454
453
|
@ism_history_rollover_retention_period_days.setter
|
|
455
|
-
def ism_history_rollover_retention_period_days(self, value: Optional[pulumi.Input[
|
|
454
|
+
def ism_history_rollover_retention_period_days(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
456
455
|
pulumi.set(self, "ism_history_rollover_retention_period_days", value)
|
|
457
456
|
|
|
458
|
-
@property
|
|
457
|
+
@_builtins.property
|
|
459
458
|
@pulumi.getter(name="overrideMainResponseVersion")
|
|
460
|
-
def override_main_response_version(self) -> Optional[pulumi.Input[
|
|
459
|
+
def override_main_response_version(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
461
460
|
"""
|
|
462
461
|
Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
463
462
|
"""
|
|
464
463
|
return pulumi.get(self, "override_main_response_version")
|
|
465
464
|
|
|
466
465
|
@override_main_response_version.setter
|
|
467
|
-
def override_main_response_version(self, value: Optional[pulumi.Input[
|
|
466
|
+
def override_main_response_version(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
468
467
|
pulumi.set(self, "override_main_response_version", value)
|
|
469
468
|
|
|
470
|
-
@property
|
|
469
|
+
@_builtins.property
|
|
471
470
|
@pulumi.getter(name="pluginsAlertingFilterByBackendRolesEnabled")
|
|
472
|
-
def plugins_alerting_filter_by_backend_roles_enabled(self) -> Optional[pulumi.Input[
|
|
471
|
+
def plugins_alerting_filter_by_backend_roles_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
473
472
|
"""
|
|
474
473
|
Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
475
474
|
"""
|
|
476
475
|
return pulumi.get(self, "plugins_alerting_filter_by_backend_roles_enabled")
|
|
477
476
|
|
|
478
477
|
@plugins_alerting_filter_by_backend_roles_enabled.setter
|
|
479
|
-
def plugins_alerting_filter_by_backend_roles_enabled(self, value: Optional[pulumi.Input[
|
|
478
|
+
def plugins_alerting_filter_by_backend_roles_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
480
479
|
pulumi.set(self, "plugins_alerting_filter_by_backend_roles_enabled", value)
|
|
481
480
|
|
|
482
|
-
@property
|
|
481
|
+
@_builtins.property
|
|
483
482
|
@pulumi.getter(name="reindexRemoteWhitelists")
|
|
484
|
-
def reindex_remote_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
483
|
+
def reindex_remote_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
485
484
|
"""
|
|
486
485
|
Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
487
486
|
"""
|
|
488
487
|
return pulumi.get(self, "reindex_remote_whitelists")
|
|
489
488
|
|
|
490
489
|
@reindex_remote_whitelists.setter
|
|
491
|
-
def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
490
|
+
def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
492
491
|
pulumi.set(self, "reindex_remote_whitelists", value)
|
|
493
492
|
|
|
494
|
-
@property
|
|
493
|
+
@_builtins.property
|
|
495
494
|
@pulumi.getter(name="scriptMaxCompilationsRate")
|
|
496
|
-
def script_max_compilations_rate(self) -> Optional[pulumi.Input[
|
|
495
|
+
def script_max_compilations_rate(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
497
496
|
"""
|
|
498
497
|
Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
499
498
|
"""
|
|
500
499
|
return pulumi.get(self, "script_max_compilations_rate")
|
|
501
500
|
|
|
502
501
|
@script_max_compilations_rate.setter
|
|
503
|
-
def script_max_compilations_rate(self, value: Optional[pulumi.Input[
|
|
502
|
+
def script_max_compilations_rate(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
504
503
|
pulumi.set(self, "script_max_compilations_rate", value)
|
|
505
504
|
|
|
506
|
-
@property
|
|
505
|
+
@_builtins.property
|
|
507
506
|
@pulumi.getter(name="searchMaxBuckets")
|
|
508
|
-
def search_max_buckets(self) -> Optional[pulumi.Input[
|
|
507
|
+
def search_max_buckets(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
509
508
|
"""
|
|
510
509
|
Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
511
510
|
"""
|
|
512
511
|
return pulumi.get(self, "search_max_buckets")
|
|
513
512
|
|
|
514
513
|
@search_max_buckets.setter
|
|
515
|
-
def search_max_buckets(self, value: Optional[pulumi.Input[
|
|
514
|
+
def search_max_buckets(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
516
515
|
pulumi.set(self, "search_max_buckets", value)
|
|
517
516
|
|
|
518
|
-
@property
|
|
517
|
+
@_builtins.property
|
|
519
518
|
@pulumi.getter(name="threadPoolAnalyzeQueueSize")
|
|
520
|
-
def thread_pool_analyze_queue_size(self) -> Optional[pulumi.Input[
|
|
519
|
+
def thread_pool_analyze_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
521
520
|
"""
|
|
522
521
|
Size of queue for operations in the analyze thread pool.
|
|
523
522
|
"""
|
|
524
523
|
return pulumi.get(self, "thread_pool_analyze_queue_size")
|
|
525
524
|
|
|
526
525
|
@thread_pool_analyze_queue_size.setter
|
|
527
|
-
def thread_pool_analyze_queue_size(self, value: Optional[pulumi.Input[
|
|
526
|
+
def thread_pool_analyze_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
528
527
|
pulumi.set(self, "thread_pool_analyze_queue_size", value)
|
|
529
528
|
|
|
530
|
-
@property
|
|
529
|
+
@_builtins.property
|
|
531
530
|
@pulumi.getter(name="threadPoolAnalyzeSize")
|
|
532
|
-
def thread_pool_analyze_size(self) -> Optional[pulumi.Input[
|
|
531
|
+
def thread_pool_analyze_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
533
532
|
"""
|
|
534
533
|
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.
|
|
535
534
|
"""
|
|
536
535
|
return pulumi.get(self, "thread_pool_analyze_size")
|
|
537
536
|
|
|
538
537
|
@thread_pool_analyze_size.setter
|
|
539
|
-
def thread_pool_analyze_size(self, value: Optional[pulumi.Input[
|
|
538
|
+
def thread_pool_analyze_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
540
539
|
pulumi.set(self, "thread_pool_analyze_size", value)
|
|
541
540
|
|
|
542
|
-
@property
|
|
541
|
+
@_builtins.property
|
|
543
542
|
@pulumi.getter(name="threadPoolForceMergeSize")
|
|
544
|
-
def thread_pool_force_merge_size(self) -> Optional[pulumi.Input[
|
|
543
|
+
def thread_pool_force_merge_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
545
544
|
"""
|
|
546
545
|
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.
|
|
547
546
|
"""
|
|
548
547
|
return pulumi.get(self, "thread_pool_force_merge_size")
|
|
549
548
|
|
|
550
549
|
@thread_pool_force_merge_size.setter
|
|
551
|
-
def thread_pool_force_merge_size(self, value: Optional[pulumi.Input[
|
|
550
|
+
def thread_pool_force_merge_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
552
551
|
pulumi.set(self, "thread_pool_force_merge_size", value)
|
|
553
552
|
|
|
554
|
-
@property
|
|
553
|
+
@_builtins.property
|
|
555
554
|
@pulumi.getter(name="threadPoolGetQueueSize")
|
|
556
|
-
def thread_pool_get_queue_size(self) -> Optional[pulumi.Input[
|
|
555
|
+
def thread_pool_get_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
557
556
|
"""
|
|
558
557
|
Size of queue for operations in the get thread pool.
|
|
559
558
|
"""
|
|
560
559
|
return pulumi.get(self, "thread_pool_get_queue_size")
|
|
561
560
|
|
|
562
561
|
@thread_pool_get_queue_size.setter
|
|
563
|
-
def thread_pool_get_queue_size(self, value: Optional[pulumi.Input[
|
|
562
|
+
def thread_pool_get_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
564
563
|
pulumi.set(self, "thread_pool_get_queue_size", value)
|
|
565
564
|
|
|
566
|
-
@property
|
|
565
|
+
@_builtins.property
|
|
567
566
|
@pulumi.getter(name="threadPoolGetSize")
|
|
568
|
-
def thread_pool_get_size(self) -> Optional[pulumi.Input[
|
|
567
|
+
def thread_pool_get_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
569
568
|
"""
|
|
570
569
|
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.
|
|
571
570
|
"""
|
|
572
571
|
return pulumi.get(self, "thread_pool_get_size")
|
|
573
572
|
|
|
574
573
|
@thread_pool_get_size.setter
|
|
575
|
-
def thread_pool_get_size(self, value: Optional[pulumi.Input[
|
|
574
|
+
def thread_pool_get_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
576
575
|
pulumi.set(self, "thread_pool_get_size", value)
|
|
577
576
|
|
|
578
|
-
@property
|
|
577
|
+
@_builtins.property
|
|
579
578
|
@pulumi.getter(name="threadPoolSearchQueueSize")
|
|
580
|
-
def thread_pool_search_queue_size(self) -> Optional[pulumi.Input[
|
|
579
|
+
def thread_pool_search_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
581
580
|
"""
|
|
582
581
|
Size of queue for operations in the search thread pool.
|
|
583
582
|
"""
|
|
584
583
|
return pulumi.get(self, "thread_pool_search_queue_size")
|
|
585
584
|
|
|
586
585
|
@thread_pool_search_queue_size.setter
|
|
587
|
-
def thread_pool_search_queue_size(self, value: Optional[pulumi.Input[
|
|
586
|
+
def thread_pool_search_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
588
587
|
pulumi.set(self, "thread_pool_search_queue_size", value)
|
|
589
588
|
|
|
590
|
-
@property
|
|
589
|
+
@_builtins.property
|
|
591
590
|
@pulumi.getter(name="threadPoolSearchSize")
|
|
592
|
-
def thread_pool_search_size(self) -> Optional[pulumi.Input[
|
|
591
|
+
def thread_pool_search_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
593
592
|
"""
|
|
594
593
|
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.
|
|
595
594
|
"""
|
|
596
595
|
return pulumi.get(self, "thread_pool_search_size")
|
|
597
596
|
|
|
598
597
|
@thread_pool_search_size.setter
|
|
599
|
-
def thread_pool_search_size(self, value: Optional[pulumi.Input[
|
|
598
|
+
def thread_pool_search_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
600
599
|
pulumi.set(self, "thread_pool_search_size", value)
|
|
601
600
|
|
|
602
|
-
@property
|
|
601
|
+
@_builtins.property
|
|
603
602
|
@pulumi.getter(name="threadPoolSearchThrottledQueueSize")
|
|
604
|
-
def thread_pool_search_throttled_queue_size(self) -> Optional[pulumi.Input[
|
|
603
|
+
def thread_pool_search_throttled_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
605
604
|
"""
|
|
606
605
|
Size of queue for operations in the search throttled thread pool.
|
|
607
606
|
"""
|
|
608
607
|
return pulumi.get(self, "thread_pool_search_throttled_queue_size")
|
|
609
608
|
|
|
610
609
|
@thread_pool_search_throttled_queue_size.setter
|
|
611
|
-
def thread_pool_search_throttled_queue_size(self, value: Optional[pulumi.Input[
|
|
610
|
+
def thread_pool_search_throttled_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
612
611
|
pulumi.set(self, "thread_pool_search_throttled_queue_size", value)
|
|
613
612
|
|
|
614
|
-
@property
|
|
613
|
+
@_builtins.property
|
|
615
614
|
@pulumi.getter(name="threadPoolSearchThrottledSize")
|
|
616
|
-
def thread_pool_search_throttled_size(self) -> Optional[pulumi.Input[
|
|
615
|
+
def thread_pool_search_throttled_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
617
616
|
"""
|
|
618
617
|
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.
|
|
619
618
|
"""
|
|
620
619
|
return pulumi.get(self, "thread_pool_search_throttled_size")
|
|
621
620
|
|
|
622
621
|
@thread_pool_search_throttled_size.setter
|
|
623
|
-
def thread_pool_search_throttled_size(self, value: Optional[pulumi.Input[
|
|
622
|
+
def thread_pool_search_throttled_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
624
623
|
pulumi.set(self, "thread_pool_search_throttled_size", value)
|
|
625
624
|
|
|
626
|
-
@property
|
|
625
|
+
@_builtins.property
|
|
627
626
|
@pulumi.getter(name="threadPoolWriteQueueSize")
|
|
628
|
-
def thread_pool_write_queue_size(self) -> Optional[pulumi.Input[
|
|
627
|
+
def thread_pool_write_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
629
628
|
"""
|
|
630
629
|
Size of queue for operations in the write thread pool.
|
|
631
630
|
"""
|
|
632
631
|
return pulumi.get(self, "thread_pool_write_queue_size")
|
|
633
632
|
|
|
634
633
|
@thread_pool_write_queue_size.setter
|
|
635
|
-
def thread_pool_write_queue_size(self, value: Optional[pulumi.Input[
|
|
634
|
+
def thread_pool_write_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
636
635
|
pulumi.set(self, "thread_pool_write_queue_size", value)
|
|
637
636
|
|
|
638
|
-
@property
|
|
637
|
+
@_builtins.property
|
|
639
638
|
@pulumi.getter(name="threadPoolWriteSize")
|
|
640
|
-
def thread_pool_write_size(self) -> Optional[pulumi.Input[
|
|
639
|
+
def thread_pool_write_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
641
640
|
"""
|
|
642
641
|
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.
|
|
643
642
|
"""
|
|
644
643
|
return pulumi.get(self, "thread_pool_write_size")
|
|
645
644
|
|
|
646
645
|
@thread_pool_write_size.setter
|
|
647
|
-
def thread_pool_write_size(self, value: Optional[pulumi.Input[
|
|
646
|
+
def thread_pool_write_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
648
647
|
pulumi.set(self, "thread_pool_write_size", value)
|
|
649
648
|
|
|
650
649
|
|
|
651
650
|
@pulumi.input_type
|
|
652
651
|
class _DatabaseOpensearchConfigState:
|
|
653
652
|
def __init__(__self__, *,
|
|
654
|
-
action_auto_create_index_enabled: Optional[pulumi.Input[
|
|
655
|
-
action_destructive_requires_name: Optional[pulumi.Input[
|
|
656
|
-
cluster_id: Optional[pulumi.Input[
|
|
657
|
-
cluster_max_shards_per_node: Optional[pulumi.Input[
|
|
658
|
-
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[
|
|
659
|
-
enable_security_audit: Optional[pulumi.Input[
|
|
660
|
-
http_max_content_length_bytes: Optional[pulumi.Input[
|
|
661
|
-
http_max_header_size_bytes: Optional[pulumi.Input[
|
|
662
|
-
http_max_initial_line_length_bytes: Optional[pulumi.Input[
|
|
663
|
-
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[
|
|
664
|
-
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[
|
|
665
|
-
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[
|
|
666
|
-
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[
|
|
667
|
-
indices_queries_cache_size_percentage: Optional[pulumi.Input[
|
|
668
|
-
indices_query_bool_max_clause_count: Optional[pulumi.Input[
|
|
669
|
-
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[
|
|
670
|
-
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[
|
|
671
|
-
ism_enabled: Optional[pulumi.Input[
|
|
672
|
-
ism_history_enabled: Optional[pulumi.Input[
|
|
673
|
-
ism_history_max_age_hours: Optional[pulumi.Input[
|
|
674
|
-
ism_history_max_docs: Optional[pulumi.Input[
|
|
675
|
-
ism_history_rollover_check_period_hours: Optional[pulumi.Input[
|
|
676
|
-
ism_history_rollover_retention_period_days: Optional[pulumi.Input[
|
|
677
|
-
override_main_response_version: Optional[pulumi.Input[
|
|
678
|
-
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[
|
|
679
|
-
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
680
|
-
script_max_compilations_rate: Optional[pulumi.Input[
|
|
681
|
-
search_max_buckets: Optional[pulumi.Input[
|
|
682
|
-
thread_pool_analyze_queue_size: Optional[pulumi.Input[
|
|
683
|
-
thread_pool_analyze_size: Optional[pulumi.Input[
|
|
684
|
-
thread_pool_force_merge_size: Optional[pulumi.Input[
|
|
685
|
-
thread_pool_get_queue_size: Optional[pulumi.Input[
|
|
686
|
-
thread_pool_get_size: Optional[pulumi.Input[
|
|
687
|
-
thread_pool_search_queue_size: Optional[pulumi.Input[
|
|
688
|
-
thread_pool_search_size: Optional[pulumi.Input[
|
|
689
|
-
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[
|
|
690
|
-
thread_pool_search_throttled_size: Optional[pulumi.Input[
|
|
691
|
-
thread_pool_write_queue_size: Optional[pulumi.Input[
|
|
692
|
-
thread_pool_write_size: Optional[pulumi.Input[
|
|
653
|
+
action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
654
|
+
action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
655
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
656
|
+
cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
657
|
+
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
|
|
658
|
+
enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
659
|
+
http_max_content_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
660
|
+
http_max_header_size_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
661
|
+
http_max_initial_line_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
662
|
+
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
663
|
+
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
664
|
+
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
665
|
+
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
666
|
+
indices_queries_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
667
|
+
indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
668
|
+
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
|
|
669
|
+
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
|
|
670
|
+
ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
671
|
+
ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
672
|
+
ism_history_max_age_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
673
|
+
ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
|
|
674
|
+
ism_history_rollover_check_period_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
675
|
+
ism_history_rollover_retention_period_days: Optional[pulumi.Input[_builtins.int]] = None,
|
|
676
|
+
override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
677
|
+
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
678
|
+
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
679
|
+
script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
|
|
680
|
+
search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
|
|
681
|
+
thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
682
|
+
thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
683
|
+
thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
684
|
+
thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
685
|
+
thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
686
|
+
thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
687
|
+
thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
688
|
+
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
689
|
+
thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
690
|
+
thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
691
|
+
thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None):
|
|
693
692
|
"""
|
|
694
693
|
Input properties used for looking up and filtering DatabaseOpensearchConfig resources.
|
|
695
|
-
:param pulumi.Input[
|
|
696
|
-
:param pulumi.Input[
|
|
697
|
-
:param pulumi.Input[
|
|
698
|
-
:param pulumi.Input[
|
|
699
|
-
:param pulumi.Input[
|
|
700
|
-
:param pulumi.Input[
|
|
701
|
-
:param pulumi.Input[
|
|
702
|
-
:param pulumi.Input[
|
|
703
|
-
:param pulumi.Input[
|
|
704
|
-
:param pulumi.Input[
|
|
705
|
-
:param pulumi.Input[
|
|
706
|
-
:param pulumi.Input[
|
|
707
|
-
:param pulumi.Input[
|
|
708
|
-
:param pulumi.Input[
|
|
709
|
-
:param pulumi.Input[
|
|
710
|
-
:param pulumi.Input[
|
|
711
|
-
:param pulumi.Input[
|
|
712
|
-
:param pulumi.Input[
|
|
713
|
-
:param pulumi.Input[
|
|
714
|
-
:param pulumi.Input[
|
|
715
|
-
:param pulumi.Input[
|
|
716
|
-
:param pulumi.Input[
|
|
717
|
-
:param pulumi.Input[
|
|
718
|
-
:param pulumi.Input[
|
|
719
|
-
:param pulumi.Input[
|
|
720
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
721
|
-
:param pulumi.Input[
|
|
722
|
-
:param pulumi.Input[
|
|
723
|
-
:param pulumi.Input[
|
|
724
|
-
:param pulumi.Input[
|
|
725
|
-
:param pulumi.Input[
|
|
726
|
-
:param pulumi.Input[
|
|
727
|
-
:param pulumi.Input[
|
|
728
|
-
:param pulumi.Input[
|
|
729
|
-
:param pulumi.Input[
|
|
730
|
-
:param pulumi.Input[
|
|
731
|
-
:param pulumi.Input[
|
|
732
|
-
:param pulumi.Input[
|
|
733
|
-
:param pulumi.Input[
|
|
694
|
+
:param pulumi.Input[_builtins.bool] action_auto_create_index_enabled: Specifices whether to allow automatic creation of indices. Default: `true`
|
|
695
|
+
:param pulumi.Input[_builtins.bool] action_destructive_requires_name: Specifies whether to require explicit index names when deleting indices.
|
|
696
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Opensearch cluster.
|
|
697
|
+
:param pulumi.Input[_builtins.int] cluster_max_shards_per_node: Maximum number of shards allowed per data node.
|
|
698
|
+
:param pulumi.Input[_builtins.int] cluster_routing_allocation_node_concurrent_recoveries: Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
699
|
+
:param pulumi.Input[_builtins.bool] enable_security_audit: Specifies whether to allow security audit logging. Default: `false`
|
|
700
|
+
:param pulumi.Input[_builtins.int] http_max_content_length_bytes: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
701
|
+
:param pulumi.Input[_builtins.int] http_max_header_size_bytes: Maximum size of allowed headers, in bytes. Default: `8192`
|
|
702
|
+
:param pulumi.Input[_builtins.int] http_max_initial_line_length_bytes: Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
703
|
+
:param pulumi.Input[_builtins.int] indices_fielddata_cache_size_percentage: 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.
|
|
704
|
+
:param pulumi.Input[_builtins.int] indices_memory_index_buffer_size_percentage: 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`
|
|
705
|
+
:param pulumi.Input[_builtins.int] indices_memory_max_index_buffer_size_mb: 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.
|
|
706
|
+
:param pulumi.Input[_builtins.int] indices_memory_min_index_buffer_size_mb: 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`
|
|
707
|
+
:param pulumi.Input[_builtins.int] indices_queries_cache_size_percentage: 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`
|
|
708
|
+
:param pulumi.Input[_builtins.int] indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
709
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_concurrent_file_chunks: Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
710
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_mb_per_sec: 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`
|
|
711
|
+
:param pulumi.Input[_builtins.bool] ism_enabled: Specifies whether ISM is enabled or not. Default: `true`
|
|
712
|
+
:param pulumi.Input[_builtins.bool] ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
713
|
+
:param pulumi.Input[_builtins.int] ism_history_max_age_hours: Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
714
|
+
:param pulumi.Input[_builtins.int] ism_history_max_docs: Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
715
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_check_period_hours: The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
716
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_retention_period_days: Length of time long audit history indices are kept, in days. Default: `30`
|
|
717
|
+
:param pulumi.Input[_builtins.bool] override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
718
|
+
:param pulumi.Input[_builtins.bool] plugins_alerting_filter_by_backend_roles_enabled: Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
719
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] reindex_remote_whitelists: Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
720
|
+
:param pulumi.Input[_builtins.str] script_max_compilations_rate: Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
721
|
+
:param pulumi.Input[_builtins.int] search_max_buckets: Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
722
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_queue_size: Size of queue for operations in the analyze thread pool.
|
|
723
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_size: 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.
|
|
724
|
+
:param pulumi.Input[_builtins.int] thread_pool_force_merge_size: 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.
|
|
725
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_queue_size: Size of queue for operations in the get thread pool.
|
|
726
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_size: 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.
|
|
727
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_queue_size: Size of queue for operations in the search thread pool.
|
|
728
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_size: 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.
|
|
729
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_queue_size: Size of queue for operations in the search throttled thread pool.
|
|
730
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_size: 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.
|
|
731
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_queue_size: Size of queue for operations in the write thread pool.
|
|
732
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_size: 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.
|
|
734
733
|
"""
|
|
735
734
|
if action_auto_create_index_enabled is not None:
|
|
736
735
|
pulumi.set(__self__, "action_auto_create_index_enabled", action_auto_create_index_enabled)
|
|
@@ -811,472 +810,472 @@ class _DatabaseOpensearchConfigState:
|
|
|
811
810
|
if thread_pool_write_size is not None:
|
|
812
811
|
pulumi.set(__self__, "thread_pool_write_size", thread_pool_write_size)
|
|
813
812
|
|
|
814
|
-
@property
|
|
813
|
+
@_builtins.property
|
|
815
814
|
@pulumi.getter(name="actionAutoCreateIndexEnabled")
|
|
816
|
-
def action_auto_create_index_enabled(self) -> Optional[pulumi.Input[
|
|
815
|
+
def action_auto_create_index_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
817
816
|
"""
|
|
818
817
|
Specifices whether to allow automatic creation of indices. Default: `true`
|
|
819
818
|
"""
|
|
820
819
|
return pulumi.get(self, "action_auto_create_index_enabled")
|
|
821
820
|
|
|
822
821
|
@action_auto_create_index_enabled.setter
|
|
823
|
-
def action_auto_create_index_enabled(self, value: Optional[pulumi.Input[
|
|
822
|
+
def action_auto_create_index_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
824
823
|
pulumi.set(self, "action_auto_create_index_enabled", value)
|
|
825
824
|
|
|
826
|
-
@property
|
|
825
|
+
@_builtins.property
|
|
827
826
|
@pulumi.getter(name="actionDestructiveRequiresName")
|
|
828
|
-
def action_destructive_requires_name(self) -> Optional[pulumi.Input[
|
|
827
|
+
def action_destructive_requires_name(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
829
828
|
"""
|
|
830
829
|
Specifies whether to require explicit index names when deleting indices.
|
|
831
830
|
"""
|
|
832
831
|
return pulumi.get(self, "action_destructive_requires_name")
|
|
833
832
|
|
|
834
833
|
@action_destructive_requires_name.setter
|
|
835
|
-
def action_destructive_requires_name(self, value: Optional[pulumi.Input[
|
|
834
|
+
def action_destructive_requires_name(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
836
835
|
pulumi.set(self, "action_destructive_requires_name", value)
|
|
837
836
|
|
|
838
|
-
@property
|
|
837
|
+
@_builtins.property
|
|
839
838
|
@pulumi.getter(name="clusterId")
|
|
840
|
-
def cluster_id(self) -> Optional[pulumi.Input[
|
|
839
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
841
840
|
"""
|
|
842
841
|
The ID of the target Opensearch cluster.
|
|
843
842
|
"""
|
|
844
843
|
return pulumi.get(self, "cluster_id")
|
|
845
844
|
|
|
846
845
|
@cluster_id.setter
|
|
847
|
-
def cluster_id(self, value: Optional[pulumi.Input[
|
|
846
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
848
847
|
pulumi.set(self, "cluster_id", value)
|
|
849
848
|
|
|
850
|
-
@property
|
|
849
|
+
@_builtins.property
|
|
851
850
|
@pulumi.getter(name="clusterMaxShardsPerNode")
|
|
852
|
-
def cluster_max_shards_per_node(self) -> Optional[pulumi.Input[
|
|
851
|
+
def cluster_max_shards_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
853
852
|
"""
|
|
854
853
|
Maximum number of shards allowed per data node.
|
|
855
854
|
"""
|
|
856
855
|
return pulumi.get(self, "cluster_max_shards_per_node")
|
|
857
856
|
|
|
858
857
|
@cluster_max_shards_per_node.setter
|
|
859
|
-
def cluster_max_shards_per_node(self, value: Optional[pulumi.Input[
|
|
858
|
+
def cluster_max_shards_per_node(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
860
859
|
pulumi.set(self, "cluster_max_shards_per_node", value)
|
|
861
860
|
|
|
862
|
-
@property
|
|
861
|
+
@_builtins.property
|
|
863
862
|
@pulumi.getter(name="clusterRoutingAllocationNodeConcurrentRecoveries")
|
|
864
|
-
def cluster_routing_allocation_node_concurrent_recoveries(self) -> Optional[pulumi.Input[
|
|
863
|
+
def cluster_routing_allocation_node_concurrent_recoveries(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
865
864
|
"""
|
|
866
865
|
Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
867
866
|
"""
|
|
868
867
|
return pulumi.get(self, "cluster_routing_allocation_node_concurrent_recoveries")
|
|
869
868
|
|
|
870
869
|
@cluster_routing_allocation_node_concurrent_recoveries.setter
|
|
871
|
-
def cluster_routing_allocation_node_concurrent_recoveries(self, value: Optional[pulumi.Input[
|
|
870
|
+
def cluster_routing_allocation_node_concurrent_recoveries(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
872
871
|
pulumi.set(self, "cluster_routing_allocation_node_concurrent_recoveries", value)
|
|
873
872
|
|
|
874
|
-
@property
|
|
873
|
+
@_builtins.property
|
|
875
874
|
@pulumi.getter(name="enableSecurityAudit")
|
|
876
|
-
def enable_security_audit(self) -> Optional[pulumi.Input[
|
|
875
|
+
def enable_security_audit(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
877
876
|
"""
|
|
878
877
|
Specifies whether to allow security audit logging. Default: `false`
|
|
879
878
|
"""
|
|
880
879
|
return pulumi.get(self, "enable_security_audit")
|
|
881
880
|
|
|
882
881
|
@enable_security_audit.setter
|
|
883
|
-
def enable_security_audit(self, value: Optional[pulumi.Input[
|
|
882
|
+
def enable_security_audit(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
884
883
|
pulumi.set(self, "enable_security_audit", value)
|
|
885
884
|
|
|
886
|
-
@property
|
|
885
|
+
@_builtins.property
|
|
887
886
|
@pulumi.getter(name="httpMaxContentLengthBytes")
|
|
888
|
-
def http_max_content_length_bytes(self) -> Optional[pulumi.Input[
|
|
887
|
+
def http_max_content_length_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
889
888
|
"""
|
|
890
889
|
Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
891
890
|
"""
|
|
892
891
|
return pulumi.get(self, "http_max_content_length_bytes")
|
|
893
892
|
|
|
894
893
|
@http_max_content_length_bytes.setter
|
|
895
|
-
def http_max_content_length_bytes(self, value: Optional[pulumi.Input[
|
|
894
|
+
def http_max_content_length_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
896
895
|
pulumi.set(self, "http_max_content_length_bytes", value)
|
|
897
896
|
|
|
898
|
-
@property
|
|
897
|
+
@_builtins.property
|
|
899
898
|
@pulumi.getter(name="httpMaxHeaderSizeBytes")
|
|
900
|
-
def http_max_header_size_bytes(self) -> Optional[pulumi.Input[
|
|
899
|
+
def http_max_header_size_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
901
900
|
"""
|
|
902
901
|
Maximum size of allowed headers, in bytes. Default: `8192`
|
|
903
902
|
"""
|
|
904
903
|
return pulumi.get(self, "http_max_header_size_bytes")
|
|
905
904
|
|
|
906
905
|
@http_max_header_size_bytes.setter
|
|
907
|
-
def http_max_header_size_bytes(self, value: Optional[pulumi.Input[
|
|
906
|
+
def http_max_header_size_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
908
907
|
pulumi.set(self, "http_max_header_size_bytes", value)
|
|
909
908
|
|
|
910
|
-
@property
|
|
909
|
+
@_builtins.property
|
|
911
910
|
@pulumi.getter(name="httpMaxInitialLineLengthBytes")
|
|
912
|
-
def http_max_initial_line_length_bytes(self) -> Optional[pulumi.Input[
|
|
911
|
+
def http_max_initial_line_length_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
913
912
|
"""
|
|
914
913
|
Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
915
914
|
"""
|
|
916
915
|
return pulumi.get(self, "http_max_initial_line_length_bytes")
|
|
917
916
|
|
|
918
917
|
@http_max_initial_line_length_bytes.setter
|
|
919
|
-
def http_max_initial_line_length_bytes(self, value: Optional[pulumi.Input[
|
|
918
|
+
def http_max_initial_line_length_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
920
919
|
pulumi.set(self, "http_max_initial_line_length_bytes", value)
|
|
921
920
|
|
|
922
|
-
@property
|
|
921
|
+
@_builtins.property
|
|
923
922
|
@pulumi.getter(name="indicesFielddataCacheSizePercentage")
|
|
924
|
-
def indices_fielddata_cache_size_percentage(self) -> Optional[pulumi.Input[
|
|
923
|
+
def indices_fielddata_cache_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
925
924
|
"""
|
|
926
925
|
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.
|
|
927
926
|
"""
|
|
928
927
|
return pulumi.get(self, "indices_fielddata_cache_size_percentage")
|
|
929
928
|
|
|
930
929
|
@indices_fielddata_cache_size_percentage.setter
|
|
931
|
-
def indices_fielddata_cache_size_percentage(self, value: Optional[pulumi.Input[
|
|
930
|
+
def indices_fielddata_cache_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
932
931
|
pulumi.set(self, "indices_fielddata_cache_size_percentage", value)
|
|
933
932
|
|
|
934
|
-
@property
|
|
933
|
+
@_builtins.property
|
|
935
934
|
@pulumi.getter(name="indicesMemoryIndexBufferSizePercentage")
|
|
936
|
-
def indices_memory_index_buffer_size_percentage(self) -> Optional[pulumi.Input[
|
|
935
|
+
def indices_memory_index_buffer_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
937
936
|
"""
|
|
938
937
|
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`
|
|
939
938
|
"""
|
|
940
939
|
return pulumi.get(self, "indices_memory_index_buffer_size_percentage")
|
|
941
940
|
|
|
942
941
|
@indices_memory_index_buffer_size_percentage.setter
|
|
943
|
-
def indices_memory_index_buffer_size_percentage(self, value: Optional[pulumi.Input[
|
|
942
|
+
def indices_memory_index_buffer_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
944
943
|
pulumi.set(self, "indices_memory_index_buffer_size_percentage", value)
|
|
945
944
|
|
|
946
|
-
@property
|
|
945
|
+
@_builtins.property
|
|
947
946
|
@pulumi.getter(name="indicesMemoryMaxIndexBufferSizeMb")
|
|
948
|
-
def indices_memory_max_index_buffer_size_mb(self) -> Optional[pulumi.Input[
|
|
947
|
+
def indices_memory_max_index_buffer_size_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
949
948
|
"""
|
|
950
949
|
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.
|
|
951
950
|
"""
|
|
952
951
|
return pulumi.get(self, "indices_memory_max_index_buffer_size_mb")
|
|
953
952
|
|
|
954
953
|
@indices_memory_max_index_buffer_size_mb.setter
|
|
955
|
-
def indices_memory_max_index_buffer_size_mb(self, value: Optional[pulumi.Input[
|
|
954
|
+
def indices_memory_max_index_buffer_size_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
956
955
|
pulumi.set(self, "indices_memory_max_index_buffer_size_mb", value)
|
|
957
956
|
|
|
958
|
-
@property
|
|
957
|
+
@_builtins.property
|
|
959
958
|
@pulumi.getter(name="indicesMemoryMinIndexBufferSizeMb")
|
|
960
|
-
def indices_memory_min_index_buffer_size_mb(self) -> Optional[pulumi.Input[
|
|
959
|
+
def indices_memory_min_index_buffer_size_mb(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
961
960
|
"""
|
|
962
961
|
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`
|
|
963
962
|
"""
|
|
964
963
|
return pulumi.get(self, "indices_memory_min_index_buffer_size_mb")
|
|
965
964
|
|
|
966
965
|
@indices_memory_min_index_buffer_size_mb.setter
|
|
967
|
-
def indices_memory_min_index_buffer_size_mb(self, value: Optional[pulumi.Input[
|
|
966
|
+
def indices_memory_min_index_buffer_size_mb(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
968
967
|
pulumi.set(self, "indices_memory_min_index_buffer_size_mb", value)
|
|
969
968
|
|
|
970
|
-
@property
|
|
969
|
+
@_builtins.property
|
|
971
970
|
@pulumi.getter(name="indicesQueriesCacheSizePercentage")
|
|
972
|
-
def indices_queries_cache_size_percentage(self) -> Optional[pulumi.Input[
|
|
971
|
+
def indices_queries_cache_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
973
972
|
"""
|
|
974
973
|
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`
|
|
975
974
|
"""
|
|
976
975
|
return pulumi.get(self, "indices_queries_cache_size_percentage")
|
|
977
976
|
|
|
978
977
|
@indices_queries_cache_size_percentage.setter
|
|
979
|
-
def indices_queries_cache_size_percentage(self, value: Optional[pulumi.Input[
|
|
978
|
+
def indices_queries_cache_size_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
980
979
|
pulumi.set(self, "indices_queries_cache_size_percentage", value)
|
|
981
980
|
|
|
982
|
-
@property
|
|
981
|
+
@_builtins.property
|
|
983
982
|
@pulumi.getter(name="indicesQueryBoolMaxClauseCount")
|
|
984
|
-
def indices_query_bool_max_clause_count(self) -> Optional[pulumi.Input[
|
|
983
|
+
def indices_query_bool_max_clause_count(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
985
984
|
"""
|
|
986
985
|
Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
987
986
|
"""
|
|
988
987
|
return pulumi.get(self, "indices_query_bool_max_clause_count")
|
|
989
988
|
|
|
990
989
|
@indices_query_bool_max_clause_count.setter
|
|
991
|
-
def indices_query_bool_max_clause_count(self, value: Optional[pulumi.Input[
|
|
990
|
+
def indices_query_bool_max_clause_count(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
992
991
|
pulumi.set(self, "indices_query_bool_max_clause_count", value)
|
|
993
992
|
|
|
994
|
-
@property
|
|
993
|
+
@_builtins.property
|
|
995
994
|
@pulumi.getter(name="indicesRecoveryMaxConcurrentFileChunks")
|
|
996
|
-
def indices_recovery_max_concurrent_file_chunks(self) -> Optional[pulumi.Input[
|
|
995
|
+
def indices_recovery_max_concurrent_file_chunks(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
997
996
|
"""
|
|
998
997
|
Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
999
998
|
"""
|
|
1000
999
|
return pulumi.get(self, "indices_recovery_max_concurrent_file_chunks")
|
|
1001
1000
|
|
|
1002
1001
|
@indices_recovery_max_concurrent_file_chunks.setter
|
|
1003
|
-
def indices_recovery_max_concurrent_file_chunks(self, value: Optional[pulumi.Input[
|
|
1002
|
+
def indices_recovery_max_concurrent_file_chunks(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1004
1003
|
pulumi.set(self, "indices_recovery_max_concurrent_file_chunks", value)
|
|
1005
1004
|
|
|
1006
|
-
@property
|
|
1005
|
+
@_builtins.property
|
|
1007
1006
|
@pulumi.getter(name="indicesRecoveryMaxMbPerSec")
|
|
1008
|
-
def indices_recovery_max_mb_per_sec(self) -> Optional[pulumi.Input[
|
|
1007
|
+
def indices_recovery_max_mb_per_sec(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1009
1008
|
"""
|
|
1010
1009
|
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`
|
|
1011
1010
|
"""
|
|
1012
1011
|
return pulumi.get(self, "indices_recovery_max_mb_per_sec")
|
|
1013
1012
|
|
|
1014
1013
|
@indices_recovery_max_mb_per_sec.setter
|
|
1015
|
-
def indices_recovery_max_mb_per_sec(self, value: Optional[pulumi.Input[
|
|
1014
|
+
def indices_recovery_max_mb_per_sec(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1016
1015
|
pulumi.set(self, "indices_recovery_max_mb_per_sec", value)
|
|
1017
1016
|
|
|
1018
|
-
@property
|
|
1017
|
+
@_builtins.property
|
|
1019
1018
|
@pulumi.getter(name="ismEnabled")
|
|
1020
|
-
def ism_enabled(self) -> Optional[pulumi.Input[
|
|
1019
|
+
def ism_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1021
1020
|
"""
|
|
1022
1021
|
Specifies whether ISM is enabled or not. Default: `true`
|
|
1023
1022
|
"""
|
|
1024
1023
|
return pulumi.get(self, "ism_enabled")
|
|
1025
1024
|
|
|
1026
1025
|
@ism_enabled.setter
|
|
1027
|
-
def ism_enabled(self, value: Optional[pulumi.Input[
|
|
1026
|
+
def ism_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1028
1027
|
pulumi.set(self, "ism_enabled", value)
|
|
1029
1028
|
|
|
1030
|
-
@property
|
|
1029
|
+
@_builtins.property
|
|
1031
1030
|
@pulumi.getter(name="ismHistoryEnabled")
|
|
1032
|
-
def ism_history_enabled(self) -> Optional[pulumi.Input[
|
|
1031
|
+
def ism_history_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1033
1032
|
"""
|
|
1034
1033
|
Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
1035
1034
|
"""
|
|
1036
1035
|
return pulumi.get(self, "ism_history_enabled")
|
|
1037
1036
|
|
|
1038
1037
|
@ism_history_enabled.setter
|
|
1039
|
-
def ism_history_enabled(self, value: Optional[pulumi.Input[
|
|
1038
|
+
def ism_history_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1040
1039
|
pulumi.set(self, "ism_history_enabled", value)
|
|
1041
1040
|
|
|
1042
|
-
@property
|
|
1041
|
+
@_builtins.property
|
|
1043
1042
|
@pulumi.getter(name="ismHistoryMaxAgeHours")
|
|
1044
|
-
def ism_history_max_age_hours(self) -> Optional[pulumi.Input[
|
|
1043
|
+
def ism_history_max_age_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1045
1044
|
"""
|
|
1046
1045
|
Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
1047
1046
|
"""
|
|
1048
1047
|
return pulumi.get(self, "ism_history_max_age_hours")
|
|
1049
1048
|
|
|
1050
1049
|
@ism_history_max_age_hours.setter
|
|
1051
|
-
def ism_history_max_age_hours(self, value: Optional[pulumi.Input[
|
|
1050
|
+
def ism_history_max_age_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1052
1051
|
pulumi.set(self, "ism_history_max_age_hours", value)
|
|
1053
1052
|
|
|
1054
|
-
@property
|
|
1053
|
+
@_builtins.property
|
|
1055
1054
|
@pulumi.getter(name="ismHistoryMaxDocs")
|
|
1056
|
-
def ism_history_max_docs(self) -> Optional[pulumi.Input[
|
|
1055
|
+
def ism_history_max_docs(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1057
1056
|
"""
|
|
1058
1057
|
Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
1059
1058
|
"""
|
|
1060
1059
|
return pulumi.get(self, "ism_history_max_docs")
|
|
1061
1060
|
|
|
1062
1061
|
@ism_history_max_docs.setter
|
|
1063
|
-
def ism_history_max_docs(self, value: Optional[pulumi.Input[
|
|
1062
|
+
def ism_history_max_docs(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1064
1063
|
pulumi.set(self, "ism_history_max_docs", value)
|
|
1065
1064
|
|
|
1066
|
-
@property
|
|
1065
|
+
@_builtins.property
|
|
1067
1066
|
@pulumi.getter(name="ismHistoryRolloverCheckPeriodHours")
|
|
1068
|
-
def ism_history_rollover_check_period_hours(self) -> Optional[pulumi.Input[
|
|
1067
|
+
def ism_history_rollover_check_period_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1069
1068
|
"""
|
|
1070
1069
|
The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
1071
1070
|
"""
|
|
1072
1071
|
return pulumi.get(self, "ism_history_rollover_check_period_hours")
|
|
1073
1072
|
|
|
1074
1073
|
@ism_history_rollover_check_period_hours.setter
|
|
1075
|
-
def ism_history_rollover_check_period_hours(self, value: Optional[pulumi.Input[
|
|
1074
|
+
def ism_history_rollover_check_period_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1076
1075
|
pulumi.set(self, "ism_history_rollover_check_period_hours", value)
|
|
1077
1076
|
|
|
1078
|
-
@property
|
|
1077
|
+
@_builtins.property
|
|
1079
1078
|
@pulumi.getter(name="ismHistoryRolloverRetentionPeriodDays")
|
|
1080
|
-
def ism_history_rollover_retention_period_days(self) -> Optional[pulumi.Input[
|
|
1079
|
+
def ism_history_rollover_retention_period_days(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1081
1080
|
"""
|
|
1082
1081
|
Length of time long audit history indices are kept, in days. Default: `30`
|
|
1083
1082
|
"""
|
|
1084
1083
|
return pulumi.get(self, "ism_history_rollover_retention_period_days")
|
|
1085
1084
|
|
|
1086
1085
|
@ism_history_rollover_retention_period_days.setter
|
|
1087
|
-
def ism_history_rollover_retention_period_days(self, value: Optional[pulumi.Input[
|
|
1086
|
+
def ism_history_rollover_retention_period_days(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1088
1087
|
pulumi.set(self, "ism_history_rollover_retention_period_days", value)
|
|
1089
1088
|
|
|
1090
|
-
@property
|
|
1089
|
+
@_builtins.property
|
|
1091
1090
|
@pulumi.getter(name="overrideMainResponseVersion")
|
|
1092
|
-
def override_main_response_version(self) -> Optional[pulumi.Input[
|
|
1091
|
+
def override_main_response_version(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1093
1092
|
"""
|
|
1094
1093
|
Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
1095
1094
|
"""
|
|
1096
1095
|
return pulumi.get(self, "override_main_response_version")
|
|
1097
1096
|
|
|
1098
1097
|
@override_main_response_version.setter
|
|
1099
|
-
def override_main_response_version(self, value: Optional[pulumi.Input[
|
|
1098
|
+
def override_main_response_version(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1100
1099
|
pulumi.set(self, "override_main_response_version", value)
|
|
1101
1100
|
|
|
1102
|
-
@property
|
|
1101
|
+
@_builtins.property
|
|
1103
1102
|
@pulumi.getter(name="pluginsAlertingFilterByBackendRolesEnabled")
|
|
1104
|
-
def plugins_alerting_filter_by_backend_roles_enabled(self) -> Optional[pulumi.Input[
|
|
1103
|
+
def plugins_alerting_filter_by_backend_roles_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1105
1104
|
"""
|
|
1106
1105
|
Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
1107
1106
|
"""
|
|
1108
1107
|
return pulumi.get(self, "plugins_alerting_filter_by_backend_roles_enabled")
|
|
1109
1108
|
|
|
1110
1109
|
@plugins_alerting_filter_by_backend_roles_enabled.setter
|
|
1111
|
-
def plugins_alerting_filter_by_backend_roles_enabled(self, value: Optional[pulumi.Input[
|
|
1110
|
+
def plugins_alerting_filter_by_backend_roles_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1112
1111
|
pulumi.set(self, "plugins_alerting_filter_by_backend_roles_enabled", value)
|
|
1113
1112
|
|
|
1114
|
-
@property
|
|
1113
|
+
@_builtins.property
|
|
1115
1114
|
@pulumi.getter(name="reindexRemoteWhitelists")
|
|
1116
|
-
def reindex_remote_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1115
|
+
def reindex_remote_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1117
1116
|
"""
|
|
1118
1117
|
Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
1119
1118
|
"""
|
|
1120
1119
|
return pulumi.get(self, "reindex_remote_whitelists")
|
|
1121
1120
|
|
|
1122
1121
|
@reindex_remote_whitelists.setter
|
|
1123
|
-
def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1122
|
+
def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1124
1123
|
pulumi.set(self, "reindex_remote_whitelists", value)
|
|
1125
1124
|
|
|
1126
|
-
@property
|
|
1125
|
+
@_builtins.property
|
|
1127
1126
|
@pulumi.getter(name="scriptMaxCompilationsRate")
|
|
1128
|
-
def script_max_compilations_rate(self) -> Optional[pulumi.Input[
|
|
1127
|
+
def script_max_compilations_rate(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1129
1128
|
"""
|
|
1130
1129
|
Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
1131
1130
|
"""
|
|
1132
1131
|
return pulumi.get(self, "script_max_compilations_rate")
|
|
1133
1132
|
|
|
1134
1133
|
@script_max_compilations_rate.setter
|
|
1135
|
-
def script_max_compilations_rate(self, value: Optional[pulumi.Input[
|
|
1134
|
+
def script_max_compilations_rate(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1136
1135
|
pulumi.set(self, "script_max_compilations_rate", value)
|
|
1137
1136
|
|
|
1138
|
-
@property
|
|
1137
|
+
@_builtins.property
|
|
1139
1138
|
@pulumi.getter(name="searchMaxBuckets")
|
|
1140
|
-
def search_max_buckets(self) -> Optional[pulumi.Input[
|
|
1139
|
+
def search_max_buckets(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1141
1140
|
"""
|
|
1142
1141
|
Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
1143
1142
|
"""
|
|
1144
1143
|
return pulumi.get(self, "search_max_buckets")
|
|
1145
1144
|
|
|
1146
1145
|
@search_max_buckets.setter
|
|
1147
|
-
def search_max_buckets(self, value: Optional[pulumi.Input[
|
|
1146
|
+
def search_max_buckets(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1148
1147
|
pulumi.set(self, "search_max_buckets", value)
|
|
1149
1148
|
|
|
1150
|
-
@property
|
|
1149
|
+
@_builtins.property
|
|
1151
1150
|
@pulumi.getter(name="threadPoolAnalyzeQueueSize")
|
|
1152
|
-
def thread_pool_analyze_queue_size(self) -> Optional[pulumi.Input[
|
|
1151
|
+
def thread_pool_analyze_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1153
1152
|
"""
|
|
1154
1153
|
Size of queue for operations in the analyze thread pool.
|
|
1155
1154
|
"""
|
|
1156
1155
|
return pulumi.get(self, "thread_pool_analyze_queue_size")
|
|
1157
1156
|
|
|
1158
1157
|
@thread_pool_analyze_queue_size.setter
|
|
1159
|
-
def thread_pool_analyze_queue_size(self, value: Optional[pulumi.Input[
|
|
1158
|
+
def thread_pool_analyze_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1160
1159
|
pulumi.set(self, "thread_pool_analyze_queue_size", value)
|
|
1161
1160
|
|
|
1162
|
-
@property
|
|
1161
|
+
@_builtins.property
|
|
1163
1162
|
@pulumi.getter(name="threadPoolAnalyzeSize")
|
|
1164
|
-
def thread_pool_analyze_size(self) -> Optional[pulumi.Input[
|
|
1163
|
+
def thread_pool_analyze_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1165
1164
|
"""
|
|
1166
1165
|
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.
|
|
1167
1166
|
"""
|
|
1168
1167
|
return pulumi.get(self, "thread_pool_analyze_size")
|
|
1169
1168
|
|
|
1170
1169
|
@thread_pool_analyze_size.setter
|
|
1171
|
-
def thread_pool_analyze_size(self, value: Optional[pulumi.Input[
|
|
1170
|
+
def thread_pool_analyze_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1172
1171
|
pulumi.set(self, "thread_pool_analyze_size", value)
|
|
1173
1172
|
|
|
1174
|
-
@property
|
|
1173
|
+
@_builtins.property
|
|
1175
1174
|
@pulumi.getter(name="threadPoolForceMergeSize")
|
|
1176
|
-
def thread_pool_force_merge_size(self) -> Optional[pulumi.Input[
|
|
1175
|
+
def thread_pool_force_merge_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1177
1176
|
"""
|
|
1178
1177
|
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.
|
|
1179
1178
|
"""
|
|
1180
1179
|
return pulumi.get(self, "thread_pool_force_merge_size")
|
|
1181
1180
|
|
|
1182
1181
|
@thread_pool_force_merge_size.setter
|
|
1183
|
-
def thread_pool_force_merge_size(self, value: Optional[pulumi.Input[
|
|
1182
|
+
def thread_pool_force_merge_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1184
1183
|
pulumi.set(self, "thread_pool_force_merge_size", value)
|
|
1185
1184
|
|
|
1186
|
-
@property
|
|
1185
|
+
@_builtins.property
|
|
1187
1186
|
@pulumi.getter(name="threadPoolGetQueueSize")
|
|
1188
|
-
def thread_pool_get_queue_size(self) -> Optional[pulumi.Input[
|
|
1187
|
+
def thread_pool_get_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1189
1188
|
"""
|
|
1190
1189
|
Size of queue for operations in the get thread pool.
|
|
1191
1190
|
"""
|
|
1192
1191
|
return pulumi.get(self, "thread_pool_get_queue_size")
|
|
1193
1192
|
|
|
1194
1193
|
@thread_pool_get_queue_size.setter
|
|
1195
|
-
def thread_pool_get_queue_size(self, value: Optional[pulumi.Input[
|
|
1194
|
+
def thread_pool_get_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1196
1195
|
pulumi.set(self, "thread_pool_get_queue_size", value)
|
|
1197
1196
|
|
|
1198
|
-
@property
|
|
1197
|
+
@_builtins.property
|
|
1199
1198
|
@pulumi.getter(name="threadPoolGetSize")
|
|
1200
|
-
def thread_pool_get_size(self) -> Optional[pulumi.Input[
|
|
1199
|
+
def thread_pool_get_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1201
1200
|
"""
|
|
1202
1201
|
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.
|
|
1203
1202
|
"""
|
|
1204
1203
|
return pulumi.get(self, "thread_pool_get_size")
|
|
1205
1204
|
|
|
1206
1205
|
@thread_pool_get_size.setter
|
|
1207
|
-
def thread_pool_get_size(self, value: Optional[pulumi.Input[
|
|
1206
|
+
def thread_pool_get_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1208
1207
|
pulumi.set(self, "thread_pool_get_size", value)
|
|
1209
1208
|
|
|
1210
|
-
@property
|
|
1209
|
+
@_builtins.property
|
|
1211
1210
|
@pulumi.getter(name="threadPoolSearchQueueSize")
|
|
1212
|
-
def thread_pool_search_queue_size(self) -> Optional[pulumi.Input[
|
|
1211
|
+
def thread_pool_search_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1213
1212
|
"""
|
|
1214
1213
|
Size of queue for operations in the search thread pool.
|
|
1215
1214
|
"""
|
|
1216
1215
|
return pulumi.get(self, "thread_pool_search_queue_size")
|
|
1217
1216
|
|
|
1218
1217
|
@thread_pool_search_queue_size.setter
|
|
1219
|
-
def thread_pool_search_queue_size(self, value: Optional[pulumi.Input[
|
|
1218
|
+
def thread_pool_search_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1220
1219
|
pulumi.set(self, "thread_pool_search_queue_size", value)
|
|
1221
1220
|
|
|
1222
|
-
@property
|
|
1221
|
+
@_builtins.property
|
|
1223
1222
|
@pulumi.getter(name="threadPoolSearchSize")
|
|
1224
|
-
def thread_pool_search_size(self) -> Optional[pulumi.Input[
|
|
1223
|
+
def thread_pool_search_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1225
1224
|
"""
|
|
1226
1225
|
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.
|
|
1227
1226
|
"""
|
|
1228
1227
|
return pulumi.get(self, "thread_pool_search_size")
|
|
1229
1228
|
|
|
1230
1229
|
@thread_pool_search_size.setter
|
|
1231
|
-
def thread_pool_search_size(self, value: Optional[pulumi.Input[
|
|
1230
|
+
def thread_pool_search_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1232
1231
|
pulumi.set(self, "thread_pool_search_size", value)
|
|
1233
1232
|
|
|
1234
|
-
@property
|
|
1233
|
+
@_builtins.property
|
|
1235
1234
|
@pulumi.getter(name="threadPoolSearchThrottledQueueSize")
|
|
1236
|
-
def thread_pool_search_throttled_queue_size(self) -> Optional[pulumi.Input[
|
|
1235
|
+
def thread_pool_search_throttled_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1237
1236
|
"""
|
|
1238
1237
|
Size of queue for operations in the search throttled thread pool.
|
|
1239
1238
|
"""
|
|
1240
1239
|
return pulumi.get(self, "thread_pool_search_throttled_queue_size")
|
|
1241
1240
|
|
|
1242
1241
|
@thread_pool_search_throttled_queue_size.setter
|
|
1243
|
-
def thread_pool_search_throttled_queue_size(self, value: Optional[pulumi.Input[
|
|
1242
|
+
def thread_pool_search_throttled_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1244
1243
|
pulumi.set(self, "thread_pool_search_throttled_queue_size", value)
|
|
1245
1244
|
|
|
1246
|
-
@property
|
|
1245
|
+
@_builtins.property
|
|
1247
1246
|
@pulumi.getter(name="threadPoolSearchThrottledSize")
|
|
1248
|
-
def thread_pool_search_throttled_size(self) -> Optional[pulumi.Input[
|
|
1247
|
+
def thread_pool_search_throttled_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1249
1248
|
"""
|
|
1250
1249
|
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.
|
|
1251
1250
|
"""
|
|
1252
1251
|
return pulumi.get(self, "thread_pool_search_throttled_size")
|
|
1253
1252
|
|
|
1254
1253
|
@thread_pool_search_throttled_size.setter
|
|
1255
|
-
def thread_pool_search_throttled_size(self, value: Optional[pulumi.Input[
|
|
1254
|
+
def thread_pool_search_throttled_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1256
1255
|
pulumi.set(self, "thread_pool_search_throttled_size", value)
|
|
1257
1256
|
|
|
1258
|
-
@property
|
|
1257
|
+
@_builtins.property
|
|
1259
1258
|
@pulumi.getter(name="threadPoolWriteQueueSize")
|
|
1260
|
-
def thread_pool_write_queue_size(self) -> Optional[pulumi.Input[
|
|
1259
|
+
def thread_pool_write_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1261
1260
|
"""
|
|
1262
1261
|
Size of queue for operations in the write thread pool.
|
|
1263
1262
|
"""
|
|
1264
1263
|
return pulumi.get(self, "thread_pool_write_queue_size")
|
|
1265
1264
|
|
|
1266
1265
|
@thread_pool_write_queue_size.setter
|
|
1267
|
-
def thread_pool_write_queue_size(self, value: Optional[pulumi.Input[
|
|
1266
|
+
def thread_pool_write_queue_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1268
1267
|
pulumi.set(self, "thread_pool_write_queue_size", value)
|
|
1269
1268
|
|
|
1270
|
-
@property
|
|
1269
|
+
@_builtins.property
|
|
1271
1270
|
@pulumi.getter(name="threadPoolWriteSize")
|
|
1272
|
-
def thread_pool_write_size(self) -> Optional[pulumi.Input[
|
|
1271
|
+
def thread_pool_write_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1273
1272
|
"""
|
|
1274
1273
|
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.
|
|
1275
1274
|
"""
|
|
1276
1275
|
return pulumi.get(self, "thread_pool_write_size")
|
|
1277
1276
|
|
|
1278
1277
|
@thread_pool_write_size.setter
|
|
1279
|
-
def thread_pool_write_size(self, value: Optional[pulumi.Input[
|
|
1278
|
+
def thread_pool_write_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1280
1279
|
pulumi.set(self, "thread_pool_write_size", value)
|
|
1281
1280
|
|
|
1282
1281
|
|
|
@@ -1286,45 +1285,45 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1286
1285
|
def __init__(__self__,
|
|
1287
1286
|
resource_name: str,
|
|
1288
1287
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1289
|
-
action_auto_create_index_enabled: Optional[pulumi.Input[
|
|
1290
|
-
action_destructive_requires_name: Optional[pulumi.Input[
|
|
1291
|
-
cluster_id: Optional[pulumi.Input[
|
|
1292
|
-
cluster_max_shards_per_node: Optional[pulumi.Input[
|
|
1293
|
-
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[
|
|
1294
|
-
enable_security_audit: Optional[pulumi.Input[
|
|
1295
|
-
http_max_content_length_bytes: Optional[pulumi.Input[
|
|
1296
|
-
http_max_header_size_bytes: Optional[pulumi.Input[
|
|
1297
|
-
http_max_initial_line_length_bytes: Optional[pulumi.Input[
|
|
1298
|
-
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[
|
|
1299
|
-
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[
|
|
1300
|
-
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1301
|
-
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1302
|
-
indices_queries_cache_size_percentage: Optional[pulumi.Input[
|
|
1303
|
-
indices_query_bool_max_clause_count: Optional[pulumi.Input[
|
|
1304
|
-
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[
|
|
1305
|
-
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[
|
|
1306
|
-
ism_enabled: Optional[pulumi.Input[
|
|
1307
|
-
ism_history_enabled: Optional[pulumi.Input[
|
|
1308
|
-
ism_history_max_age_hours: Optional[pulumi.Input[
|
|
1309
|
-
ism_history_max_docs: Optional[pulumi.Input[
|
|
1310
|
-
ism_history_rollover_check_period_hours: Optional[pulumi.Input[
|
|
1311
|
-
ism_history_rollover_retention_period_days: Optional[pulumi.Input[
|
|
1312
|
-
override_main_response_version: Optional[pulumi.Input[
|
|
1313
|
-
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[
|
|
1314
|
-
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1315
|
-
script_max_compilations_rate: Optional[pulumi.Input[
|
|
1316
|
-
search_max_buckets: Optional[pulumi.Input[
|
|
1317
|
-
thread_pool_analyze_queue_size: Optional[pulumi.Input[
|
|
1318
|
-
thread_pool_analyze_size: Optional[pulumi.Input[
|
|
1319
|
-
thread_pool_force_merge_size: Optional[pulumi.Input[
|
|
1320
|
-
thread_pool_get_queue_size: Optional[pulumi.Input[
|
|
1321
|
-
thread_pool_get_size: Optional[pulumi.Input[
|
|
1322
|
-
thread_pool_search_queue_size: Optional[pulumi.Input[
|
|
1323
|
-
thread_pool_search_size: Optional[pulumi.Input[
|
|
1324
|
-
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[
|
|
1325
|
-
thread_pool_search_throttled_size: Optional[pulumi.Input[
|
|
1326
|
-
thread_pool_write_queue_size: Optional[pulumi.Input[
|
|
1327
|
-
thread_pool_write_size: Optional[pulumi.Input[
|
|
1288
|
+
action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1289
|
+
action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1290
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1291
|
+
cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1292
|
+
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1293
|
+
enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1294
|
+
http_max_content_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1295
|
+
http_max_header_size_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1296
|
+
http_max_initial_line_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1297
|
+
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1298
|
+
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1299
|
+
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1300
|
+
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1301
|
+
indices_queries_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1302
|
+
indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1303
|
+
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1304
|
+
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1305
|
+
ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1306
|
+
ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1307
|
+
ism_history_max_age_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1308
|
+
ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1309
|
+
ism_history_rollover_check_period_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1310
|
+
ism_history_rollover_retention_period_days: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1311
|
+
override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1312
|
+
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1313
|
+
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1314
|
+
script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1315
|
+
search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1316
|
+
thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1317
|
+
thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1318
|
+
thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1319
|
+
thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1320
|
+
thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1321
|
+
thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1322
|
+
thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1323
|
+
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1324
|
+
thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1325
|
+
thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1326
|
+
thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1328
1327
|
__props__=None):
|
|
1329
1328
|
"""
|
|
1330
1329
|
Provides a virtual resource that can be used to change advanced configuration
|
|
@@ -1397,45 +1396,45 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1397
1396
|
|
|
1398
1397
|
:param str resource_name: The name of the resource.
|
|
1399
1398
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1400
|
-
:param pulumi.Input[
|
|
1401
|
-
:param pulumi.Input[
|
|
1402
|
-
:param pulumi.Input[
|
|
1403
|
-
:param pulumi.Input[
|
|
1404
|
-
:param pulumi.Input[
|
|
1405
|
-
:param pulumi.Input[
|
|
1406
|
-
:param pulumi.Input[
|
|
1407
|
-
:param pulumi.Input[
|
|
1408
|
-
:param pulumi.Input[
|
|
1409
|
-
:param pulumi.Input[
|
|
1410
|
-
:param pulumi.Input[
|
|
1411
|
-
:param pulumi.Input[
|
|
1412
|
-
:param pulumi.Input[
|
|
1413
|
-
:param pulumi.Input[
|
|
1414
|
-
:param pulumi.Input[
|
|
1415
|
-
:param pulumi.Input[
|
|
1416
|
-
:param pulumi.Input[
|
|
1417
|
-
:param pulumi.Input[
|
|
1418
|
-
:param pulumi.Input[
|
|
1419
|
-
:param pulumi.Input[
|
|
1420
|
-
:param pulumi.Input[
|
|
1421
|
-
:param pulumi.Input[
|
|
1422
|
-
:param pulumi.Input[
|
|
1423
|
-
:param pulumi.Input[
|
|
1424
|
-
:param pulumi.Input[
|
|
1425
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1426
|
-
:param pulumi.Input[
|
|
1427
|
-
:param pulumi.Input[
|
|
1428
|
-
:param pulumi.Input[
|
|
1429
|
-
:param pulumi.Input[
|
|
1430
|
-
:param pulumi.Input[
|
|
1431
|
-
:param pulumi.Input[
|
|
1432
|
-
:param pulumi.Input[
|
|
1433
|
-
:param pulumi.Input[
|
|
1434
|
-
:param pulumi.Input[
|
|
1435
|
-
:param pulumi.Input[
|
|
1436
|
-
:param pulumi.Input[
|
|
1437
|
-
:param pulumi.Input[
|
|
1438
|
-
:param pulumi.Input[
|
|
1399
|
+
:param pulumi.Input[_builtins.bool] action_auto_create_index_enabled: Specifices whether to allow automatic creation of indices. Default: `true`
|
|
1400
|
+
:param pulumi.Input[_builtins.bool] action_destructive_requires_name: Specifies whether to require explicit index names when deleting indices.
|
|
1401
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Opensearch cluster.
|
|
1402
|
+
:param pulumi.Input[_builtins.int] cluster_max_shards_per_node: Maximum number of shards allowed per data node.
|
|
1403
|
+
:param pulumi.Input[_builtins.int] cluster_routing_allocation_node_concurrent_recoveries: Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
1404
|
+
:param pulumi.Input[_builtins.bool] enable_security_audit: Specifies whether to allow security audit logging. Default: `false`
|
|
1405
|
+
:param pulumi.Input[_builtins.int] http_max_content_length_bytes: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
1406
|
+
:param pulumi.Input[_builtins.int] http_max_header_size_bytes: Maximum size of allowed headers, in bytes. Default: `8192`
|
|
1407
|
+
:param pulumi.Input[_builtins.int] http_max_initial_line_length_bytes: Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
1408
|
+
:param pulumi.Input[_builtins.int] indices_fielddata_cache_size_percentage: 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.
|
|
1409
|
+
:param pulumi.Input[_builtins.int] indices_memory_index_buffer_size_percentage: 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`
|
|
1410
|
+
:param pulumi.Input[_builtins.int] indices_memory_max_index_buffer_size_mb: 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.
|
|
1411
|
+
:param pulumi.Input[_builtins.int] indices_memory_min_index_buffer_size_mb: 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`
|
|
1412
|
+
:param pulumi.Input[_builtins.int] indices_queries_cache_size_percentage: 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`
|
|
1413
|
+
:param pulumi.Input[_builtins.int] indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
1414
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_concurrent_file_chunks: Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
1415
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_mb_per_sec: 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`
|
|
1416
|
+
:param pulumi.Input[_builtins.bool] ism_enabled: Specifies whether ISM is enabled or not. Default: `true`
|
|
1417
|
+
:param pulumi.Input[_builtins.bool] ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
1418
|
+
:param pulumi.Input[_builtins.int] ism_history_max_age_hours: Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
1419
|
+
:param pulumi.Input[_builtins.int] ism_history_max_docs: Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
1420
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_check_period_hours: The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
1421
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_retention_period_days: Length of time long audit history indices are kept, in days. Default: `30`
|
|
1422
|
+
:param pulumi.Input[_builtins.bool] override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
1423
|
+
:param pulumi.Input[_builtins.bool] plugins_alerting_filter_by_backend_roles_enabled: Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
1424
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] reindex_remote_whitelists: Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
1425
|
+
:param pulumi.Input[_builtins.str] script_max_compilations_rate: Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
1426
|
+
:param pulumi.Input[_builtins.int] search_max_buckets: Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
1427
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_queue_size: Size of queue for operations in the analyze thread pool.
|
|
1428
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_size: 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.
|
|
1429
|
+
:param pulumi.Input[_builtins.int] thread_pool_force_merge_size: 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.
|
|
1430
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_queue_size: Size of queue for operations in the get thread pool.
|
|
1431
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_size: 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.
|
|
1432
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_queue_size: Size of queue for operations in the search thread pool.
|
|
1433
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_size: 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.
|
|
1434
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_queue_size: Size of queue for operations in the search throttled thread pool.
|
|
1435
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_size: 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.
|
|
1436
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_queue_size: Size of queue for operations in the write thread pool.
|
|
1437
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_size: 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.
|
|
1439
1438
|
"""
|
|
1440
1439
|
...
|
|
1441
1440
|
@overload
|
|
@@ -1527,45 +1526,45 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1527
1526
|
def _internal_init(__self__,
|
|
1528
1527
|
resource_name: str,
|
|
1529
1528
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1530
|
-
action_auto_create_index_enabled: Optional[pulumi.Input[
|
|
1531
|
-
action_destructive_requires_name: Optional[pulumi.Input[
|
|
1532
|
-
cluster_id: Optional[pulumi.Input[
|
|
1533
|
-
cluster_max_shards_per_node: Optional[pulumi.Input[
|
|
1534
|
-
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[
|
|
1535
|
-
enable_security_audit: Optional[pulumi.Input[
|
|
1536
|
-
http_max_content_length_bytes: Optional[pulumi.Input[
|
|
1537
|
-
http_max_header_size_bytes: Optional[pulumi.Input[
|
|
1538
|
-
http_max_initial_line_length_bytes: Optional[pulumi.Input[
|
|
1539
|
-
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[
|
|
1540
|
-
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[
|
|
1541
|
-
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1542
|
-
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1543
|
-
indices_queries_cache_size_percentage: Optional[pulumi.Input[
|
|
1544
|
-
indices_query_bool_max_clause_count: Optional[pulumi.Input[
|
|
1545
|
-
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[
|
|
1546
|
-
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[
|
|
1547
|
-
ism_enabled: Optional[pulumi.Input[
|
|
1548
|
-
ism_history_enabled: Optional[pulumi.Input[
|
|
1549
|
-
ism_history_max_age_hours: Optional[pulumi.Input[
|
|
1550
|
-
ism_history_max_docs: Optional[pulumi.Input[
|
|
1551
|
-
ism_history_rollover_check_period_hours: Optional[pulumi.Input[
|
|
1552
|
-
ism_history_rollover_retention_period_days: Optional[pulumi.Input[
|
|
1553
|
-
override_main_response_version: Optional[pulumi.Input[
|
|
1554
|
-
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[
|
|
1555
|
-
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1556
|
-
script_max_compilations_rate: Optional[pulumi.Input[
|
|
1557
|
-
search_max_buckets: Optional[pulumi.Input[
|
|
1558
|
-
thread_pool_analyze_queue_size: Optional[pulumi.Input[
|
|
1559
|
-
thread_pool_analyze_size: Optional[pulumi.Input[
|
|
1560
|
-
thread_pool_force_merge_size: Optional[pulumi.Input[
|
|
1561
|
-
thread_pool_get_queue_size: Optional[pulumi.Input[
|
|
1562
|
-
thread_pool_get_size: Optional[pulumi.Input[
|
|
1563
|
-
thread_pool_search_queue_size: Optional[pulumi.Input[
|
|
1564
|
-
thread_pool_search_size: Optional[pulumi.Input[
|
|
1565
|
-
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[
|
|
1566
|
-
thread_pool_search_throttled_size: Optional[pulumi.Input[
|
|
1567
|
-
thread_pool_write_queue_size: Optional[pulumi.Input[
|
|
1568
|
-
thread_pool_write_size: Optional[pulumi.Input[
|
|
1529
|
+
action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1530
|
+
action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1531
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1532
|
+
cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1533
|
+
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1534
|
+
enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1535
|
+
http_max_content_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1536
|
+
http_max_header_size_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1537
|
+
http_max_initial_line_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1538
|
+
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1539
|
+
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1540
|
+
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1541
|
+
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1542
|
+
indices_queries_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1543
|
+
indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1544
|
+
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1545
|
+
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1546
|
+
ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1547
|
+
ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1548
|
+
ism_history_max_age_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1549
|
+
ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1550
|
+
ism_history_rollover_check_period_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1551
|
+
ism_history_rollover_retention_period_days: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1552
|
+
override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1553
|
+
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1554
|
+
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1555
|
+
script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1556
|
+
search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1557
|
+
thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1558
|
+
thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1559
|
+
thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1560
|
+
thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1561
|
+
thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1562
|
+
thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1563
|
+
thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1564
|
+
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1565
|
+
thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1566
|
+
thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1567
|
+
thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1569
1568
|
__props__=None):
|
|
1570
1569
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1571
1570
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1626,45 +1625,45 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1626
1625
|
def get(resource_name: str,
|
|
1627
1626
|
id: pulumi.Input[str],
|
|
1628
1627
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1629
|
-
action_auto_create_index_enabled: Optional[pulumi.Input[
|
|
1630
|
-
action_destructive_requires_name: Optional[pulumi.Input[
|
|
1631
|
-
cluster_id: Optional[pulumi.Input[
|
|
1632
|
-
cluster_max_shards_per_node: Optional[pulumi.Input[
|
|
1633
|
-
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[
|
|
1634
|
-
enable_security_audit: Optional[pulumi.Input[
|
|
1635
|
-
http_max_content_length_bytes: Optional[pulumi.Input[
|
|
1636
|
-
http_max_header_size_bytes: Optional[pulumi.Input[
|
|
1637
|
-
http_max_initial_line_length_bytes: Optional[pulumi.Input[
|
|
1638
|
-
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[
|
|
1639
|
-
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[
|
|
1640
|
-
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1641
|
-
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[
|
|
1642
|
-
indices_queries_cache_size_percentage: Optional[pulumi.Input[
|
|
1643
|
-
indices_query_bool_max_clause_count: Optional[pulumi.Input[
|
|
1644
|
-
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[
|
|
1645
|
-
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[
|
|
1646
|
-
ism_enabled: Optional[pulumi.Input[
|
|
1647
|
-
ism_history_enabled: Optional[pulumi.Input[
|
|
1648
|
-
ism_history_max_age_hours: Optional[pulumi.Input[
|
|
1649
|
-
ism_history_max_docs: Optional[pulumi.Input[
|
|
1650
|
-
ism_history_rollover_check_period_hours: Optional[pulumi.Input[
|
|
1651
|
-
ism_history_rollover_retention_period_days: Optional[pulumi.Input[
|
|
1652
|
-
override_main_response_version: Optional[pulumi.Input[
|
|
1653
|
-
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[
|
|
1654
|
-
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1655
|
-
script_max_compilations_rate: Optional[pulumi.Input[
|
|
1656
|
-
search_max_buckets: Optional[pulumi.Input[
|
|
1657
|
-
thread_pool_analyze_queue_size: Optional[pulumi.Input[
|
|
1658
|
-
thread_pool_analyze_size: Optional[pulumi.Input[
|
|
1659
|
-
thread_pool_force_merge_size: Optional[pulumi.Input[
|
|
1660
|
-
thread_pool_get_queue_size: Optional[pulumi.Input[
|
|
1661
|
-
thread_pool_get_size: Optional[pulumi.Input[
|
|
1662
|
-
thread_pool_search_queue_size: Optional[pulumi.Input[
|
|
1663
|
-
thread_pool_search_size: Optional[pulumi.Input[
|
|
1664
|
-
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[
|
|
1665
|
-
thread_pool_search_throttled_size: Optional[pulumi.Input[
|
|
1666
|
-
thread_pool_write_queue_size: Optional[pulumi.Input[
|
|
1667
|
-
thread_pool_write_size: Optional[pulumi.Input[
|
|
1628
|
+
action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1629
|
+
action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1630
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1631
|
+
cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1632
|
+
cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1633
|
+
enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1634
|
+
http_max_content_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1635
|
+
http_max_header_size_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1636
|
+
http_max_initial_line_length_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1637
|
+
indices_fielddata_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1638
|
+
indices_memory_index_buffer_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1639
|
+
indices_memory_max_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1640
|
+
indices_memory_min_index_buffer_size_mb: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1641
|
+
indices_queries_cache_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1642
|
+
indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1643
|
+
indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1644
|
+
indices_recovery_max_mb_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1645
|
+
ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1646
|
+
ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1647
|
+
ism_history_max_age_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1648
|
+
ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1649
|
+
ism_history_rollover_check_period_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1650
|
+
ism_history_rollover_retention_period_days: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1651
|
+
override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1652
|
+
plugins_alerting_filter_by_backend_roles_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1653
|
+
reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1654
|
+
script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1655
|
+
search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1656
|
+
thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1657
|
+
thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1658
|
+
thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1659
|
+
thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1660
|
+
thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1661
|
+
thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1662
|
+
thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1663
|
+
thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1664
|
+
thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1665
|
+
thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1666
|
+
thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabaseOpensearchConfig':
|
|
1668
1667
|
"""
|
|
1669
1668
|
Get an existing DatabaseOpensearchConfig resource's state with the given name, id, and optional extra
|
|
1670
1669
|
properties used to qualify the lookup.
|
|
@@ -1672,45 +1671,45 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1672
1671
|
:param str resource_name: The unique name of the resulting resource.
|
|
1673
1672
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1674
1673
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1675
|
-
:param pulumi.Input[
|
|
1676
|
-
:param pulumi.Input[
|
|
1677
|
-
:param pulumi.Input[
|
|
1678
|
-
:param pulumi.Input[
|
|
1679
|
-
:param pulumi.Input[
|
|
1680
|
-
:param pulumi.Input[
|
|
1681
|
-
:param pulumi.Input[
|
|
1682
|
-
:param pulumi.Input[
|
|
1683
|
-
:param pulumi.Input[
|
|
1684
|
-
:param pulumi.Input[
|
|
1685
|
-
:param pulumi.Input[
|
|
1686
|
-
:param pulumi.Input[
|
|
1687
|
-
:param pulumi.Input[
|
|
1688
|
-
:param pulumi.Input[
|
|
1689
|
-
:param pulumi.Input[
|
|
1690
|
-
:param pulumi.Input[
|
|
1691
|
-
:param pulumi.Input[
|
|
1692
|
-
:param pulumi.Input[
|
|
1693
|
-
:param pulumi.Input[
|
|
1694
|
-
:param pulumi.Input[
|
|
1695
|
-
:param pulumi.Input[
|
|
1696
|
-
:param pulumi.Input[
|
|
1697
|
-
:param pulumi.Input[
|
|
1698
|
-
:param pulumi.Input[
|
|
1699
|
-
:param pulumi.Input[
|
|
1700
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1701
|
-
:param pulumi.Input[
|
|
1702
|
-
:param pulumi.Input[
|
|
1703
|
-
:param pulumi.Input[
|
|
1704
|
-
:param pulumi.Input[
|
|
1705
|
-
:param pulumi.Input[
|
|
1706
|
-
:param pulumi.Input[
|
|
1707
|
-
:param pulumi.Input[
|
|
1708
|
-
:param pulumi.Input[
|
|
1709
|
-
:param pulumi.Input[
|
|
1710
|
-
:param pulumi.Input[
|
|
1711
|
-
:param pulumi.Input[
|
|
1712
|
-
:param pulumi.Input[
|
|
1713
|
-
:param pulumi.Input[
|
|
1674
|
+
:param pulumi.Input[_builtins.bool] action_auto_create_index_enabled: Specifices whether to allow automatic creation of indices. Default: `true`
|
|
1675
|
+
:param pulumi.Input[_builtins.bool] action_destructive_requires_name: Specifies whether to require explicit index names when deleting indices.
|
|
1676
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Opensearch cluster.
|
|
1677
|
+
:param pulumi.Input[_builtins.int] cluster_max_shards_per_node: Maximum number of shards allowed per data node.
|
|
1678
|
+
:param pulumi.Input[_builtins.int] cluster_routing_allocation_node_concurrent_recoveries: Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
1679
|
+
:param pulumi.Input[_builtins.bool] enable_security_audit: Specifies whether to allow security audit logging. Default: `false`
|
|
1680
|
+
:param pulumi.Input[_builtins.int] http_max_content_length_bytes: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
1681
|
+
:param pulumi.Input[_builtins.int] http_max_header_size_bytes: Maximum size of allowed headers, in bytes. Default: `8192`
|
|
1682
|
+
:param pulumi.Input[_builtins.int] http_max_initial_line_length_bytes: Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
1683
|
+
:param pulumi.Input[_builtins.int] indices_fielddata_cache_size_percentage: 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.
|
|
1684
|
+
:param pulumi.Input[_builtins.int] indices_memory_index_buffer_size_percentage: 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`
|
|
1685
|
+
:param pulumi.Input[_builtins.int] indices_memory_max_index_buffer_size_mb: 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.
|
|
1686
|
+
:param pulumi.Input[_builtins.int] indices_memory_min_index_buffer_size_mb: 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`
|
|
1687
|
+
:param pulumi.Input[_builtins.int] indices_queries_cache_size_percentage: 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`
|
|
1688
|
+
:param pulumi.Input[_builtins.int] indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
1689
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_concurrent_file_chunks: Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
1690
|
+
:param pulumi.Input[_builtins.int] indices_recovery_max_mb_per_sec: 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`
|
|
1691
|
+
:param pulumi.Input[_builtins.bool] ism_enabled: Specifies whether ISM is enabled or not. Default: `true`
|
|
1692
|
+
:param pulumi.Input[_builtins.bool] ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
1693
|
+
:param pulumi.Input[_builtins.int] ism_history_max_age_hours: Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
1694
|
+
:param pulumi.Input[_builtins.int] ism_history_max_docs: Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
1695
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_check_period_hours: The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
1696
|
+
:param pulumi.Input[_builtins.int] ism_history_rollover_retention_period_days: Length of time long audit history indices are kept, in days. Default: `30`
|
|
1697
|
+
:param pulumi.Input[_builtins.bool] override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
1698
|
+
:param pulumi.Input[_builtins.bool] plugins_alerting_filter_by_backend_roles_enabled: Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
1699
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] reindex_remote_whitelists: Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
1700
|
+
:param pulumi.Input[_builtins.str] script_max_compilations_rate: Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
1701
|
+
:param pulumi.Input[_builtins.int] search_max_buckets: Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
1702
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_queue_size: Size of queue for operations in the analyze thread pool.
|
|
1703
|
+
:param pulumi.Input[_builtins.int] thread_pool_analyze_size: 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.
|
|
1704
|
+
:param pulumi.Input[_builtins.int] thread_pool_force_merge_size: 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.
|
|
1705
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_queue_size: Size of queue for operations in the get thread pool.
|
|
1706
|
+
:param pulumi.Input[_builtins.int] thread_pool_get_size: 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.
|
|
1707
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_queue_size: Size of queue for operations in the search thread pool.
|
|
1708
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_size: 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.
|
|
1709
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_queue_size: Size of queue for operations in the search throttled thread pool.
|
|
1710
|
+
:param pulumi.Input[_builtins.int] thread_pool_search_throttled_size: 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.
|
|
1711
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_queue_size: Size of queue for operations in the write thread pool.
|
|
1712
|
+
:param pulumi.Input[_builtins.int] thread_pool_write_size: 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.
|
|
1714
1713
|
"""
|
|
1715
1714
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1716
1715
|
|
|
@@ -1757,313 +1756,313 @@ class DatabaseOpensearchConfig(pulumi.CustomResource):
|
|
|
1757
1756
|
__props__.__dict__["thread_pool_write_size"] = thread_pool_write_size
|
|
1758
1757
|
return DatabaseOpensearchConfig(resource_name, opts=opts, __props__=__props__)
|
|
1759
1758
|
|
|
1760
|
-
@property
|
|
1759
|
+
@_builtins.property
|
|
1761
1760
|
@pulumi.getter(name="actionAutoCreateIndexEnabled")
|
|
1762
|
-
def action_auto_create_index_enabled(self) -> pulumi.Output[
|
|
1761
|
+
def action_auto_create_index_enabled(self) -> pulumi.Output[_builtins.bool]:
|
|
1763
1762
|
"""
|
|
1764
1763
|
Specifices whether to allow automatic creation of indices. Default: `true`
|
|
1765
1764
|
"""
|
|
1766
1765
|
return pulumi.get(self, "action_auto_create_index_enabled")
|
|
1767
1766
|
|
|
1768
|
-
@property
|
|
1767
|
+
@_builtins.property
|
|
1769
1768
|
@pulumi.getter(name="actionDestructiveRequiresName")
|
|
1770
|
-
def action_destructive_requires_name(self) -> pulumi.Output[
|
|
1769
|
+
def action_destructive_requires_name(self) -> pulumi.Output[_builtins.bool]:
|
|
1771
1770
|
"""
|
|
1772
1771
|
Specifies whether to require explicit index names when deleting indices.
|
|
1773
1772
|
"""
|
|
1774
1773
|
return pulumi.get(self, "action_destructive_requires_name")
|
|
1775
1774
|
|
|
1776
|
-
@property
|
|
1775
|
+
@_builtins.property
|
|
1777
1776
|
@pulumi.getter(name="clusterId")
|
|
1778
|
-
def cluster_id(self) -> pulumi.Output[
|
|
1777
|
+
def cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
1779
1778
|
"""
|
|
1780
1779
|
The ID of the target Opensearch cluster.
|
|
1781
1780
|
"""
|
|
1782
1781
|
return pulumi.get(self, "cluster_id")
|
|
1783
1782
|
|
|
1784
|
-
@property
|
|
1783
|
+
@_builtins.property
|
|
1785
1784
|
@pulumi.getter(name="clusterMaxShardsPerNode")
|
|
1786
|
-
def cluster_max_shards_per_node(self) -> pulumi.Output[
|
|
1785
|
+
def cluster_max_shards_per_node(self) -> pulumi.Output[_builtins.int]:
|
|
1787
1786
|
"""
|
|
1788
1787
|
Maximum number of shards allowed per data node.
|
|
1789
1788
|
"""
|
|
1790
1789
|
return pulumi.get(self, "cluster_max_shards_per_node")
|
|
1791
1790
|
|
|
1792
|
-
@property
|
|
1791
|
+
@_builtins.property
|
|
1793
1792
|
@pulumi.getter(name="clusterRoutingAllocationNodeConcurrentRecoveries")
|
|
1794
|
-
def cluster_routing_allocation_node_concurrent_recoveries(self) -> pulumi.Output[
|
|
1793
|
+
def cluster_routing_allocation_node_concurrent_recoveries(self) -> pulumi.Output[_builtins.int]:
|
|
1795
1794
|
"""
|
|
1796
1795
|
Maximum concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen per node. Default: `2`
|
|
1797
1796
|
"""
|
|
1798
1797
|
return pulumi.get(self, "cluster_routing_allocation_node_concurrent_recoveries")
|
|
1799
1798
|
|
|
1800
|
-
@property
|
|
1799
|
+
@_builtins.property
|
|
1801
1800
|
@pulumi.getter(name="enableSecurityAudit")
|
|
1802
|
-
def enable_security_audit(self) -> pulumi.Output[
|
|
1801
|
+
def enable_security_audit(self) -> pulumi.Output[_builtins.bool]:
|
|
1803
1802
|
"""
|
|
1804
1803
|
Specifies whether to allow security audit logging. Default: `false`
|
|
1805
1804
|
"""
|
|
1806
1805
|
return pulumi.get(self, "enable_security_audit")
|
|
1807
1806
|
|
|
1808
|
-
@property
|
|
1807
|
+
@_builtins.property
|
|
1809
1808
|
@pulumi.getter(name="httpMaxContentLengthBytes")
|
|
1810
|
-
def http_max_content_length_bytes(self) -> pulumi.Output[
|
|
1809
|
+
def http_max_content_length_bytes(self) -> pulumi.Output[_builtins.int]:
|
|
1811
1810
|
"""
|
|
1812
1811
|
Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes. Default: `100000000`
|
|
1813
1812
|
"""
|
|
1814
1813
|
return pulumi.get(self, "http_max_content_length_bytes")
|
|
1815
1814
|
|
|
1816
|
-
@property
|
|
1815
|
+
@_builtins.property
|
|
1817
1816
|
@pulumi.getter(name="httpMaxHeaderSizeBytes")
|
|
1818
|
-
def http_max_header_size_bytes(self) -> pulumi.Output[
|
|
1817
|
+
def http_max_header_size_bytes(self) -> pulumi.Output[_builtins.int]:
|
|
1819
1818
|
"""
|
|
1820
1819
|
Maximum size of allowed headers, in bytes. Default: `8192`
|
|
1821
1820
|
"""
|
|
1822
1821
|
return pulumi.get(self, "http_max_header_size_bytes")
|
|
1823
1822
|
|
|
1824
|
-
@property
|
|
1823
|
+
@_builtins.property
|
|
1825
1824
|
@pulumi.getter(name="httpMaxInitialLineLengthBytes")
|
|
1826
|
-
def http_max_initial_line_length_bytes(self) -> pulumi.Output[
|
|
1825
|
+
def http_max_initial_line_length_bytes(self) -> pulumi.Output[_builtins.int]:
|
|
1827
1826
|
"""
|
|
1828
1827
|
Maximum length of an HTTP URL, in bytes. Default: `4096`
|
|
1829
1828
|
"""
|
|
1830
1829
|
return pulumi.get(self, "http_max_initial_line_length_bytes")
|
|
1831
1830
|
|
|
1832
|
-
@property
|
|
1831
|
+
@_builtins.property
|
|
1833
1832
|
@pulumi.getter(name="indicesFielddataCacheSizePercentage")
|
|
1834
|
-
def indices_fielddata_cache_size_percentage(self) -> pulumi.Output[
|
|
1833
|
+
def indices_fielddata_cache_size_percentage(self) -> pulumi.Output[_builtins.int]:
|
|
1835
1834
|
"""
|
|
1836
1835
|
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.
|
|
1837
1836
|
"""
|
|
1838
1837
|
return pulumi.get(self, "indices_fielddata_cache_size_percentage")
|
|
1839
1838
|
|
|
1840
|
-
@property
|
|
1839
|
+
@_builtins.property
|
|
1841
1840
|
@pulumi.getter(name="indicesMemoryIndexBufferSizePercentage")
|
|
1842
|
-
def indices_memory_index_buffer_size_percentage(self) -> pulumi.Output[
|
|
1841
|
+
def indices_memory_index_buffer_size_percentage(self) -> pulumi.Output[_builtins.int]:
|
|
1843
1842
|
"""
|
|
1844
1843
|
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`
|
|
1845
1844
|
"""
|
|
1846
1845
|
return pulumi.get(self, "indices_memory_index_buffer_size_percentage")
|
|
1847
1846
|
|
|
1848
|
-
@property
|
|
1847
|
+
@_builtins.property
|
|
1849
1848
|
@pulumi.getter(name="indicesMemoryMaxIndexBufferSizeMb")
|
|
1850
|
-
def indices_memory_max_index_buffer_size_mb(self) -> pulumi.Output[
|
|
1849
|
+
def indices_memory_max_index_buffer_size_mb(self) -> pulumi.Output[_builtins.int]:
|
|
1851
1850
|
"""
|
|
1852
1851
|
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.
|
|
1853
1852
|
"""
|
|
1854
1853
|
return pulumi.get(self, "indices_memory_max_index_buffer_size_mb")
|
|
1855
1854
|
|
|
1856
|
-
@property
|
|
1855
|
+
@_builtins.property
|
|
1857
1856
|
@pulumi.getter(name="indicesMemoryMinIndexBufferSizeMb")
|
|
1858
|
-
def indices_memory_min_index_buffer_size_mb(self) -> pulumi.Output[
|
|
1857
|
+
def indices_memory_min_index_buffer_size_mb(self) -> pulumi.Output[_builtins.int]:
|
|
1859
1858
|
"""
|
|
1860
1859
|
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`
|
|
1861
1860
|
"""
|
|
1862
1861
|
return pulumi.get(self, "indices_memory_min_index_buffer_size_mb")
|
|
1863
1862
|
|
|
1864
|
-
@property
|
|
1863
|
+
@_builtins.property
|
|
1865
1864
|
@pulumi.getter(name="indicesQueriesCacheSizePercentage")
|
|
1866
|
-
def indices_queries_cache_size_percentage(self) -> pulumi.Output[
|
|
1865
|
+
def indices_queries_cache_size_percentage(self) -> pulumi.Output[_builtins.int]:
|
|
1867
1866
|
"""
|
|
1868
1867
|
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`
|
|
1869
1868
|
"""
|
|
1870
1869
|
return pulumi.get(self, "indices_queries_cache_size_percentage")
|
|
1871
1870
|
|
|
1872
|
-
@property
|
|
1871
|
+
@_builtins.property
|
|
1873
1872
|
@pulumi.getter(name="indicesQueryBoolMaxClauseCount")
|
|
1874
|
-
def indices_query_bool_max_clause_count(self) -> pulumi.Output[
|
|
1873
|
+
def indices_query_bool_max_clause_count(self) -> pulumi.Output[_builtins.int]:
|
|
1875
1874
|
"""
|
|
1876
1875
|
Maximum number of clauses Lucene BooleanQuery can have. Only increase it if necessary, as it may cause performance issues. Default: `1024`
|
|
1877
1876
|
"""
|
|
1878
1877
|
return pulumi.get(self, "indices_query_bool_max_clause_count")
|
|
1879
1878
|
|
|
1880
|
-
@property
|
|
1879
|
+
@_builtins.property
|
|
1881
1880
|
@pulumi.getter(name="indicesRecoveryMaxConcurrentFileChunks")
|
|
1882
|
-
def indices_recovery_max_concurrent_file_chunks(self) -> pulumi.Output[
|
|
1881
|
+
def indices_recovery_max_concurrent_file_chunks(self) -> pulumi.Output[_builtins.int]:
|
|
1883
1882
|
"""
|
|
1884
1883
|
Maximum number of file chunks sent in parallel for each recovery. Default: `2`
|
|
1885
1884
|
"""
|
|
1886
1885
|
return pulumi.get(self, "indices_recovery_max_concurrent_file_chunks")
|
|
1887
1886
|
|
|
1888
|
-
@property
|
|
1887
|
+
@_builtins.property
|
|
1889
1888
|
@pulumi.getter(name="indicesRecoveryMaxMbPerSec")
|
|
1890
|
-
def indices_recovery_max_mb_per_sec(self) -> pulumi.Output[
|
|
1889
|
+
def indices_recovery_max_mb_per_sec(self) -> pulumi.Output[_builtins.int]:
|
|
1891
1890
|
"""
|
|
1892
1891
|
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`
|
|
1893
1892
|
"""
|
|
1894
1893
|
return pulumi.get(self, "indices_recovery_max_mb_per_sec")
|
|
1895
1894
|
|
|
1896
|
-
@property
|
|
1895
|
+
@_builtins.property
|
|
1897
1896
|
@pulumi.getter(name="ismEnabled")
|
|
1898
|
-
def ism_enabled(self) -> pulumi.Output[
|
|
1897
|
+
def ism_enabled(self) -> pulumi.Output[_builtins.bool]:
|
|
1899
1898
|
"""
|
|
1900
1899
|
Specifies whether ISM is enabled or not. Default: `true`
|
|
1901
1900
|
"""
|
|
1902
1901
|
return pulumi.get(self, "ism_enabled")
|
|
1903
1902
|
|
|
1904
|
-
@property
|
|
1903
|
+
@_builtins.property
|
|
1905
1904
|
@pulumi.getter(name="ismHistoryEnabled")
|
|
1906
|
-
def ism_history_enabled(self) -> pulumi.Output[
|
|
1905
|
+
def ism_history_enabled(self) -> pulumi.Output[_builtins.bool]:
|
|
1907
1906
|
"""
|
|
1908
1907
|
Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`
|
|
1909
1908
|
"""
|
|
1910
1909
|
return pulumi.get(self, "ism_history_enabled")
|
|
1911
1910
|
|
|
1912
|
-
@property
|
|
1911
|
+
@_builtins.property
|
|
1913
1912
|
@pulumi.getter(name="ismHistoryMaxAgeHours")
|
|
1914
|
-
def ism_history_max_age_hours(self) -> pulumi.Output[
|
|
1913
|
+
def ism_history_max_age_hours(self) -> pulumi.Output[_builtins.int]:
|
|
1915
1914
|
"""
|
|
1916
1915
|
Maximum age before rolling over the audit history index, in hours. Default: `24`
|
|
1917
1916
|
"""
|
|
1918
1917
|
return pulumi.get(self, "ism_history_max_age_hours")
|
|
1919
1918
|
|
|
1920
|
-
@property
|
|
1919
|
+
@_builtins.property
|
|
1921
1920
|
@pulumi.getter(name="ismHistoryMaxDocs")
|
|
1922
|
-
def ism_history_max_docs(self) -> pulumi.Output[
|
|
1921
|
+
def ism_history_max_docs(self) -> pulumi.Output[_builtins.int]:
|
|
1923
1922
|
"""
|
|
1924
1923
|
Maximum number of documents before rolling over the audit history index. Default: `2500000`
|
|
1925
1924
|
"""
|
|
1926
1925
|
return pulumi.get(self, "ism_history_max_docs")
|
|
1927
1926
|
|
|
1928
|
-
@property
|
|
1927
|
+
@_builtins.property
|
|
1929
1928
|
@pulumi.getter(name="ismHistoryRolloverCheckPeriodHours")
|
|
1930
|
-
def ism_history_rollover_check_period_hours(self) -> pulumi.Output[
|
|
1929
|
+
def ism_history_rollover_check_period_hours(self) -> pulumi.Output[_builtins.int]:
|
|
1931
1930
|
"""
|
|
1932
1931
|
The time between rollover checks for the audit history index, in hours. Default: `8`
|
|
1933
1932
|
"""
|
|
1934
1933
|
return pulumi.get(self, "ism_history_rollover_check_period_hours")
|
|
1935
1934
|
|
|
1936
|
-
@property
|
|
1935
|
+
@_builtins.property
|
|
1937
1936
|
@pulumi.getter(name="ismHistoryRolloverRetentionPeriodDays")
|
|
1938
|
-
def ism_history_rollover_retention_period_days(self) -> pulumi.Output[
|
|
1937
|
+
def ism_history_rollover_retention_period_days(self) -> pulumi.Output[_builtins.int]:
|
|
1939
1938
|
"""
|
|
1940
1939
|
Length of time long audit history indices are kept, in days. Default: `30`
|
|
1941
1940
|
"""
|
|
1942
1941
|
return pulumi.get(self, "ism_history_rollover_retention_period_days")
|
|
1943
1942
|
|
|
1944
|
-
@property
|
|
1943
|
+
@_builtins.property
|
|
1945
1944
|
@pulumi.getter(name="overrideMainResponseVersion")
|
|
1946
|
-
def override_main_response_version(self) -> pulumi.Output[
|
|
1945
|
+
def override_main_response_version(self) -> pulumi.Output[_builtins.bool]:
|
|
1947
1946
|
"""
|
|
1948
1947
|
Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default: `false`
|
|
1949
1948
|
"""
|
|
1950
1949
|
return pulumi.get(self, "override_main_response_version")
|
|
1951
1950
|
|
|
1952
|
-
@property
|
|
1951
|
+
@_builtins.property
|
|
1953
1952
|
@pulumi.getter(name="pluginsAlertingFilterByBackendRolesEnabled")
|
|
1954
|
-
def plugins_alerting_filter_by_backend_roles_enabled(self) -> pulumi.Output[
|
|
1953
|
+
def plugins_alerting_filter_by_backend_roles_enabled(self) -> pulumi.Output[_builtins.bool]:
|
|
1955
1954
|
"""
|
|
1956
1955
|
Enable or disable filtering of alerting by backend roles. Default: `false`
|
|
1957
1956
|
"""
|
|
1958
1957
|
return pulumi.get(self, "plugins_alerting_filter_by_backend_roles_enabled")
|
|
1959
1958
|
|
|
1960
|
-
@property
|
|
1959
|
+
@_builtins.property
|
|
1961
1960
|
@pulumi.getter(name="reindexRemoteWhitelists")
|
|
1962
|
-
def reindex_remote_whitelists(self) -> pulumi.Output[Optional[Sequence[
|
|
1961
|
+
def reindex_remote_whitelists(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1963
1962
|
"""
|
|
1964
1963
|
Allowlist of remote IP addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
|
|
1965
1964
|
"""
|
|
1966
1965
|
return pulumi.get(self, "reindex_remote_whitelists")
|
|
1967
1966
|
|
|
1968
|
-
@property
|
|
1967
|
+
@_builtins.property
|
|
1969
1968
|
@pulumi.getter(name="scriptMaxCompilationsRate")
|
|
1970
|
-
def script_max_compilations_rate(self) -> pulumi.Output[
|
|
1969
|
+
def script_max_compilations_rate(self) -> pulumi.Output[_builtins.str]:
|
|
1971
1970
|
"""
|
|
1972
1971
|
Limits the number of inline script compilations within a period of time. Default is `use-context`
|
|
1973
1972
|
"""
|
|
1974
1973
|
return pulumi.get(self, "script_max_compilations_rate")
|
|
1975
1974
|
|
|
1976
|
-
@property
|
|
1975
|
+
@_builtins.property
|
|
1977
1976
|
@pulumi.getter(name="searchMaxBuckets")
|
|
1978
|
-
def search_max_buckets(self) -> pulumi.Output[
|
|
1977
|
+
def search_max_buckets(self) -> pulumi.Output[_builtins.int]:
|
|
1979
1978
|
"""
|
|
1980
1979
|
Maximum number of aggregation buckets allowed in a single response. Default: `10000`
|
|
1981
1980
|
"""
|
|
1982
1981
|
return pulumi.get(self, "search_max_buckets")
|
|
1983
1982
|
|
|
1984
|
-
@property
|
|
1983
|
+
@_builtins.property
|
|
1985
1984
|
@pulumi.getter(name="threadPoolAnalyzeQueueSize")
|
|
1986
|
-
def thread_pool_analyze_queue_size(self) -> pulumi.Output[
|
|
1985
|
+
def thread_pool_analyze_queue_size(self) -> pulumi.Output[_builtins.int]:
|
|
1987
1986
|
"""
|
|
1988
1987
|
Size of queue for operations in the analyze thread pool.
|
|
1989
1988
|
"""
|
|
1990
1989
|
return pulumi.get(self, "thread_pool_analyze_queue_size")
|
|
1991
1990
|
|
|
1992
|
-
@property
|
|
1991
|
+
@_builtins.property
|
|
1993
1992
|
@pulumi.getter(name="threadPoolAnalyzeSize")
|
|
1994
|
-
def thread_pool_analyze_size(self) -> pulumi.Output[
|
|
1993
|
+
def thread_pool_analyze_size(self) -> pulumi.Output[_builtins.int]:
|
|
1995
1994
|
"""
|
|
1996
1995
|
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.
|
|
1997
1996
|
"""
|
|
1998
1997
|
return pulumi.get(self, "thread_pool_analyze_size")
|
|
1999
1998
|
|
|
2000
|
-
@property
|
|
1999
|
+
@_builtins.property
|
|
2001
2000
|
@pulumi.getter(name="threadPoolForceMergeSize")
|
|
2002
|
-
def thread_pool_force_merge_size(self) -> pulumi.Output[
|
|
2001
|
+
def thread_pool_force_merge_size(self) -> pulumi.Output[_builtins.int]:
|
|
2003
2002
|
"""
|
|
2004
2003
|
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.
|
|
2005
2004
|
"""
|
|
2006
2005
|
return pulumi.get(self, "thread_pool_force_merge_size")
|
|
2007
2006
|
|
|
2008
|
-
@property
|
|
2007
|
+
@_builtins.property
|
|
2009
2008
|
@pulumi.getter(name="threadPoolGetQueueSize")
|
|
2010
|
-
def thread_pool_get_queue_size(self) -> pulumi.Output[
|
|
2009
|
+
def thread_pool_get_queue_size(self) -> pulumi.Output[_builtins.int]:
|
|
2011
2010
|
"""
|
|
2012
2011
|
Size of queue for operations in the get thread pool.
|
|
2013
2012
|
"""
|
|
2014
2013
|
return pulumi.get(self, "thread_pool_get_queue_size")
|
|
2015
2014
|
|
|
2016
|
-
@property
|
|
2015
|
+
@_builtins.property
|
|
2017
2016
|
@pulumi.getter(name="threadPoolGetSize")
|
|
2018
|
-
def thread_pool_get_size(self) -> pulumi.Output[
|
|
2017
|
+
def thread_pool_get_size(self) -> pulumi.Output[_builtins.int]:
|
|
2019
2018
|
"""
|
|
2020
2019
|
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.
|
|
2021
2020
|
"""
|
|
2022
2021
|
return pulumi.get(self, "thread_pool_get_size")
|
|
2023
2022
|
|
|
2024
|
-
@property
|
|
2023
|
+
@_builtins.property
|
|
2025
2024
|
@pulumi.getter(name="threadPoolSearchQueueSize")
|
|
2026
|
-
def thread_pool_search_queue_size(self) -> pulumi.Output[
|
|
2025
|
+
def thread_pool_search_queue_size(self) -> pulumi.Output[_builtins.int]:
|
|
2027
2026
|
"""
|
|
2028
2027
|
Size of queue for operations in the search thread pool.
|
|
2029
2028
|
"""
|
|
2030
2029
|
return pulumi.get(self, "thread_pool_search_queue_size")
|
|
2031
2030
|
|
|
2032
|
-
@property
|
|
2031
|
+
@_builtins.property
|
|
2033
2032
|
@pulumi.getter(name="threadPoolSearchSize")
|
|
2034
|
-
def thread_pool_search_size(self) -> pulumi.Output[
|
|
2033
|
+
def thread_pool_search_size(self) -> pulumi.Output[_builtins.int]:
|
|
2035
2034
|
"""
|
|
2036
2035
|
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.
|
|
2037
2036
|
"""
|
|
2038
2037
|
return pulumi.get(self, "thread_pool_search_size")
|
|
2039
2038
|
|
|
2040
|
-
@property
|
|
2039
|
+
@_builtins.property
|
|
2041
2040
|
@pulumi.getter(name="threadPoolSearchThrottledQueueSize")
|
|
2042
|
-
def thread_pool_search_throttled_queue_size(self) -> pulumi.Output[
|
|
2041
|
+
def thread_pool_search_throttled_queue_size(self) -> pulumi.Output[_builtins.int]:
|
|
2043
2042
|
"""
|
|
2044
2043
|
Size of queue for operations in the search throttled thread pool.
|
|
2045
2044
|
"""
|
|
2046
2045
|
return pulumi.get(self, "thread_pool_search_throttled_queue_size")
|
|
2047
2046
|
|
|
2048
|
-
@property
|
|
2047
|
+
@_builtins.property
|
|
2049
2048
|
@pulumi.getter(name="threadPoolSearchThrottledSize")
|
|
2050
|
-
def thread_pool_search_throttled_size(self) -> pulumi.Output[
|
|
2049
|
+
def thread_pool_search_throttled_size(self) -> pulumi.Output[_builtins.int]:
|
|
2051
2050
|
"""
|
|
2052
2051
|
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.
|
|
2053
2052
|
"""
|
|
2054
2053
|
return pulumi.get(self, "thread_pool_search_throttled_size")
|
|
2055
2054
|
|
|
2056
|
-
@property
|
|
2055
|
+
@_builtins.property
|
|
2057
2056
|
@pulumi.getter(name="threadPoolWriteQueueSize")
|
|
2058
|
-
def thread_pool_write_queue_size(self) -> pulumi.Output[
|
|
2057
|
+
def thread_pool_write_queue_size(self) -> pulumi.Output[_builtins.int]:
|
|
2059
2058
|
"""
|
|
2060
2059
|
Size of queue for operations in the write thread pool.
|
|
2061
2060
|
"""
|
|
2062
2061
|
return pulumi.get(self, "thread_pool_write_queue_size")
|
|
2063
2062
|
|
|
2064
|
-
@property
|
|
2063
|
+
@_builtins.property
|
|
2065
2064
|
@pulumi.getter(name="threadPoolWriteSize")
|
|
2066
|
-
def thread_pool_write_size(self) -> pulumi.Output[
|
|
2065
|
+
def thread_pool_write_size(self) -> pulumi.Output[_builtins.int]:
|
|
2067
2066
|
"""
|
|
2068
2067
|
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.
|
|
2069
2068
|
"""
|