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