pulumi-digitalocean 4.50.0a1753335988__py3-none-any.whl → 4.50.0a1753508712__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 +1 -1
- pulumi_digitalocean/_enums.py +9 -9
- pulumi_digitalocean/_inputs.py +5705 -5706
- pulumi_digitalocean/app.py +87 -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 +346 -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_opensearch_config.py +664 -665
- pulumi_digitalocean/database_postgresql_config.py +857 -858
- pulumi_digitalocean/database_redis_config.py +205 -206
- pulumi_digitalocean/database_replica.py +197 -198
- pulumi_digitalocean/database_user.py +91 -92
- 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/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 +60 -61
- pulumi_digitalocean/get_database_connection_pool.py +35 -36
- 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_agents.py +10 -11
- 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 +7064 -7065
- 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.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/METADATA +1 -1
- pulumi_digitalocean-4.50.0a1753508712.dist-info/RECORD +119 -0
- pulumi_digitalocean-4.50.0a1753335988.dist-info/RECORD +0 -119
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/WHEEL +0 -0
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.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,44 +19,44 @@ __all__ = ['DatabaseKafkaConfigArgs', 'DatabaseKafkaConfig']
|
|
|
20
19
|
@pulumi.input_type
|
|
21
20
|
class DatabaseKafkaConfigArgs:
|
|
22
21
|
def __init__(__self__, *,
|
|
23
|
-
cluster_id: pulumi.Input[
|
|
24
|
-
auto_create_topics_enable: Optional[pulumi.Input[
|
|
25
|
-
group_initial_rebalance_delay_ms: Optional[pulumi.Input[
|
|
26
|
-
group_max_session_timeout_ms: Optional[pulumi.Input[
|
|
27
|
-
group_min_session_timeout_ms: Optional[pulumi.Input[
|
|
28
|
-
log_cleaner_delete_retention_ms: Optional[pulumi.Input[
|
|
29
|
-
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[
|
|
30
|
-
log_flush_interval_ms: Optional[pulumi.Input[
|
|
31
|
-
log_index_interval_bytes: Optional[pulumi.Input[
|
|
32
|
-
log_message_downconversion_enable: Optional[pulumi.Input[
|
|
33
|
-
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[
|
|
34
|
-
log_preallocate: Optional[pulumi.Input[
|
|
35
|
-
log_retention_bytes: Optional[pulumi.Input[
|
|
36
|
-
log_retention_hours: Optional[pulumi.Input[
|
|
37
|
-
log_retention_ms: Optional[pulumi.Input[
|
|
38
|
-
log_roll_jitter_ms: Optional[pulumi.Input[
|
|
39
|
-
log_segment_delete_delay_ms: Optional[pulumi.Input[
|
|
40
|
-
message_max_bytes: Optional[pulumi.Input[
|
|
22
|
+
cluster_id: pulumi.Input[_builtins.str],
|
|
23
|
+
auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
24
|
+
group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
25
|
+
group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
26
|
+
group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
27
|
+
log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
28
|
+
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
|
+
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
|
+
log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
36
|
+
log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
39
|
+
message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
41
40
|
"""
|
|
42
41
|
The set of arguments for constructing a DatabaseKafkaConfig resource.
|
|
43
|
-
:param pulumi.Input[
|
|
44
|
-
:param pulumi.Input[
|
|
45
|
-
:param pulumi.Input[
|
|
46
|
-
:param pulumi.Input[
|
|
47
|
-
:param pulumi.Input[
|
|
48
|
-
:param pulumi.Input[
|
|
49
|
-
:param pulumi.Input[
|
|
50
|
-
:param pulumi.Input[
|
|
51
|
-
:param pulumi.Input[
|
|
52
|
-
:param pulumi.Input[
|
|
53
|
-
:param pulumi.Input[
|
|
54
|
-
:param pulumi.Input[
|
|
55
|
-
:param pulumi.Input[
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
59
|
-
:param pulumi.Input[
|
|
60
|
-
:param pulumi.Input[
|
|
42
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
|
|
43
|
+
:param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
|
|
44
|
+
:param pulumi.Input[_builtins.int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
45
|
+
:param pulumi.Input[_builtins.int] group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
46
|
+
:param pulumi.Input[_builtins.int] group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
47
|
+
:param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
|
|
48
|
+
:param pulumi.Input[_builtins.str] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
49
|
+
:param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
50
|
+
:param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
|
|
51
|
+
:param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
52
|
+
:param pulumi.Input[_builtins.str] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
53
|
+
:param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
|
|
54
|
+
:param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
|
|
55
|
+
:param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
|
|
56
|
+
:param pulumi.Input[_builtins.str] log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
57
|
+
:param pulumi.Input[_builtins.str] log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
58
|
+
:param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
|
|
59
|
+
:param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
|
|
61
60
|
"""
|
|
62
61
|
pulumi.set(__self__, "cluster_id", cluster_id)
|
|
63
62
|
if auto_create_topics_enable is not None:
|
|
@@ -95,264 +94,264 @@ class DatabaseKafkaConfigArgs:
|
|
|
95
94
|
if message_max_bytes is not None:
|
|
96
95
|
pulumi.set(__self__, "message_max_bytes", message_max_bytes)
|
|
97
96
|
|
|
98
|
-
@property
|
|
97
|
+
@_builtins.property
|
|
99
98
|
@pulumi.getter(name="clusterId")
|
|
100
|
-
def cluster_id(self) -> pulumi.Input[
|
|
99
|
+
def cluster_id(self) -> pulumi.Input[_builtins.str]:
|
|
101
100
|
"""
|
|
102
101
|
The ID of the target Kafka cluster.
|
|
103
102
|
"""
|
|
104
103
|
return pulumi.get(self, "cluster_id")
|
|
105
104
|
|
|
106
105
|
@cluster_id.setter
|
|
107
|
-
def cluster_id(self, value: pulumi.Input[
|
|
106
|
+
def cluster_id(self, value: pulumi.Input[_builtins.str]):
|
|
108
107
|
pulumi.set(self, "cluster_id", value)
|
|
109
108
|
|
|
110
|
-
@property
|
|
109
|
+
@_builtins.property
|
|
111
110
|
@pulumi.getter(name="autoCreateTopicsEnable")
|
|
112
|
-
def auto_create_topics_enable(self) -> Optional[pulumi.Input[
|
|
111
|
+
def auto_create_topics_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
113
112
|
"""
|
|
114
113
|
Enable auto creation of topics.
|
|
115
114
|
"""
|
|
116
115
|
return pulumi.get(self, "auto_create_topics_enable")
|
|
117
116
|
|
|
118
117
|
@auto_create_topics_enable.setter
|
|
119
|
-
def auto_create_topics_enable(self, value: Optional[pulumi.Input[
|
|
118
|
+
def auto_create_topics_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
120
119
|
pulumi.set(self, "auto_create_topics_enable", value)
|
|
121
120
|
|
|
122
|
-
@property
|
|
121
|
+
@_builtins.property
|
|
123
122
|
@pulumi.getter(name="groupInitialRebalanceDelayMs")
|
|
124
|
-
def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[
|
|
123
|
+
def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
125
124
|
"""
|
|
126
125
|
The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
127
126
|
"""
|
|
128
127
|
return pulumi.get(self, "group_initial_rebalance_delay_ms")
|
|
129
128
|
|
|
130
129
|
@group_initial_rebalance_delay_ms.setter
|
|
131
|
-
def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[
|
|
130
|
+
def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
132
131
|
pulumi.set(self, "group_initial_rebalance_delay_ms", value)
|
|
133
132
|
|
|
134
|
-
@property
|
|
133
|
+
@_builtins.property
|
|
135
134
|
@pulumi.getter(name="groupMaxSessionTimeoutMs")
|
|
136
|
-
def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[
|
|
135
|
+
def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
137
136
|
"""
|
|
138
137
|
The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
139
138
|
"""
|
|
140
139
|
return pulumi.get(self, "group_max_session_timeout_ms")
|
|
141
140
|
|
|
142
141
|
@group_max_session_timeout_ms.setter
|
|
143
|
-
def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[
|
|
142
|
+
def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
144
143
|
pulumi.set(self, "group_max_session_timeout_ms", value)
|
|
145
144
|
|
|
146
|
-
@property
|
|
145
|
+
@_builtins.property
|
|
147
146
|
@pulumi.getter(name="groupMinSessionTimeoutMs")
|
|
148
|
-
def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[
|
|
147
|
+
def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
149
148
|
"""
|
|
150
149
|
The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
151
150
|
"""
|
|
152
151
|
return pulumi.get(self, "group_min_session_timeout_ms")
|
|
153
152
|
|
|
154
153
|
@group_min_session_timeout_ms.setter
|
|
155
|
-
def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[
|
|
154
|
+
def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
156
155
|
pulumi.set(self, "group_min_session_timeout_ms", value)
|
|
157
156
|
|
|
158
|
-
@property
|
|
157
|
+
@_builtins.property
|
|
159
158
|
@pulumi.getter(name="logCleanerDeleteRetentionMs")
|
|
160
|
-
def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[
|
|
159
|
+
def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
161
160
|
"""
|
|
162
161
|
How long are delete records retained?
|
|
163
162
|
"""
|
|
164
163
|
return pulumi.get(self, "log_cleaner_delete_retention_ms")
|
|
165
164
|
|
|
166
165
|
@log_cleaner_delete_retention_ms.setter
|
|
167
|
-
def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[
|
|
166
|
+
def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
168
167
|
pulumi.set(self, "log_cleaner_delete_retention_ms", value)
|
|
169
168
|
|
|
170
|
-
@property
|
|
169
|
+
@_builtins.property
|
|
171
170
|
@pulumi.getter(name="logCleanerMinCompactionLagMs")
|
|
172
|
-
def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[
|
|
171
|
+
def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
173
172
|
"""
|
|
174
173
|
The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
175
174
|
"""
|
|
176
175
|
return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
|
|
177
176
|
|
|
178
177
|
@log_cleaner_min_compaction_lag_ms.setter
|
|
179
|
-
def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[
|
|
178
|
+
def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
180
179
|
pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)
|
|
181
180
|
|
|
182
|
-
@property
|
|
181
|
+
@_builtins.property
|
|
183
182
|
@pulumi.getter(name="logFlushIntervalMs")
|
|
184
|
-
def log_flush_interval_ms(self) -> Optional[pulumi.Input[
|
|
183
|
+
def log_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
185
184
|
"""
|
|
186
185
|
The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
187
186
|
"""
|
|
188
187
|
return pulumi.get(self, "log_flush_interval_ms")
|
|
189
188
|
|
|
190
189
|
@log_flush_interval_ms.setter
|
|
191
|
-
def log_flush_interval_ms(self, value: Optional[pulumi.Input[
|
|
190
|
+
def log_flush_interval_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
192
191
|
pulumi.set(self, "log_flush_interval_ms", value)
|
|
193
192
|
|
|
194
|
-
@property
|
|
193
|
+
@_builtins.property
|
|
195
194
|
@pulumi.getter(name="logIndexIntervalBytes")
|
|
196
|
-
def log_index_interval_bytes(self) -> Optional[pulumi.Input[
|
|
195
|
+
def log_index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
197
196
|
"""
|
|
198
197
|
The interval with which Kafka adds an entry to the offset index.
|
|
199
198
|
"""
|
|
200
199
|
return pulumi.get(self, "log_index_interval_bytes")
|
|
201
200
|
|
|
202
201
|
@log_index_interval_bytes.setter
|
|
203
|
-
def log_index_interval_bytes(self, value: Optional[pulumi.Input[
|
|
202
|
+
def log_index_interval_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
204
203
|
pulumi.set(self, "log_index_interval_bytes", value)
|
|
205
204
|
|
|
206
|
-
@property
|
|
205
|
+
@_builtins.property
|
|
207
206
|
@pulumi.getter(name="logMessageDownconversionEnable")
|
|
208
|
-
def log_message_downconversion_enable(self) -> Optional[pulumi.Input[
|
|
207
|
+
def log_message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
209
208
|
"""
|
|
210
209
|
This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
211
210
|
"""
|
|
212
211
|
return pulumi.get(self, "log_message_downconversion_enable")
|
|
213
212
|
|
|
214
213
|
@log_message_downconversion_enable.setter
|
|
215
|
-
def log_message_downconversion_enable(self, value: Optional[pulumi.Input[
|
|
214
|
+
def log_message_downconversion_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
216
215
|
pulumi.set(self, "log_message_downconversion_enable", value)
|
|
217
216
|
|
|
218
|
-
@property
|
|
217
|
+
@_builtins.property
|
|
219
218
|
@pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
|
|
220
|
-
def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[
|
|
219
|
+
def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
221
220
|
"""
|
|
222
221
|
The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
223
222
|
"""
|
|
224
223
|
return pulumi.get(self, "log_message_timestamp_difference_max_ms")
|
|
225
224
|
|
|
226
225
|
@log_message_timestamp_difference_max_ms.setter
|
|
227
|
-
def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[
|
|
226
|
+
def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
228
227
|
pulumi.set(self, "log_message_timestamp_difference_max_ms", value)
|
|
229
228
|
|
|
230
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
231
230
|
@pulumi.getter(name="logPreallocate")
|
|
232
|
-
def log_preallocate(self) -> Optional[pulumi.Input[
|
|
231
|
+
def log_preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
233
232
|
"""
|
|
234
233
|
Controls whether to preallocate a file when creating a new segment.
|
|
235
234
|
"""
|
|
236
235
|
return pulumi.get(self, "log_preallocate")
|
|
237
236
|
|
|
238
237
|
@log_preallocate.setter
|
|
239
|
-
def log_preallocate(self, value: Optional[pulumi.Input[
|
|
238
|
+
def log_preallocate(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
240
239
|
pulumi.set(self, "log_preallocate", value)
|
|
241
240
|
|
|
242
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
243
242
|
@pulumi.getter(name="logRetentionBytes")
|
|
244
|
-
def log_retention_bytes(self) -> Optional[pulumi.Input[
|
|
243
|
+
def log_retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
245
244
|
"""
|
|
246
245
|
The maximum size of the log before deleting messages.
|
|
247
246
|
"""
|
|
248
247
|
return pulumi.get(self, "log_retention_bytes")
|
|
249
248
|
|
|
250
249
|
@log_retention_bytes.setter
|
|
251
|
-
def log_retention_bytes(self, value: Optional[pulumi.Input[
|
|
250
|
+
def log_retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
252
251
|
pulumi.set(self, "log_retention_bytes", value)
|
|
253
252
|
|
|
254
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
255
254
|
@pulumi.getter(name="logRetentionHours")
|
|
256
|
-
def log_retention_hours(self) -> Optional[pulumi.Input[
|
|
255
|
+
def log_retention_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
257
256
|
"""
|
|
258
257
|
The number of hours to keep a log file before deleting it.
|
|
259
258
|
"""
|
|
260
259
|
return pulumi.get(self, "log_retention_hours")
|
|
261
260
|
|
|
262
261
|
@log_retention_hours.setter
|
|
263
|
-
def log_retention_hours(self, value: Optional[pulumi.Input[
|
|
262
|
+
def log_retention_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
264
263
|
pulumi.set(self, "log_retention_hours", value)
|
|
265
264
|
|
|
266
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
267
266
|
@pulumi.getter(name="logRetentionMs")
|
|
268
|
-
def log_retention_ms(self) -> Optional[pulumi.Input[
|
|
267
|
+
def log_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
269
268
|
"""
|
|
270
269
|
The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
271
270
|
"""
|
|
272
271
|
return pulumi.get(self, "log_retention_ms")
|
|
273
272
|
|
|
274
273
|
@log_retention_ms.setter
|
|
275
|
-
def log_retention_ms(self, value: Optional[pulumi.Input[
|
|
274
|
+
def log_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
276
275
|
pulumi.set(self, "log_retention_ms", value)
|
|
277
276
|
|
|
278
|
-
@property
|
|
277
|
+
@_builtins.property
|
|
279
278
|
@pulumi.getter(name="logRollJitterMs")
|
|
280
|
-
def log_roll_jitter_ms(self) -> Optional[pulumi.Input[
|
|
279
|
+
def log_roll_jitter_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
281
280
|
"""
|
|
282
281
|
The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
283
282
|
"""
|
|
284
283
|
return pulumi.get(self, "log_roll_jitter_ms")
|
|
285
284
|
|
|
286
285
|
@log_roll_jitter_ms.setter
|
|
287
|
-
def log_roll_jitter_ms(self, value: Optional[pulumi.Input[
|
|
286
|
+
def log_roll_jitter_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
288
287
|
pulumi.set(self, "log_roll_jitter_ms", value)
|
|
289
288
|
|
|
290
|
-
@property
|
|
289
|
+
@_builtins.property
|
|
291
290
|
@pulumi.getter(name="logSegmentDeleteDelayMs")
|
|
292
|
-
def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[
|
|
291
|
+
def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
293
292
|
"""
|
|
294
293
|
The amount of time to wait before deleting a file from the filesystem.
|
|
295
294
|
"""
|
|
296
295
|
return pulumi.get(self, "log_segment_delete_delay_ms")
|
|
297
296
|
|
|
298
297
|
@log_segment_delete_delay_ms.setter
|
|
299
|
-
def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[
|
|
298
|
+
def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
300
299
|
pulumi.set(self, "log_segment_delete_delay_ms", value)
|
|
301
300
|
|
|
302
|
-
@property
|
|
301
|
+
@_builtins.property
|
|
303
302
|
@pulumi.getter(name="messageMaxBytes")
|
|
304
|
-
def message_max_bytes(self) -> Optional[pulumi.Input[
|
|
303
|
+
def message_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
305
304
|
"""
|
|
306
305
|
The maximum size of message that the server can receive.
|
|
307
306
|
"""
|
|
308
307
|
return pulumi.get(self, "message_max_bytes")
|
|
309
308
|
|
|
310
309
|
@message_max_bytes.setter
|
|
311
|
-
def message_max_bytes(self, value: Optional[pulumi.Input[
|
|
310
|
+
def message_max_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
312
311
|
pulumi.set(self, "message_max_bytes", value)
|
|
313
312
|
|
|
314
313
|
|
|
315
314
|
@pulumi.input_type
|
|
316
315
|
class _DatabaseKafkaConfigState:
|
|
317
316
|
def __init__(__self__, *,
|
|
318
|
-
auto_create_topics_enable: Optional[pulumi.Input[
|
|
319
|
-
cluster_id: Optional[pulumi.Input[
|
|
320
|
-
group_initial_rebalance_delay_ms: Optional[pulumi.Input[
|
|
321
|
-
group_max_session_timeout_ms: Optional[pulumi.Input[
|
|
322
|
-
group_min_session_timeout_ms: Optional[pulumi.Input[
|
|
323
|
-
log_cleaner_delete_retention_ms: Optional[pulumi.Input[
|
|
324
|
-
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[
|
|
325
|
-
log_flush_interval_ms: Optional[pulumi.Input[
|
|
326
|
-
log_index_interval_bytes: Optional[pulumi.Input[
|
|
327
|
-
log_message_downconversion_enable: Optional[pulumi.Input[
|
|
328
|
-
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[
|
|
329
|
-
log_preallocate: Optional[pulumi.Input[
|
|
330
|
-
log_retention_bytes: Optional[pulumi.Input[
|
|
331
|
-
log_retention_hours: Optional[pulumi.Input[
|
|
332
|
-
log_retention_ms: Optional[pulumi.Input[
|
|
333
|
-
log_roll_jitter_ms: Optional[pulumi.Input[
|
|
334
|
-
log_segment_delete_delay_ms: Optional[pulumi.Input[
|
|
335
|
-
message_max_bytes: Optional[pulumi.Input[
|
|
317
|
+
auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
318
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
319
|
+
group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
320
|
+
group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
321
|
+
group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
322
|
+
log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
323
|
+
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
324
|
+
log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
325
|
+
log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
326
|
+
log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
327
|
+
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
328
|
+
log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
329
|
+
log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
330
|
+
log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
331
|
+
log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
332
|
+
log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
333
|
+
log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
334
|
+
message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None):
|
|
336
335
|
"""
|
|
337
336
|
Input properties used for looking up and filtering DatabaseKafkaConfig resources.
|
|
338
|
-
:param pulumi.Input[
|
|
339
|
-
:param pulumi.Input[
|
|
340
|
-
:param pulumi.Input[
|
|
341
|
-
:param pulumi.Input[
|
|
342
|
-
:param pulumi.Input[
|
|
343
|
-
:param pulumi.Input[
|
|
344
|
-
:param pulumi.Input[
|
|
345
|
-
:param pulumi.Input[
|
|
346
|
-
:param pulumi.Input[
|
|
347
|
-
:param pulumi.Input[
|
|
348
|
-
:param pulumi.Input[
|
|
349
|
-
:param pulumi.Input[
|
|
350
|
-
:param pulumi.Input[
|
|
351
|
-
:param pulumi.Input[
|
|
352
|
-
:param pulumi.Input[
|
|
353
|
-
:param pulumi.Input[
|
|
354
|
-
:param pulumi.Input[
|
|
355
|
-
:param pulumi.Input[
|
|
337
|
+
:param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
|
|
338
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
|
|
339
|
+
:param pulumi.Input[_builtins.int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
340
|
+
:param pulumi.Input[_builtins.int] group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
341
|
+
:param pulumi.Input[_builtins.int] group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
342
|
+
:param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
|
|
343
|
+
:param pulumi.Input[_builtins.str] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
344
|
+
:param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
345
|
+
:param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
|
|
346
|
+
:param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
347
|
+
:param pulumi.Input[_builtins.str] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
348
|
+
:param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
|
|
349
|
+
:param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
|
|
350
|
+
:param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
|
|
351
|
+
:param pulumi.Input[_builtins.str] log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
352
|
+
:param pulumi.Input[_builtins.str] log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
353
|
+
:param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
|
|
354
|
+
:param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
|
|
356
355
|
"""
|
|
357
356
|
if auto_create_topics_enable is not None:
|
|
358
357
|
pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
|
|
@@ -391,220 +390,220 @@ class _DatabaseKafkaConfigState:
|
|
|
391
390
|
if message_max_bytes is not None:
|
|
392
391
|
pulumi.set(__self__, "message_max_bytes", message_max_bytes)
|
|
393
392
|
|
|
394
|
-
@property
|
|
393
|
+
@_builtins.property
|
|
395
394
|
@pulumi.getter(name="autoCreateTopicsEnable")
|
|
396
|
-
def auto_create_topics_enable(self) -> Optional[pulumi.Input[
|
|
395
|
+
def auto_create_topics_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
397
396
|
"""
|
|
398
397
|
Enable auto creation of topics.
|
|
399
398
|
"""
|
|
400
399
|
return pulumi.get(self, "auto_create_topics_enable")
|
|
401
400
|
|
|
402
401
|
@auto_create_topics_enable.setter
|
|
403
|
-
def auto_create_topics_enable(self, value: Optional[pulumi.Input[
|
|
402
|
+
def auto_create_topics_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
404
403
|
pulumi.set(self, "auto_create_topics_enable", value)
|
|
405
404
|
|
|
406
|
-
@property
|
|
405
|
+
@_builtins.property
|
|
407
406
|
@pulumi.getter(name="clusterId")
|
|
408
|
-
def cluster_id(self) -> Optional[pulumi.Input[
|
|
407
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
409
408
|
"""
|
|
410
409
|
The ID of the target Kafka cluster.
|
|
411
410
|
"""
|
|
412
411
|
return pulumi.get(self, "cluster_id")
|
|
413
412
|
|
|
414
413
|
@cluster_id.setter
|
|
415
|
-
def cluster_id(self, value: Optional[pulumi.Input[
|
|
414
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
416
415
|
pulumi.set(self, "cluster_id", value)
|
|
417
416
|
|
|
418
|
-
@property
|
|
417
|
+
@_builtins.property
|
|
419
418
|
@pulumi.getter(name="groupInitialRebalanceDelayMs")
|
|
420
|
-
def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[
|
|
419
|
+
def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
421
420
|
"""
|
|
422
421
|
The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
423
422
|
"""
|
|
424
423
|
return pulumi.get(self, "group_initial_rebalance_delay_ms")
|
|
425
424
|
|
|
426
425
|
@group_initial_rebalance_delay_ms.setter
|
|
427
|
-
def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[
|
|
426
|
+
def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
428
427
|
pulumi.set(self, "group_initial_rebalance_delay_ms", value)
|
|
429
428
|
|
|
430
|
-
@property
|
|
429
|
+
@_builtins.property
|
|
431
430
|
@pulumi.getter(name="groupMaxSessionTimeoutMs")
|
|
432
|
-
def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[
|
|
431
|
+
def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
433
432
|
"""
|
|
434
433
|
The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
435
434
|
"""
|
|
436
435
|
return pulumi.get(self, "group_max_session_timeout_ms")
|
|
437
436
|
|
|
438
437
|
@group_max_session_timeout_ms.setter
|
|
439
|
-
def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[
|
|
438
|
+
def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
440
439
|
pulumi.set(self, "group_max_session_timeout_ms", value)
|
|
441
440
|
|
|
442
|
-
@property
|
|
441
|
+
@_builtins.property
|
|
443
442
|
@pulumi.getter(name="groupMinSessionTimeoutMs")
|
|
444
|
-
def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[
|
|
443
|
+
def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
445
444
|
"""
|
|
446
445
|
The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
447
446
|
"""
|
|
448
447
|
return pulumi.get(self, "group_min_session_timeout_ms")
|
|
449
448
|
|
|
450
449
|
@group_min_session_timeout_ms.setter
|
|
451
|
-
def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[
|
|
450
|
+
def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
452
451
|
pulumi.set(self, "group_min_session_timeout_ms", value)
|
|
453
452
|
|
|
454
|
-
@property
|
|
453
|
+
@_builtins.property
|
|
455
454
|
@pulumi.getter(name="logCleanerDeleteRetentionMs")
|
|
456
|
-
def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[
|
|
455
|
+
def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
457
456
|
"""
|
|
458
457
|
How long are delete records retained?
|
|
459
458
|
"""
|
|
460
459
|
return pulumi.get(self, "log_cleaner_delete_retention_ms")
|
|
461
460
|
|
|
462
461
|
@log_cleaner_delete_retention_ms.setter
|
|
463
|
-
def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[
|
|
462
|
+
def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
464
463
|
pulumi.set(self, "log_cleaner_delete_retention_ms", value)
|
|
465
464
|
|
|
466
|
-
@property
|
|
465
|
+
@_builtins.property
|
|
467
466
|
@pulumi.getter(name="logCleanerMinCompactionLagMs")
|
|
468
|
-
def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[
|
|
467
|
+
def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
469
468
|
"""
|
|
470
469
|
The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
471
470
|
"""
|
|
472
471
|
return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
|
|
473
472
|
|
|
474
473
|
@log_cleaner_min_compaction_lag_ms.setter
|
|
475
|
-
def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[
|
|
474
|
+
def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
476
475
|
pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)
|
|
477
476
|
|
|
478
|
-
@property
|
|
477
|
+
@_builtins.property
|
|
479
478
|
@pulumi.getter(name="logFlushIntervalMs")
|
|
480
|
-
def log_flush_interval_ms(self) -> Optional[pulumi.Input[
|
|
479
|
+
def log_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
481
480
|
"""
|
|
482
481
|
The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
483
482
|
"""
|
|
484
483
|
return pulumi.get(self, "log_flush_interval_ms")
|
|
485
484
|
|
|
486
485
|
@log_flush_interval_ms.setter
|
|
487
|
-
def log_flush_interval_ms(self, value: Optional[pulumi.Input[
|
|
486
|
+
def log_flush_interval_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
488
487
|
pulumi.set(self, "log_flush_interval_ms", value)
|
|
489
488
|
|
|
490
|
-
@property
|
|
489
|
+
@_builtins.property
|
|
491
490
|
@pulumi.getter(name="logIndexIntervalBytes")
|
|
492
|
-
def log_index_interval_bytes(self) -> Optional[pulumi.Input[
|
|
491
|
+
def log_index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
493
492
|
"""
|
|
494
493
|
The interval with which Kafka adds an entry to the offset index.
|
|
495
494
|
"""
|
|
496
495
|
return pulumi.get(self, "log_index_interval_bytes")
|
|
497
496
|
|
|
498
497
|
@log_index_interval_bytes.setter
|
|
499
|
-
def log_index_interval_bytes(self, value: Optional[pulumi.Input[
|
|
498
|
+
def log_index_interval_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
500
499
|
pulumi.set(self, "log_index_interval_bytes", value)
|
|
501
500
|
|
|
502
|
-
@property
|
|
501
|
+
@_builtins.property
|
|
503
502
|
@pulumi.getter(name="logMessageDownconversionEnable")
|
|
504
|
-
def log_message_downconversion_enable(self) -> Optional[pulumi.Input[
|
|
503
|
+
def log_message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
505
504
|
"""
|
|
506
505
|
This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
507
506
|
"""
|
|
508
507
|
return pulumi.get(self, "log_message_downconversion_enable")
|
|
509
508
|
|
|
510
509
|
@log_message_downconversion_enable.setter
|
|
511
|
-
def log_message_downconversion_enable(self, value: Optional[pulumi.Input[
|
|
510
|
+
def log_message_downconversion_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
512
511
|
pulumi.set(self, "log_message_downconversion_enable", value)
|
|
513
512
|
|
|
514
|
-
@property
|
|
513
|
+
@_builtins.property
|
|
515
514
|
@pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
|
|
516
|
-
def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[
|
|
515
|
+
def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
517
516
|
"""
|
|
518
517
|
The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
519
518
|
"""
|
|
520
519
|
return pulumi.get(self, "log_message_timestamp_difference_max_ms")
|
|
521
520
|
|
|
522
521
|
@log_message_timestamp_difference_max_ms.setter
|
|
523
|
-
def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[
|
|
522
|
+
def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
524
523
|
pulumi.set(self, "log_message_timestamp_difference_max_ms", value)
|
|
525
524
|
|
|
526
|
-
@property
|
|
525
|
+
@_builtins.property
|
|
527
526
|
@pulumi.getter(name="logPreallocate")
|
|
528
|
-
def log_preallocate(self) -> Optional[pulumi.Input[
|
|
527
|
+
def log_preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
529
528
|
"""
|
|
530
529
|
Controls whether to preallocate a file when creating a new segment.
|
|
531
530
|
"""
|
|
532
531
|
return pulumi.get(self, "log_preallocate")
|
|
533
532
|
|
|
534
533
|
@log_preallocate.setter
|
|
535
|
-
def log_preallocate(self, value: Optional[pulumi.Input[
|
|
534
|
+
def log_preallocate(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
536
535
|
pulumi.set(self, "log_preallocate", value)
|
|
537
536
|
|
|
538
|
-
@property
|
|
537
|
+
@_builtins.property
|
|
539
538
|
@pulumi.getter(name="logRetentionBytes")
|
|
540
|
-
def log_retention_bytes(self) -> Optional[pulumi.Input[
|
|
539
|
+
def log_retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
541
540
|
"""
|
|
542
541
|
The maximum size of the log before deleting messages.
|
|
543
542
|
"""
|
|
544
543
|
return pulumi.get(self, "log_retention_bytes")
|
|
545
544
|
|
|
546
545
|
@log_retention_bytes.setter
|
|
547
|
-
def log_retention_bytes(self, value: Optional[pulumi.Input[
|
|
546
|
+
def log_retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
548
547
|
pulumi.set(self, "log_retention_bytes", value)
|
|
549
548
|
|
|
550
|
-
@property
|
|
549
|
+
@_builtins.property
|
|
551
550
|
@pulumi.getter(name="logRetentionHours")
|
|
552
|
-
def log_retention_hours(self) -> Optional[pulumi.Input[
|
|
551
|
+
def log_retention_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
553
552
|
"""
|
|
554
553
|
The number of hours to keep a log file before deleting it.
|
|
555
554
|
"""
|
|
556
555
|
return pulumi.get(self, "log_retention_hours")
|
|
557
556
|
|
|
558
557
|
@log_retention_hours.setter
|
|
559
|
-
def log_retention_hours(self, value: Optional[pulumi.Input[
|
|
558
|
+
def log_retention_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
560
559
|
pulumi.set(self, "log_retention_hours", value)
|
|
561
560
|
|
|
562
|
-
@property
|
|
561
|
+
@_builtins.property
|
|
563
562
|
@pulumi.getter(name="logRetentionMs")
|
|
564
|
-
def log_retention_ms(self) -> Optional[pulumi.Input[
|
|
563
|
+
def log_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
565
564
|
"""
|
|
566
565
|
The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
567
566
|
"""
|
|
568
567
|
return pulumi.get(self, "log_retention_ms")
|
|
569
568
|
|
|
570
569
|
@log_retention_ms.setter
|
|
571
|
-
def log_retention_ms(self, value: Optional[pulumi.Input[
|
|
570
|
+
def log_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
572
571
|
pulumi.set(self, "log_retention_ms", value)
|
|
573
572
|
|
|
574
|
-
@property
|
|
573
|
+
@_builtins.property
|
|
575
574
|
@pulumi.getter(name="logRollJitterMs")
|
|
576
|
-
def log_roll_jitter_ms(self) -> Optional[pulumi.Input[
|
|
575
|
+
def log_roll_jitter_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
577
576
|
"""
|
|
578
577
|
The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
579
578
|
"""
|
|
580
579
|
return pulumi.get(self, "log_roll_jitter_ms")
|
|
581
580
|
|
|
582
581
|
@log_roll_jitter_ms.setter
|
|
583
|
-
def log_roll_jitter_ms(self, value: Optional[pulumi.Input[
|
|
582
|
+
def log_roll_jitter_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
584
583
|
pulumi.set(self, "log_roll_jitter_ms", value)
|
|
585
584
|
|
|
586
|
-
@property
|
|
585
|
+
@_builtins.property
|
|
587
586
|
@pulumi.getter(name="logSegmentDeleteDelayMs")
|
|
588
|
-
def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[
|
|
587
|
+
def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
589
588
|
"""
|
|
590
589
|
The amount of time to wait before deleting a file from the filesystem.
|
|
591
590
|
"""
|
|
592
591
|
return pulumi.get(self, "log_segment_delete_delay_ms")
|
|
593
592
|
|
|
594
593
|
@log_segment_delete_delay_ms.setter
|
|
595
|
-
def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[
|
|
594
|
+
def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
596
595
|
pulumi.set(self, "log_segment_delete_delay_ms", value)
|
|
597
596
|
|
|
598
|
-
@property
|
|
597
|
+
@_builtins.property
|
|
599
598
|
@pulumi.getter(name="messageMaxBytes")
|
|
600
|
-
def message_max_bytes(self) -> Optional[pulumi.Input[
|
|
599
|
+
def message_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
601
600
|
"""
|
|
602
601
|
The maximum size of message that the server can receive.
|
|
603
602
|
"""
|
|
604
603
|
return pulumi.get(self, "message_max_bytes")
|
|
605
604
|
|
|
606
605
|
@message_max_bytes.setter
|
|
607
|
-
def message_max_bytes(self, value: Optional[pulumi.Input[
|
|
606
|
+
def message_max_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
608
607
|
pulumi.set(self, "message_max_bytes", value)
|
|
609
608
|
|
|
610
609
|
|
|
@@ -614,24 +613,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
614
613
|
def __init__(__self__,
|
|
615
614
|
resource_name: str,
|
|
616
615
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
617
|
-
auto_create_topics_enable: Optional[pulumi.Input[
|
|
618
|
-
cluster_id: Optional[pulumi.Input[
|
|
619
|
-
group_initial_rebalance_delay_ms: Optional[pulumi.Input[
|
|
620
|
-
group_max_session_timeout_ms: Optional[pulumi.Input[
|
|
621
|
-
group_min_session_timeout_ms: Optional[pulumi.Input[
|
|
622
|
-
log_cleaner_delete_retention_ms: Optional[pulumi.Input[
|
|
623
|
-
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[
|
|
624
|
-
log_flush_interval_ms: Optional[pulumi.Input[
|
|
625
|
-
log_index_interval_bytes: Optional[pulumi.Input[
|
|
626
|
-
log_message_downconversion_enable: Optional[pulumi.Input[
|
|
627
|
-
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[
|
|
628
|
-
log_preallocate: Optional[pulumi.Input[
|
|
629
|
-
log_retention_bytes: Optional[pulumi.Input[
|
|
630
|
-
log_retention_hours: Optional[pulumi.Input[
|
|
631
|
-
log_retention_ms: Optional[pulumi.Input[
|
|
632
|
-
log_roll_jitter_ms: Optional[pulumi.Input[
|
|
633
|
-
log_segment_delete_delay_ms: Optional[pulumi.Input[
|
|
634
|
-
message_max_bytes: Optional[pulumi.Input[
|
|
616
|
+
auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
617
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
618
|
+
group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
619
|
+
group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
620
|
+
group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
621
|
+
log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
622
|
+
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
623
|
+
log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
624
|
+
log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
625
|
+
log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
626
|
+
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
627
|
+
log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
628
|
+
log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
629
|
+
log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
630
|
+
log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
631
|
+
log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
632
|
+
log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
633
|
+
message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
635
634
|
__props__=None):
|
|
636
635
|
"""
|
|
637
636
|
Provides a virtual resource that can be used to change advanced configuration
|
|
@@ -683,24 +682,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
683
682
|
|
|
684
683
|
:param str resource_name: The name of the resource.
|
|
685
684
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
686
|
-
:param pulumi.Input[
|
|
687
|
-
:param pulumi.Input[
|
|
688
|
-
:param pulumi.Input[
|
|
689
|
-
:param pulumi.Input[
|
|
690
|
-
:param pulumi.Input[
|
|
691
|
-
:param pulumi.Input[
|
|
692
|
-
:param pulumi.Input[
|
|
693
|
-
:param pulumi.Input[
|
|
694
|
-
:param pulumi.Input[
|
|
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[
|
|
685
|
+
:param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
|
|
686
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
|
|
687
|
+
:param pulumi.Input[_builtins.int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
688
|
+
:param pulumi.Input[_builtins.int] group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
689
|
+
:param pulumi.Input[_builtins.int] group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
690
|
+
:param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
|
|
691
|
+
:param pulumi.Input[_builtins.str] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
692
|
+
:param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
693
|
+
:param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
|
|
694
|
+
:param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
695
|
+
:param pulumi.Input[_builtins.str] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
696
|
+
:param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
|
|
697
|
+
:param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
|
|
698
|
+
:param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
|
|
699
|
+
:param pulumi.Input[_builtins.str] log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
700
|
+
:param pulumi.Input[_builtins.str] log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
701
|
+
:param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
|
|
702
|
+
:param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
|
|
704
703
|
"""
|
|
705
704
|
...
|
|
706
705
|
@overload
|
|
@@ -771,24 +770,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
771
770
|
def _internal_init(__self__,
|
|
772
771
|
resource_name: str,
|
|
773
772
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
774
|
-
auto_create_topics_enable: Optional[pulumi.Input[
|
|
775
|
-
cluster_id: Optional[pulumi.Input[
|
|
776
|
-
group_initial_rebalance_delay_ms: Optional[pulumi.Input[
|
|
777
|
-
group_max_session_timeout_ms: Optional[pulumi.Input[
|
|
778
|
-
group_min_session_timeout_ms: Optional[pulumi.Input[
|
|
779
|
-
log_cleaner_delete_retention_ms: Optional[pulumi.Input[
|
|
780
|
-
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[
|
|
781
|
-
log_flush_interval_ms: Optional[pulumi.Input[
|
|
782
|
-
log_index_interval_bytes: Optional[pulumi.Input[
|
|
783
|
-
log_message_downconversion_enable: Optional[pulumi.Input[
|
|
784
|
-
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[
|
|
785
|
-
log_preallocate: Optional[pulumi.Input[
|
|
786
|
-
log_retention_bytes: Optional[pulumi.Input[
|
|
787
|
-
log_retention_hours: Optional[pulumi.Input[
|
|
788
|
-
log_retention_ms: Optional[pulumi.Input[
|
|
789
|
-
log_roll_jitter_ms: Optional[pulumi.Input[
|
|
790
|
-
log_segment_delete_delay_ms: Optional[pulumi.Input[
|
|
791
|
-
message_max_bytes: Optional[pulumi.Input[
|
|
773
|
+
auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
774
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
775
|
+
group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
776
|
+
group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
777
|
+
group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
778
|
+
log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
779
|
+
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
780
|
+
log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
781
|
+
log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
782
|
+
log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
783
|
+
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
784
|
+
log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
785
|
+
log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
786
|
+
log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
787
|
+
log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
788
|
+
log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
789
|
+
log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
790
|
+
message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
792
791
|
__props__=None):
|
|
793
792
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
794
793
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -828,24 +827,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
828
827
|
def get(resource_name: str,
|
|
829
828
|
id: pulumi.Input[str],
|
|
830
829
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
831
|
-
auto_create_topics_enable: Optional[pulumi.Input[
|
|
832
|
-
cluster_id: Optional[pulumi.Input[
|
|
833
|
-
group_initial_rebalance_delay_ms: Optional[pulumi.Input[
|
|
834
|
-
group_max_session_timeout_ms: Optional[pulumi.Input[
|
|
835
|
-
group_min_session_timeout_ms: Optional[pulumi.Input[
|
|
836
|
-
log_cleaner_delete_retention_ms: Optional[pulumi.Input[
|
|
837
|
-
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[
|
|
838
|
-
log_flush_interval_ms: Optional[pulumi.Input[
|
|
839
|
-
log_index_interval_bytes: Optional[pulumi.Input[
|
|
840
|
-
log_message_downconversion_enable: Optional[pulumi.Input[
|
|
841
|
-
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[
|
|
842
|
-
log_preallocate: Optional[pulumi.Input[
|
|
843
|
-
log_retention_bytes: Optional[pulumi.Input[
|
|
844
|
-
log_retention_hours: Optional[pulumi.Input[
|
|
845
|
-
log_retention_ms: Optional[pulumi.Input[
|
|
846
|
-
log_roll_jitter_ms: Optional[pulumi.Input[
|
|
847
|
-
log_segment_delete_delay_ms: Optional[pulumi.Input[
|
|
848
|
-
message_max_bytes: Optional[pulumi.Input[
|
|
830
|
+
auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
831
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
832
|
+
group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
833
|
+
group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
834
|
+
group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
835
|
+
log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
836
|
+
log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
837
|
+
log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
838
|
+
log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
|
|
839
|
+
log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
840
|
+
log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
841
|
+
log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
842
|
+
log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
|
|
843
|
+
log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
|
|
844
|
+
log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
845
|
+
log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
|
|
846
|
+
log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
|
|
847
|
+
message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabaseKafkaConfig':
|
|
849
848
|
"""
|
|
850
849
|
Get an existing DatabaseKafkaConfig resource's state with the given name, id, and optional extra
|
|
851
850
|
properties used to qualify the lookup.
|
|
@@ -853,24 +852,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
853
852
|
:param str resource_name: The unique name of the resulting resource.
|
|
854
853
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
855
854
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
856
|
-
:param pulumi.Input[
|
|
857
|
-
:param pulumi.Input[
|
|
858
|
-
:param pulumi.Input[
|
|
859
|
-
:param pulumi.Input[
|
|
860
|
-
:param pulumi.Input[
|
|
861
|
-
:param pulumi.Input[
|
|
862
|
-
:param pulumi.Input[
|
|
863
|
-
:param pulumi.Input[
|
|
864
|
-
:param pulumi.Input[
|
|
865
|
-
:param pulumi.Input[
|
|
866
|
-
:param pulumi.Input[
|
|
867
|
-
:param pulumi.Input[
|
|
868
|
-
:param pulumi.Input[
|
|
869
|
-
:param pulumi.Input[
|
|
870
|
-
:param pulumi.Input[
|
|
871
|
-
:param pulumi.Input[
|
|
872
|
-
:param pulumi.Input[
|
|
873
|
-
:param pulumi.Input[
|
|
855
|
+
:param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
|
|
856
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
|
|
857
|
+
:param pulumi.Input[_builtins.int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
858
|
+
:param pulumi.Input[_builtins.int] group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
859
|
+
:param pulumi.Input[_builtins.int] group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
860
|
+
:param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
|
|
861
|
+
:param pulumi.Input[_builtins.str] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
862
|
+
:param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
863
|
+
:param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
|
|
864
|
+
:param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
865
|
+
:param pulumi.Input[_builtins.str] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
866
|
+
:param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
|
|
867
|
+
:param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
|
|
868
|
+
:param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
|
|
869
|
+
:param pulumi.Input[_builtins.str] log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
870
|
+
:param pulumi.Input[_builtins.str] log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
871
|
+
:param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
|
|
872
|
+
:param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
|
|
874
873
|
"""
|
|
875
874
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
876
875
|
|
|
@@ -896,145 +895,145 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
|
|
|
896
895
|
__props__.__dict__["message_max_bytes"] = message_max_bytes
|
|
897
896
|
return DatabaseKafkaConfig(resource_name, opts=opts, __props__=__props__)
|
|
898
897
|
|
|
899
|
-
@property
|
|
898
|
+
@_builtins.property
|
|
900
899
|
@pulumi.getter(name="autoCreateTopicsEnable")
|
|
901
|
-
def auto_create_topics_enable(self) -> pulumi.Output[
|
|
900
|
+
def auto_create_topics_enable(self) -> pulumi.Output[_builtins.bool]:
|
|
902
901
|
"""
|
|
903
902
|
Enable auto creation of topics.
|
|
904
903
|
"""
|
|
905
904
|
return pulumi.get(self, "auto_create_topics_enable")
|
|
906
905
|
|
|
907
|
-
@property
|
|
906
|
+
@_builtins.property
|
|
908
907
|
@pulumi.getter(name="clusterId")
|
|
909
|
-
def cluster_id(self) -> pulumi.Output[
|
|
908
|
+
def cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
910
909
|
"""
|
|
911
910
|
The ID of the target Kafka cluster.
|
|
912
911
|
"""
|
|
913
912
|
return pulumi.get(self, "cluster_id")
|
|
914
913
|
|
|
915
|
-
@property
|
|
914
|
+
@_builtins.property
|
|
916
915
|
@pulumi.getter(name="groupInitialRebalanceDelayMs")
|
|
917
|
-
def group_initial_rebalance_delay_ms(self) -> pulumi.Output[
|
|
916
|
+
def group_initial_rebalance_delay_ms(self) -> pulumi.Output[_builtins.int]:
|
|
918
917
|
"""
|
|
919
918
|
The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
|
|
920
919
|
"""
|
|
921
920
|
return pulumi.get(self, "group_initial_rebalance_delay_ms")
|
|
922
921
|
|
|
923
|
-
@property
|
|
922
|
+
@_builtins.property
|
|
924
923
|
@pulumi.getter(name="groupMaxSessionTimeoutMs")
|
|
925
|
-
def group_max_session_timeout_ms(self) -> pulumi.Output[
|
|
924
|
+
def group_max_session_timeout_ms(self) -> pulumi.Output[_builtins.int]:
|
|
926
925
|
"""
|
|
927
926
|
The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
928
927
|
"""
|
|
929
928
|
return pulumi.get(self, "group_max_session_timeout_ms")
|
|
930
929
|
|
|
931
|
-
@property
|
|
930
|
+
@_builtins.property
|
|
932
931
|
@pulumi.getter(name="groupMinSessionTimeoutMs")
|
|
933
|
-
def group_min_session_timeout_ms(self) -> pulumi.Output[
|
|
932
|
+
def group_min_session_timeout_ms(self) -> pulumi.Output[_builtins.int]:
|
|
934
933
|
"""
|
|
935
934
|
The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures.
|
|
936
935
|
"""
|
|
937
936
|
return pulumi.get(self, "group_min_session_timeout_ms")
|
|
938
937
|
|
|
939
|
-
@property
|
|
938
|
+
@_builtins.property
|
|
940
939
|
@pulumi.getter(name="logCleanerDeleteRetentionMs")
|
|
941
|
-
def log_cleaner_delete_retention_ms(self) -> pulumi.Output[
|
|
940
|
+
def log_cleaner_delete_retention_ms(self) -> pulumi.Output[_builtins.int]:
|
|
942
941
|
"""
|
|
943
942
|
How long are delete records retained?
|
|
944
943
|
"""
|
|
945
944
|
return pulumi.get(self, "log_cleaner_delete_retention_ms")
|
|
946
945
|
|
|
947
|
-
@property
|
|
946
|
+
@_builtins.property
|
|
948
947
|
@pulumi.getter(name="logCleanerMinCompactionLagMs")
|
|
949
|
-
def log_cleaner_min_compaction_lag_ms(self) -> pulumi.Output[
|
|
948
|
+
def log_cleaner_min_compaction_lag_ms(self) -> pulumi.Output[_builtins.str]:
|
|
950
949
|
"""
|
|
951
950
|
The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
|
|
952
951
|
"""
|
|
953
952
|
return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
|
|
954
953
|
|
|
955
|
-
@property
|
|
954
|
+
@_builtins.property
|
|
956
955
|
@pulumi.getter(name="logFlushIntervalMs")
|
|
957
|
-
def log_flush_interval_ms(self) -> pulumi.Output[
|
|
956
|
+
def log_flush_interval_ms(self) -> pulumi.Output[_builtins.str]:
|
|
958
957
|
"""
|
|
959
958
|
The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
|
|
960
959
|
"""
|
|
961
960
|
return pulumi.get(self, "log_flush_interval_ms")
|
|
962
961
|
|
|
963
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
964
963
|
@pulumi.getter(name="logIndexIntervalBytes")
|
|
965
|
-
def log_index_interval_bytes(self) -> pulumi.Output[
|
|
964
|
+
def log_index_interval_bytes(self) -> pulumi.Output[_builtins.int]:
|
|
966
965
|
"""
|
|
967
966
|
The interval with which Kafka adds an entry to the offset index.
|
|
968
967
|
"""
|
|
969
968
|
return pulumi.get(self, "log_index_interval_bytes")
|
|
970
969
|
|
|
971
|
-
@property
|
|
970
|
+
@_builtins.property
|
|
972
971
|
@pulumi.getter(name="logMessageDownconversionEnable")
|
|
973
|
-
def log_message_downconversion_enable(self) -> pulumi.Output[
|
|
972
|
+
def log_message_downconversion_enable(self) -> pulumi.Output[_builtins.bool]:
|
|
974
973
|
"""
|
|
975
974
|
This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
|
|
976
975
|
"""
|
|
977
976
|
return pulumi.get(self, "log_message_downconversion_enable")
|
|
978
977
|
|
|
979
|
-
@property
|
|
978
|
+
@_builtins.property
|
|
980
979
|
@pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
|
|
981
|
-
def log_message_timestamp_difference_max_ms(self) -> pulumi.Output[
|
|
980
|
+
def log_message_timestamp_difference_max_ms(self) -> pulumi.Output[_builtins.str]:
|
|
982
981
|
"""
|
|
983
982
|
The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
|
|
984
983
|
"""
|
|
985
984
|
return pulumi.get(self, "log_message_timestamp_difference_max_ms")
|
|
986
985
|
|
|
987
|
-
@property
|
|
986
|
+
@_builtins.property
|
|
988
987
|
@pulumi.getter(name="logPreallocate")
|
|
989
|
-
def log_preallocate(self) -> pulumi.Output[
|
|
988
|
+
def log_preallocate(self) -> pulumi.Output[_builtins.bool]:
|
|
990
989
|
"""
|
|
991
990
|
Controls whether to preallocate a file when creating a new segment.
|
|
992
991
|
"""
|
|
993
992
|
return pulumi.get(self, "log_preallocate")
|
|
994
993
|
|
|
995
|
-
@property
|
|
994
|
+
@_builtins.property
|
|
996
995
|
@pulumi.getter(name="logRetentionBytes")
|
|
997
|
-
def log_retention_bytes(self) -> pulumi.Output[
|
|
996
|
+
def log_retention_bytes(self) -> pulumi.Output[_builtins.str]:
|
|
998
997
|
"""
|
|
999
998
|
The maximum size of the log before deleting messages.
|
|
1000
999
|
"""
|
|
1001
1000
|
return pulumi.get(self, "log_retention_bytes")
|
|
1002
1001
|
|
|
1003
|
-
@property
|
|
1002
|
+
@_builtins.property
|
|
1004
1003
|
@pulumi.getter(name="logRetentionHours")
|
|
1005
|
-
def log_retention_hours(self) -> pulumi.Output[
|
|
1004
|
+
def log_retention_hours(self) -> pulumi.Output[_builtins.int]:
|
|
1006
1005
|
"""
|
|
1007
1006
|
The number of hours to keep a log file before deleting it.
|
|
1008
1007
|
"""
|
|
1009
1008
|
return pulumi.get(self, "log_retention_hours")
|
|
1010
1009
|
|
|
1011
|
-
@property
|
|
1010
|
+
@_builtins.property
|
|
1012
1011
|
@pulumi.getter(name="logRetentionMs")
|
|
1013
|
-
def log_retention_ms(self) -> pulumi.Output[
|
|
1012
|
+
def log_retention_ms(self) -> pulumi.Output[_builtins.str]:
|
|
1014
1013
|
"""
|
|
1015
1014
|
The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
|
|
1016
1015
|
"""
|
|
1017
1016
|
return pulumi.get(self, "log_retention_ms")
|
|
1018
1017
|
|
|
1019
|
-
@property
|
|
1018
|
+
@_builtins.property
|
|
1020
1019
|
@pulumi.getter(name="logRollJitterMs")
|
|
1021
|
-
def log_roll_jitter_ms(self) -> pulumi.Output[
|
|
1020
|
+
def log_roll_jitter_ms(self) -> pulumi.Output[_builtins.str]:
|
|
1022
1021
|
"""
|
|
1023
1022
|
The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
|
|
1024
1023
|
"""
|
|
1025
1024
|
return pulumi.get(self, "log_roll_jitter_ms")
|
|
1026
1025
|
|
|
1027
|
-
@property
|
|
1026
|
+
@_builtins.property
|
|
1028
1027
|
@pulumi.getter(name="logSegmentDeleteDelayMs")
|
|
1029
|
-
def log_segment_delete_delay_ms(self) -> pulumi.Output[
|
|
1028
|
+
def log_segment_delete_delay_ms(self) -> pulumi.Output[_builtins.int]:
|
|
1030
1029
|
"""
|
|
1031
1030
|
The amount of time to wait before deleting a file from the filesystem.
|
|
1032
1031
|
"""
|
|
1033
1032
|
return pulumi.get(self, "log_segment_delete_delay_ms")
|
|
1034
1033
|
|
|
1035
|
-
@property
|
|
1034
|
+
@_builtins.property
|
|
1036
1035
|
@pulumi.getter(name="messageMaxBytes")
|
|
1037
|
-
def message_max_bytes(self) -> pulumi.Output[
|
|
1036
|
+
def message_max_bytes(self) -> pulumi.Output[_builtins.int]:
|
|
1038
1037
|
"""
|
|
1039
1038
|
The maximum size of message that the server can receive.
|
|
1040
1039
|
"""
|