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,34 +19,34 @@ __all__ = ['DatabaseRedisConfigArgs', 'DatabaseRedisConfig']
|
|
|
20
19
|
@pulumi.input_type
|
|
21
20
|
class DatabaseRedisConfigArgs:
|
|
22
21
|
def __init__(__self__, *,
|
|
23
|
-
cluster_id: pulumi.Input[
|
|
24
|
-
acl_channels_default: Optional[pulumi.Input[
|
|
25
|
-
io_threads: Optional[pulumi.Input[
|
|
26
|
-
lfu_decay_time: Optional[pulumi.Input[
|
|
27
|
-
lfu_log_factor: Optional[pulumi.Input[
|
|
28
|
-
maxmemory_policy: Optional[pulumi.Input[
|
|
29
|
-
notify_keyspace_events: Optional[pulumi.Input[
|
|
30
|
-
number_of_databases: Optional[pulumi.Input[
|
|
31
|
-
persistence: Optional[pulumi.Input[
|
|
32
|
-
pubsub_client_output_buffer_limit: Optional[pulumi.Input[
|
|
33
|
-
ssl: Optional[pulumi.Input[
|
|
34
|
-
timeout: Optional[pulumi.Input[
|
|
22
|
+
cluster_id: pulumi.Input[_builtins.str],
|
|
23
|
+
acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
|
|
24
|
+
io_threads: Optional[pulumi.Input[_builtins.int]] = None,
|
|
25
|
+
lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
|
|
26
|
+
lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
|
|
27
|
+
maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
persistence: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
timeout: Optional[pulumi.Input[_builtins.int]] = None):
|
|
35
34
|
"""
|
|
36
35
|
The set of arguments for constructing a DatabaseRedisConfig resource.
|
|
37
|
-
:param pulumi.Input[
|
|
38
|
-
:param pulumi.Input[
|
|
39
|
-
:param pulumi.Input[
|
|
40
|
-
:param pulumi.Input[
|
|
41
|
-
:param pulumi.Input[
|
|
42
|
-
:param pulumi.Input[
|
|
43
|
-
:param pulumi.Input[
|
|
44
|
-
:param pulumi.Input[
|
|
45
|
-
:param pulumi.Input[
|
|
46
|
-
:param pulumi.Input[
|
|
47
|
-
:param pulumi.Input[
|
|
36
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Redis cluster.
|
|
37
|
+
:param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
38
|
+
:param pulumi.Input[_builtins.int] io_threads: The Redis IO thread count.
|
|
39
|
+
:param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
|
|
40
|
+
:param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
41
|
+
:param pulumi.Input[_builtins.str] maxmemory_policy: A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
42
|
+
:param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
43
|
+
:param pulumi.Input[_builtins.int] number_of_databases: The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
44
|
+
:param pulumi.Input[_builtins.str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
45
|
+
:param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
46
|
+
:param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Redis.
|
|
48
47
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
49
48
|
- When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
|
|
50
|
-
:param pulumi.Input[
|
|
49
|
+
:param pulumi.Input[_builtins.int] timeout: The Redis idle connection timeout in seconds.
|
|
51
50
|
"""
|
|
52
51
|
pulumi.set(__self__, "cluster_id", cluster_id)
|
|
53
52
|
if acl_channels_default is not None:
|
|
@@ -73,129 +72,129 @@ class DatabaseRedisConfigArgs:
|
|
|
73
72
|
if timeout is not None:
|
|
74
73
|
pulumi.set(__self__, "timeout", timeout)
|
|
75
74
|
|
|
76
|
-
@property
|
|
75
|
+
@_builtins.property
|
|
77
76
|
@pulumi.getter(name="clusterId")
|
|
78
|
-
def cluster_id(self) -> pulumi.Input[
|
|
77
|
+
def cluster_id(self) -> pulumi.Input[_builtins.str]:
|
|
79
78
|
"""
|
|
80
79
|
The ID of the target Redis cluster.
|
|
81
80
|
"""
|
|
82
81
|
return pulumi.get(self, "cluster_id")
|
|
83
82
|
|
|
84
83
|
@cluster_id.setter
|
|
85
|
-
def cluster_id(self, value: pulumi.Input[
|
|
84
|
+
def cluster_id(self, value: pulumi.Input[_builtins.str]):
|
|
86
85
|
pulumi.set(self, "cluster_id", value)
|
|
87
86
|
|
|
88
|
-
@property
|
|
87
|
+
@_builtins.property
|
|
89
88
|
@pulumi.getter(name="aclChannelsDefault")
|
|
90
|
-
def acl_channels_default(self) -> Optional[pulumi.Input[
|
|
89
|
+
def acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
91
90
|
"""
|
|
92
91
|
Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
93
92
|
"""
|
|
94
93
|
return pulumi.get(self, "acl_channels_default")
|
|
95
94
|
|
|
96
95
|
@acl_channels_default.setter
|
|
97
|
-
def acl_channels_default(self, value: Optional[pulumi.Input[
|
|
96
|
+
def acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
98
97
|
pulumi.set(self, "acl_channels_default", value)
|
|
99
98
|
|
|
100
|
-
@property
|
|
99
|
+
@_builtins.property
|
|
101
100
|
@pulumi.getter(name="ioThreads")
|
|
102
|
-
def io_threads(self) -> Optional[pulumi.Input[
|
|
101
|
+
def io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
103
102
|
"""
|
|
104
103
|
The Redis IO thread count.
|
|
105
104
|
"""
|
|
106
105
|
return pulumi.get(self, "io_threads")
|
|
107
106
|
|
|
108
107
|
@io_threads.setter
|
|
109
|
-
def io_threads(self, value: Optional[pulumi.Input[
|
|
108
|
+
def io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
110
109
|
pulumi.set(self, "io_threads", value)
|
|
111
110
|
|
|
112
|
-
@property
|
|
111
|
+
@_builtins.property
|
|
113
112
|
@pulumi.getter(name="lfuDecayTime")
|
|
114
|
-
def lfu_decay_time(self) -> Optional[pulumi.Input[
|
|
113
|
+
def lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
115
114
|
"""
|
|
116
115
|
The LFU maxmemory policy counter decay time in minutes.
|
|
117
116
|
"""
|
|
118
117
|
return pulumi.get(self, "lfu_decay_time")
|
|
119
118
|
|
|
120
119
|
@lfu_decay_time.setter
|
|
121
|
-
def lfu_decay_time(self, value: Optional[pulumi.Input[
|
|
120
|
+
def lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
122
121
|
pulumi.set(self, "lfu_decay_time", value)
|
|
123
122
|
|
|
124
|
-
@property
|
|
123
|
+
@_builtins.property
|
|
125
124
|
@pulumi.getter(name="lfuLogFactor")
|
|
126
|
-
def lfu_log_factor(self) -> Optional[pulumi.Input[
|
|
125
|
+
def lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
127
126
|
"""
|
|
128
127
|
The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
129
128
|
"""
|
|
130
129
|
return pulumi.get(self, "lfu_log_factor")
|
|
131
130
|
|
|
132
131
|
@lfu_log_factor.setter
|
|
133
|
-
def lfu_log_factor(self, value: Optional[pulumi.Input[
|
|
132
|
+
def lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
134
133
|
pulumi.set(self, "lfu_log_factor", value)
|
|
135
134
|
|
|
136
|
-
@property
|
|
135
|
+
@_builtins.property
|
|
137
136
|
@pulumi.getter(name="maxmemoryPolicy")
|
|
138
|
-
def maxmemory_policy(self) -> Optional[pulumi.Input[
|
|
137
|
+
def maxmemory_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
139
138
|
"""
|
|
140
139
|
A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
141
140
|
"""
|
|
142
141
|
return pulumi.get(self, "maxmemory_policy")
|
|
143
142
|
|
|
144
143
|
@maxmemory_policy.setter
|
|
145
|
-
def maxmemory_policy(self, value: Optional[pulumi.Input[
|
|
144
|
+
def maxmemory_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
146
145
|
pulumi.set(self, "maxmemory_policy", value)
|
|
147
146
|
|
|
148
|
-
@property
|
|
147
|
+
@_builtins.property
|
|
149
148
|
@pulumi.getter(name="notifyKeyspaceEvents")
|
|
150
|
-
def notify_keyspace_events(self) -> Optional[pulumi.Input[
|
|
149
|
+
def notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
151
150
|
"""
|
|
152
151
|
The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
153
152
|
"""
|
|
154
153
|
return pulumi.get(self, "notify_keyspace_events")
|
|
155
154
|
|
|
156
155
|
@notify_keyspace_events.setter
|
|
157
|
-
def notify_keyspace_events(self, value: Optional[pulumi.Input[
|
|
156
|
+
def notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
158
157
|
pulumi.set(self, "notify_keyspace_events", value)
|
|
159
158
|
|
|
160
|
-
@property
|
|
159
|
+
@_builtins.property
|
|
161
160
|
@pulumi.getter(name="numberOfDatabases")
|
|
162
|
-
def number_of_databases(self) -> Optional[pulumi.Input[
|
|
161
|
+
def number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
163
162
|
"""
|
|
164
163
|
The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
165
164
|
"""
|
|
166
165
|
return pulumi.get(self, "number_of_databases")
|
|
167
166
|
|
|
168
167
|
@number_of_databases.setter
|
|
169
|
-
def number_of_databases(self, value: Optional[pulumi.Input[
|
|
168
|
+
def number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
170
169
|
pulumi.set(self, "number_of_databases", value)
|
|
171
170
|
|
|
172
|
-
@property
|
|
171
|
+
@_builtins.property
|
|
173
172
|
@pulumi.getter
|
|
174
|
-
def persistence(self) -> Optional[pulumi.Input[
|
|
173
|
+
def persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
175
174
|
"""
|
|
176
175
|
When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
177
176
|
"""
|
|
178
177
|
return pulumi.get(self, "persistence")
|
|
179
178
|
|
|
180
179
|
@persistence.setter
|
|
181
|
-
def persistence(self, value: Optional[pulumi.Input[
|
|
180
|
+
def persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
182
181
|
pulumi.set(self, "persistence", value)
|
|
183
182
|
|
|
184
|
-
@property
|
|
183
|
+
@_builtins.property
|
|
185
184
|
@pulumi.getter(name="pubsubClientOutputBufferLimit")
|
|
186
|
-
def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[
|
|
185
|
+
def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
187
186
|
"""
|
|
188
187
|
The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
189
188
|
"""
|
|
190
189
|
return pulumi.get(self, "pubsub_client_output_buffer_limit")
|
|
191
190
|
|
|
192
191
|
@pubsub_client_output_buffer_limit.setter
|
|
193
|
-
def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[
|
|
192
|
+
def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
194
193
|
pulumi.set(self, "pubsub_client_output_buffer_limit", value)
|
|
195
194
|
|
|
196
|
-
@property
|
|
195
|
+
@_builtins.property
|
|
197
196
|
@pulumi.getter
|
|
198
|
-
def ssl(self) -> Optional[pulumi.Input[
|
|
197
|
+
def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
199
198
|
"""
|
|
200
199
|
A boolean indicating whether to require SSL to access Redis.
|
|
201
200
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
@@ -204,53 +203,53 @@ class DatabaseRedisConfigArgs:
|
|
|
204
203
|
return pulumi.get(self, "ssl")
|
|
205
204
|
|
|
206
205
|
@ssl.setter
|
|
207
|
-
def ssl(self, value: Optional[pulumi.Input[
|
|
206
|
+
def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
208
207
|
pulumi.set(self, "ssl", value)
|
|
209
208
|
|
|
210
|
-
@property
|
|
209
|
+
@_builtins.property
|
|
211
210
|
@pulumi.getter
|
|
212
|
-
def timeout(self) -> Optional[pulumi.Input[
|
|
211
|
+
def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
213
212
|
"""
|
|
214
213
|
The Redis idle connection timeout in seconds.
|
|
215
214
|
"""
|
|
216
215
|
return pulumi.get(self, "timeout")
|
|
217
216
|
|
|
218
217
|
@timeout.setter
|
|
219
|
-
def timeout(self, value: Optional[pulumi.Input[
|
|
218
|
+
def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
220
219
|
pulumi.set(self, "timeout", value)
|
|
221
220
|
|
|
222
221
|
|
|
223
222
|
@pulumi.input_type
|
|
224
223
|
class _DatabaseRedisConfigState:
|
|
225
224
|
def __init__(__self__, *,
|
|
226
|
-
acl_channels_default: Optional[pulumi.Input[
|
|
227
|
-
cluster_id: Optional[pulumi.Input[
|
|
228
|
-
io_threads: Optional[pulumi.Input[
|
|
229
|
-
lfu_decay_time: Optional[pulumi.Input[
|
|
230
|
-
lfu_log_factor: Optional[pulumi.Input[
|
|
231
|
-
maxmemory_policy: Optional[pulumi.Input[
|
|
232
|
-
notify_keyspace_events: Optional[pulumi.Input[
|
|
233
|
-
number_of_databases: Optional[pulumi.Input[
|
|
234
|
-
persistence: Optional[pulumi.Input[
|
|
235
|
-
pubsub_client_output_buffer_limit: Optional[pulumi.Input[
|
|
236
|
-
ssl: Optional[pulumi.Input[
|
|
237
|
-
timeout: Optional[pulumi.Input[
|
|
225
|
+
acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
|
|
226
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
227
|
+
io_threads: Optional[pulumi.Input[_builtins.int]] = None,
|
|
228
|
+
lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
|
|
229
|
+
lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
|
|
230
|
+
maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
231
|
+
notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
|
|
232
|
+
number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
|
|
233
|
+
persistence: Optional[pulumi.Input[_builtins.str]] = None,
|
|
234
|
+
pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
235
|
+
ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
236
|
+
timeout: Optional[pulumi.Input[_builtins.int]] = None):
|
|
238
237
|
"""
|
|
239
238
|
Input properties used for looking up and filtering DatabaseRedisConfig resources.
|
|
240
|
-
:param pulumi.Input[
|
|
241
|
-
:param pulumi.Input[
|
|
242
|
-
:param pulumi.Input[
|
|
243
|
-
:param pulumi.Input[
|
|
244
|
-
:param pulumi.Input[
|
|
245
|
-
:param pulumi.Input[
|
|
246
|
-
:param pulumi.Input[
|
|
247
|
-
:param pulumi.Input[
|
|
248
|
-
:param pulumi.Input[
|
|
249
|
-
:param pulumi.Input[
|
|
250
|
-
:param pulumi.Input[
|
|
239
|
+
:param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
240
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Redis cluster.
|
|
241
|
+
:param pulumi.Input[_builtins.int] io_threads: The Redis IO thread count.
|
|
242
|
+
:param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
|
|
243
|
+
:param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
244
|
+
:param pulumi.Input[_builtins.str] maxmemory_policy: A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
245
|
+
:param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
246
|
+
:param pulumi.Input[_builtins.int] number_of_databases: The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
247
|
+
:param pulumi.Input[_builtins.str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
248
|
+
:param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
249
|
+
:param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Redis.
|
|
251
250
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
252
251
|
- When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
|
|
253
|
-
:param pulumi.Input[
|
|
252
|
+
:param pulumi.Input[_builtins.int] timeout: The Redis idle connection timeout in seconds.
|
|
254
253
|
"""
|
|
255
254
|
if acl_channels_default is not None:
|
|
256
255
|
pulumi.set(__self__, "acl_channels_default", acl_channels_default)
|
|
@@ -277,129 +276,129 @@ class _DatabaseRedisConfigState:
|
|
|
277
276
|
if timeout is not None:
|
|
278
277
|
pulumi.set(__self__, "timeout", timeout)
|
|
279
278
|
|
|
280
|
-
@property
|
|
279
|
+
@_builtins.property
|
|
281
280
|
@pulumi.getter(name="aclChannelsDefault")
|
|
282
|
-
def acl_channels_default(self) -> Optional[pulumi.Input[
|
|
281
|
+
def acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
283
282
|
"""
|
|
284
283
|
Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
285
284
|
"""
|
|
286
285
|
return pulumi.get(self, "acl_channels_default")
|
|
287
286
|
|
|
288
287
|
@acl_channels_default.setter
|
|
289
|
-
def acl_channels_default(self, value: Optional[pulumi.Input[
|
|
288
|
+
def acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
290
289
|
pulumi.set(self, "acl_channels_default", value)
|
|
291
290
|
|
|
292
|
-
@property
|
|
291
|
+
@_builtins.property
|
|
293
292
|
@pulumi.getter(name="clusterId")
|
|
294
|
-
def cluster_id(self) -> Optional[pulumi.Input[
|
|
293
|
+
def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
295
294
|
"""
|
|
296
295
|
The ID of the target Redis cluster.
|
|
297
296
|
"""
|
|
298
297
|
return pulumi.get(self, "cluster_id")
|
|
299
298
|
|
|
300
299
|
@cluster_id.setter
|
|
301
|
-
def cluster_id(self, value: Optional[pulumi.Input[
|
|
300
|
+
def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
302
301
|
pulumi.set(self, "cluster_id", value)
|
|
303
302
|
|
|
304
|
-
@property
|
|
303
|
+
@_builtins.property
|
|
305
304
|
@pulumi.getter(name="ioThreads")
|
|
306
|
-
def io_threads(self) -> Optional[pulumi.Input[
|
|
305
|
+
def io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
307
306
|
"""
|
|
308
307
|
The Redis IO thread count.
|
|
309
308
|
"""
|
|
310
309
|
return pulumi.get(self, "io_threads")
|
|
311
310
|
|
|
312
311
|
@io_threads.setter
|
|
313
|
-
def io_threads(self, value: Optional[pulumi.Input[
|
|
312
|
+
def io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
314
313
|
pulumi.set(self, "io_threads", value)
|
|
315
314
|
|
|
316
|
-
@property
|
|
315
|
+
@_builtins.property
|
|
317
316
|
@pulumi.getter(name="lfuDecayTime")
|
|
318
|
-
def lfu_decay_time(self) -> Optional[pulumi.Input[
|
|
317
|
+
def lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
319
318
|
"""
|
|
320
319
|
The LFU maxmemory policy counter decay time in minutes.
|
|
321
320
|
"""
|
|
322
321
|
return pulumi.get(self, "lfu_decay_time")
|
|
323
322
|
|
|
324
323
|
@lfu_decay_time.setter
|
|
325
|
-
def lfu_decay_time(self, value: Optional[pulumi.Input[
|
|
324
|
+
def lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
326
325
|
pulumi.set(self, "lfu_decay_time", value)
|
|
327
326
|
|
|
328
|
-
@property
|
|
327
|
+
@_builtins.property
|
|
329
328
|
@pulumi.getter(name="lfuLogFactor")
|
|
330
|
-
def lfu_log_factor(self) -> Optional[pulumi.Input[
|
|
329
|
+
def lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
331
330
|
"""
|
|
332
331
|
The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
333
332
|
"""
|
|
334
333
|
return pulumi.get(self, "lfu_log_factor")
|
|
335
334
|
|
|
336
335
|
@lfu_log_factor.setter
|
|
337
|
-
def lfu_log_factor(self, value: Optional[pulumi.Input[
|
|
336
|
+
def lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
338
337
|
pulumi.set(self, "lfu_log_factor", value)
|
|
339
338
|
|
|
340
|
-
@property
|
|
339
|
+
@_builtins.property
|
|
341
340
|
@pulumi.getter(name="maxmemoryPolicy")
|
|
342
|
-
def maxmemory_policy(self) -> Optional[pulumi.Input[
|
|
341
|
+
def maxmemory_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
343
342
|
"""
|
|
344
343
|
A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
345
344
|
"""
|
|
346
345
|
return pulumi.get(self, "maxmemory_policy")
|
|
347
346
|
|
|
348
347
|
@maxmemory_policy.setter
|
|
349
|
-
def maxmemory_policy(self, value: Optional[pulumi.Input[
|
|
348
|
+
def maxmemory_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
350
349
|
pulumi.set(self, "maxmemory_policy", value)
|
|
351
350
|
|
|
352
|
-
@property
|
|
351
|
+
@_builtins.property
|
|
353
352
|
@pulumi.getter(name="notifyKeyspaceEvents")
|
|
354
|
-
def notify_keyspace_events(self) -> Optional[pulumi.Input[
|
|
353
|
+
def notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
355
354
|
"""
|
|
356
355
|
The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
357
356
|
"""
|
|
358
357
|
return pulumi.get(self, "notify_keyspace_events")
|
|
359
358
|
|
|
360
359
|
@notify_keyspace_events.setter
|
|
361
|
-
def notify_keyspace_events(self, value: Optional[pulumi.Input[
|
|
360
|
+
def notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
362
361
|
pulumi.set(self, "notify_keyspace_events", value)
|
|
363
362
|
|
|
364
|
-
@property
|
|
363
|
+
@_builtins.property
|
|
365
364
|
@pulumi.getter(name="numberOfDatabases")
|
|
366
|
-
def number_of_databases(self) -> Optional[pulumi.Input[
|
|
365
|
+
def number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
367
366
|
"""
|
|
368
367
|
The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
369
368
|
"""
|
|
370
369
|
return pulumi.get(self, "number_of_databases")
|
|
371
370
|
|
|
372
371
|
@number_of_databases.setter
|
|
373
|
-
def number_of_databases(self, value: Optional[pulumi.Input[
|
|
372
|
+
def number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
374
373
|
pulumi.set(self, "number_of_databases", value)
|
|
375
374
|
|
|
376
|
-
@property
|
|
375
|
+
@_builtins.property
|
|
377
376
|
@pulumi.getter
|
|
378
|
-
def persistence(self) -> Optional[pulumi.Input[
|
|
377
|
+
def persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
379
378
|
"""
|
|
380
379
|
When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
381
380
|
"""
|
|
382
381
|
return pulumi.get(self, "persistence")
|
|
383
382
|
|
|
384
383
|
@persistence.setter
|
|
385
|
-
def persistence(self, value: Optional[pulumi.Input[
|
|
384
|
+
def persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
386
385
|
pulumi.set(self, "persistence", value)
|
|
387
386
|
|
|
388
|
-
@property
|
|
387
|
+
@_builtins.property
|
|
389
388
|
@pulumi.getter(name="pubsubClientOutputBufferLimit")
|
|
390
|
-
def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[
|
|
389
|
+
def pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
391
390
|
"""
|
|
392
391
|
The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
393
392
|
"""
|
|
394
393
|
return pulumi.get(self, "pubsub_client_output_buffer_limit")
|
|
395
394
|
|
|
396
395
|
@pubsub_client_output_buffer_limit.setter
|
|
397
|
-
def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[
|
|
396
|
+
def pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
398
397
|
pulumi.set(self, "pubsub_client_output_buffer_limit", value)
|
|
399
398
|
|
|
400
|
-
@property
|
|
399
|
+
@_builtins.property
|
|
401
400
|
@pulumi.getter
|
|
402
|
-
def ssl(self) -> Optional[pulumi.Input[
|
|
401
|
+
def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
403
402
|
"""
|
|
404
403
|
A boolean indicating whether to require SSL to access Redis.
|
|
405
404
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
@@ -408,19 +407,19 @@ class _DatabaseRedisConfigState:
|
|
|
408
407
|
return pulumi.get(self, "ssl")
|
|
409
408
|
|
|
410
409
|
@ssl.setter
|
|
411
|
-
def ssl(self, value: Optional[pulumi.Input[
|
|
410
|
+
def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
412
411
|
pulumi.set(self, "ssl", value)
|
|
413
412
|
|
|
414
|
-
@property
|
|
413
|
+
@_builtins.property
|
|
415
414
|
@pulumi.getter
|
|
416
|
-
def timeout(self) -> Optional[pulumi.Input[
|
|
415
|
+
def timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
417
416
|
"""
|
|
418
417
|
The Redis idle connection timeout in seconds.
|
|
419
418
|
"""
|
|
420
419
|
return pulumi.get(self, "timeout")
|
|
421
420
|
|
|
422
421
|
@timeout.setter
|
|
423
|
-
def timeout(self, value: Optional[pulumi.Input[
|
|
422
|
+
def timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
424
423
|
pulumi.set(self, "timeout", value)
|
|
425
424
|
|
|
426
425
|
|
|
@@ -430,18 +429,18 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
430
429
|
def __init__(__self__,
|
|
431
430
|
resource_name: str,
|
|
432
431
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
433
|
-
acl_channels_default: Optional[pulumi.Input[
|
|
434
|
-
cluster_id: Optional[pulumi.Input[
|
|
435
|
-
io_threads: Optional[pulumi.Input[
|
|
436
|
-
lfu_decay_time: Optional[pulumi.Input[
|
|
437
|
-
lfu_log_factor: Optional[pulumi.Input[
|
|
438
|
-
maxmemory_policy: Optional[pulumi.Input[
|
|
439
|
-
notify_keyspace_events: Optional[pulumi.Input[
|
|
440
|
-
number_of_databases: Optional[pulumi.Input[
|
|
441
|
-
persistence: Optional[pulumi.Input[
|
|
442
|
-
pubsub_client_output_buffer_limit: Optional[pulumi.Input[
|
|
443
|
-
ssl: Optional[pulumi.Input[
|
|
444
|
-
timeout: Optional[pulumi.Input[
|
|
432
|
+
acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
|
|
433
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
434
|
+
io_threads: Optional[pulumi.Input[_builtins.int]] = None,
|
|
435
|
+
lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
|
|
436
|
+
lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
|
|
437
|
+
maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
438
|
+
notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
|
|
439
|
+
number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
|
|
440
|
+
persistence: Optional[pulumi.Input[_builtins.str]] = None,
|
|
441
|
+
pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
442
|
+
ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
443
|
+
timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
445
444
|
__props__=None):
|
|
446
445
|
"""
|
|
447
446
|
Provides a virtual resource that can be used to change advanced configuration
|
|
@@ -479,20 +478,20 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
479
478
|
|
|
480
479
|
:param str resource_name: The name of the resource.
|
|
481
480
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
482
|
-
:param pulumi.Input[
|
|
483
|
-
:param pulumi.Input[
|
|
484
|
-
:param pulumi.Input[
|
|
485
|
-
:param pulumi.Input[
|
|
486
|
-
:param pulumi.Input[
|
|
487
|
-
:param pulumi.Input[
|
|
488
|
-
:param pulumi.Input[
|
|
489
|
-
:param pulumi.Input[
|
|
490
|
-
:param pulumi.Input[
|
|
491
|
-
:param pulumi.Input[
|
|
492
|
-
:param pulumi.Input[
|
|
481
|
+
:param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
482
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Redis cluster.
|
|
483
|
+
:param pulumi.Input[_builtins.int] io_threads: The Redis IO thread count.
|
|
484
|
+
:param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
|
|
485
|
+
:param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
486
|
+
:param pulumi.Input[_builtins.str] maxmemory_policy: A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
487
|
+
:param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
488
|
+
:param pulumi.Input[_builtins.int] number_of_databases: The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
489
|
+
:param pulumi.Input[_builtins.str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
490
|
+
:param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
491
|
+
:param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Redis.
|
|
493
492
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
494
493
|
- When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
|
|
495
|
-
:param pulumi.Input[
|
|
494
|
+
:param pulumi.Input[_builtins.int] timeout: The Redis idle connection timeout in seconds.
|
|
496
495
|
"""
|
|
497
496
|
...
|
|
498
497
|
@overload
|
|
@@ -549,18 +548,18 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
549
548
|
def _internal_init(__self__,
|
|
550
549
|
resource_name: str,
|
|
551
550
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
552
|
-
acl_channels_default: Optional[pulumi.Input[
|
|
553
|
-
cluster_id: Optional[pulumi.Input[
|
|
554
|
-
io_threads: Optional[pulumi.Input[
|
|
555
|
-
lfu_decay_time: Optional[pulumi.Input[
|
|
556
|
-
lfu_log_factor: Optional[pulumi.Input[
|
|
557
|
-
maxmemory_policy: Optional[pulumi.Input[
|
|
558
|
-
notify_keyspace_events: Optional[pulumi.Input[
|
|
559
|
-
number_of_databases: Optional[pulumi.Input[
|
|
560
|
-
persistence: Optional[pulumi.Input[
|
|
561
|
-
pubsub_client_output_buffer_limit: Optional[pulumi.Input[
|
|
562
|
-
ssl: Optional[pulumi.Input[
|
|
563
|
-
timeout: Optional[pulumi.Input[
|
|
551
|
+
acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
|
|
552
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
553
|
+
io_threads: Optional[pulumi.Input[_builtins.int]] = None,
|
|
554
|
+
lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
|
|
555
|
+
lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
|
|
556
|
+
maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
557
|
+
notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
|
|
558
|
+
number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
|
|
559
|
+
persistence: Optional[pulumi.Input[_builtins.str]] = None,
|
|
560
|
+
pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
561
|
+
ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
562
|
+
timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
564
563
|
__props__=None):
|
|
565
564
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
566
565
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -594,18 +593,18 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
594
593
|
def get(resource_name: str,
|
|
595
594
|
id: pulumi.Input[str],
|
|
596
595
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
597
|
-
acl_channels_default: Optional[pulumi.Input[
|
|
598
|
-
cluster_id: Optional[pulumi.Input[
|
|
599
|
-
io_threads: Optional[pulumi.Input[
|
|
600
|
-
lfu_decay_time: Optional[pulumi.Input[
|
|
601
|
-
lfu_log_factor: Optional[pulumi.Input[
|
|
602
|
-
maxmemory_policy: Optional[pulumi.Input[
|
|
603
|
-
notify_keyspace_events: Optional[pulumi.Input[
|
|
604
|
-
number_of_databases: Optional[pulumi.Input[
|
|
605
|
-
persistence: Optional[pulumi.Input[
|
|
606
|
-
pubsub_client_output_buffer_limit: Optional[pulumi.Input[
|
|
607
|
-
ssl: Optional[pulumi.Input[
|
|
608
|
-
timeout: Optional[pulumi.Input[
|
|
596
|
+
acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
|
|
597
|
+
cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
598
|
+
io_threads: Optional[pulumi.Input[_builtins.int]] = None,
|
|
599
|
+
lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
|
|
600
|
+
lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
|
|
601
|
+
maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
602
|
+
notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
|
|
603
|
+
number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
|
|
604
|
+
persistence: Optional[pulumi.Input[_builtins.str]] = None,
|
|
605
|
+
pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
606
|
+
ssl: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
607
|
+
timeout: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabaseRedisConfig':
|
|
609
608
|
"""
|
|
610
609
|
Get an existing DatabaseRedisConfig resource's state with the given name, id, and optional extra
|
|
611
610
|
properties used to qualify the lookup.
|
|
@@ -613,20 +612,20 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
613
612
|
:param str resource_name: The unique name of the resulting resource.
|
|
614
613
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
615
614
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
616
|
-
:param pulumi.Input[
|
|
617
|
-
:param pulumi.Input[
|
|
618
|
-
:param pulumi.Input[
|
|
619
|
-
:param pulumi.Input[
|
|
620
|
-
:param pulumi.Input[
|
|
621
|
-
:param pulumi.Input[
|
|
622
|
-
:param pulumi.Input[
|
|
623
|
-
:param pulumi.Input[
|
|
624
|
-
:param pulumi.Input[
|
|
625
|
-
:param pulumi.Input[
|
|
626
|
-
:param pulumi.Input[
|
|
615
|
+
:param pulumi.Input[_builtins.str] acl_channels_default: Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
616
|
+
:param pulumi.Input[_builtins.str] cluster_id: The ID of the target Redis cluster.
|
|
617
|
+
:param pulumi.Input[_builtins.int] io_threads: The Redis IO thread count.
|
|
618
|
+
:param pulumi.Input[_builtins.int] lfu_decay_time: The LFU maxmemory policy counter decay time in minutes.
|
|
619
|
+
:param pulumi.Input[_builtins.int] lfu_log_factor: The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
620
|
+
:param pulumi.Input[_builtins.str] maxmemory_policy: A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
621
|
+
:param pulumi.Input[_builtins.str] notify_keyspace_events: The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
622
|
+
:param pulumi.Input[_builtins.int] number_of_databases: The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
623
|
+
:param pulumi.Input[_builtins.str] persistence: When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
624
|
+
:param pulumi.Input[_builtins.int] pubsub_client_output_buffer_limit: The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
625
|
+
:param pulumi.Input[_builtins.bool] ssl: A boolean indicating whether to require SSL to access Redis.
|
|
627
626
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
628
627
|
- When disabled, port `25060` is opened for non-SSL connections, while port `25061` remains available for SSL connections.
|
|
629
|
-
:param pulumi.Input[
|
|
628
|
+
:param pulumi.Input[_builtins.int] timeout: The Redis idle connection timeout in seconds.
|
|
630
629
|
"""
|
|
631
630
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
632
631
|
|
|
@@ -646,89 +645,89 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
646
645
|
__props__.__dict__["timeout"] = timeout
|
|
647
646
|
return DatabaseRedisConfig(resource_name, opts=opts, __props__=__props__)
|
|
648
647
|
|
|
649
|
-
@property
|
|
648
|
+
@_builtins.property
|
|
650
649
|
@pulumi.getter(name="aclChannelsDefault")
|
|
651
|
-
def acl_channels_default(self) -> pulumi.Output[
|
|
650
|
+
def acl_channels_default(self) -> pulumi.Output[_builtins.str]:
|
|
652
651
|
"""
|
|
653
652
|
Determines default pub/sub channels' ACL for new users if an ACL is not supplied. When this option is not defined, `allchannels` is assumed to keep backward compatibility. This option doesn't affect Redis' `acl-pubsub-default` configuration. Supported values are: `allchannels` and `resetchannels`
|
|
654
653
|
"""
|
|
655
654
|
return pulumi.get(self, "acl_channels_default")
|
|
656
655
|
|
|
657
|
-
@property
|
|
656
|
+
@_builtins.property
|
|
658
657
|
@pulumi.getter(name="clusterId")
|
|
659
|
-
def cluster_id(self) -> pulumi.Output[
|
|
658
|
+
def cluster_id(self) -> pulumi.Output[_builtins.str]:
|
|
660
659
|
"""
|
|
661
660
|
The ID of the target Redis cluster.
|
|
662
661
|
"""
|
|
663
662
|
return pulumi.get(self, "cluster_id")
|
|
664
663
|
|
|
665
|
-
@property
|
|
664
|
+
@_builtins.property
|
|
666
665
|
@pulumi.getter(name="ioThreads")
|
|
667
|
-
def io_threads(self) -> pulumi.Output[
|
|
666
|
+
def io_threads(self) -> pulumi.Output[_builtins.int]:
|
|
668
667
|
"""
|
|
669
668
|
The Redis IO thread count.
|
|
670
669
|
"""
|
|
671
670
|
return pulumi.get(self, "io_threads")
|
|
672
671
|
|
|
673
|
-
@property
|
|
672
|
+
@_builtins.property
|
|
674
673
|
@pulumi.getter(name="lfuDecayTime")
|
|
675
|
-
def lfu_decay_time(self) -> pulumi.Output[
|
|
674
|
+
def lfu_decay_time(self) -> pulumi.Output[_builtins.int]:
|
|
676
675
|
"""
|
|
677
676
|
The LFU maxmemory policy counter decay time in minutes.
|
|
678
677
|
"""
|
|
679
678
|
return pulumi.get(self, "lfu_decay_time")
|
|
680
679
|
|
|
681
|
-
@property
|
|
680
|
+
@_builtins.property
|
|
682
681
|
@pulumi.getter(name="lfuLogFactor")
|
|
683
|
-
def lfu_log_factor(self) -> pulumi.Output[
|
|
682
|
+
def lfu_log_factor(self) -> pulumi.Output[_builtins.int]:
|
|
684
683
|
"""
|
|
685
684
|
The counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory policies.
|
|
686
685
|
"""
|
|
687
686
|
return pulumi.get(self, "lfu_log_factor")
|
|
688
687
|
|
|
689
|
-
@property
|
|
688
|
+
@_builtins.property
|
|
690
689
|
@pulumi.getter(name="maxmemoryPolicy")
|
|
691
|
-
def maxmemory_policy(self) -> pulumi.Output[
|
|
690
|
+
def maxmemory_policy(self) -> pulumi.Output[_builtins.str]:
|
|
692
691
|
"""
|
|
693
692
|
A string specifying the desired eviction policy for the Redis cluster.Supported values are: `noeviction`, `allkeys-lru`, `allkeys-random`, `volatile-lru`, `volatile-random`, `volatile-ttl`
|
|
694
693
|
"""
|
|
695
694
|
return pulumi.get(self, "maxmemory_policy")
|
|
696
695
|
|
|
697
|
-
@property
|
|
696
|
+
@_builtins.property
|
|
698
697
|
@pulumi.getter(name="notifyKeyspaceEvents")
|
|
699
|
-
def notify_keyspace_events(self) -> pulumi.Output[
|
|
698
|
+
def notify_keyspace_events(self) -> pulumi.Output[_builtins.str]:
|
|
700
699
|
"""
|
|
701
700
|
The `notify-keyspace-events` option. Requires at least `K` or `E`.
|
|
702
701
|
"""
|
|
703
702
|
return pulumi.get(self, "notify_keyspace_events")
|
|
704
703
|
|
|
705
|
-
@property
|
|
704
|
+
@_builtins.property
|
|
706
705
|
@pulumi.getter(name="numberOfDatabases")
|
|
707
|
-
def number_of_databases(self) -> pulumi.Output[
|
|
706
|
+
def number_of_databases(self) -> pulumi.Output[_builtins.int]:
|
|
708
707
|
"""
|
|
709
708
|
The number of Redis databases. Changing this will cause a restart of Redis service.
|
|
710
709
|
"""
|
|
711
710
|
return pulumi.get(self, "number_of_databases")
|
|
712
711
|
|
|
713
|
-
@property
|
|
712
|
+
@_builtins.property
|
|
714
713
|
@pulumi.getter
|
|
715
|
-
def persistence(self) -> pulumi.Output[
|
|
714
|
+
def persistence(self) -> pulumi.Output[_builtins.str]:
|
|
716
715
|
"""
|
|
717
716
|
When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
|
|
718
717
|
"""
|
|
719
718
|
return pulumi.get(self, "persistence")
|
|
720
719
|
|
|
721
|
-
@property
|
|
720
|
+
@_builtins.property
|
|
722
721
|
@pulumi.getter(name="pubsubClientOutputBufferLimit")
|
|
723
|
-
def pubsub_client_output_buffer_limit(self) -> pulumi.Output[
|
|
722
|
+
def pubsub_client_output_buffer_limit(self) -> pulumi.Output[_builtins.int]:
|
|
724
723
|
"""
|
|
725
724
|
The output buffer limit for pub/sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
|
|
726
725
|
"""
|
|
727
726
|
return pulumi.get(self, "pubsub_client_output_buffer_limit")
|
|
728
727
|
|
|
729
|
-
@property
|
|
728
|
+
@_builtins.property
|
|
730
729
|
@pulumi.getter
|
|
731
|
-
def ssl(self) -> pulumi.Output[
|
|
730
|
+
def ssl(self) -> pulumi.Output[_builtins.bool]:
|
|
732
731
|
"""
|
|
733
732
|
A boolean indicating whether to require SSL to access Redis.
|
|
734
733
|
- When enabled, Redis accepts only SSL connections on port `25061`.
|
|
@@ -736,9 +735,9 @@ class DatabaseRedisConfig(pulumi.CustomResource):
|
|
|
736
735
|
"""
|
|
737
736
|
return pulumi.get(self, "ssl")
|
|
738
737
|
|
|
739
|
-
@property
|
|
738
|
+
@_builtins.property
|
|
740
739
|
@pulumi.getter
|
|
741
|
-
def timeout(self) -> pulumi.Output[
|
|
740
|
+
def timeout(self) -> pulumi.Output[_builtins.int]:
|
|
742
741
|
"""
|
|
743
742
|
The Redis idle connection timeout in seconds.
|
|
744
743
|
"""
|