pulumi-linode 5.1.0a1752810302__py3-none-any.whl → 5.1.1__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-linode might be problematic. Click here for more details.
- pulumi_linode/__init__.py +1 -1
- pulumi_linode/_inputs.py +5169 -5170
- pulumi_linode/account_settings.py +70 -71
- pulumi_linode/config/__init__.py +1 -1
- pulumi_linode/config/__init__.pyi +1 -2
- pulumi_linode/config/vars.py +21 -22
- pulumi_linode/database_access_controls.py +52 -53
- pulumi_linode/database_mysql.py +247 -248
- pulumi_linode/database_mysql_v2.py +782 -783
- pulumi_linode/database_postgresql.py +273 -274
- pulumi_linode/database_postgresql_v2.py +1105 -1106
- pulumi_linode/domain.py +222 -223
- pulumi_linode/domain_record.py +188 -189
- pulumi_linode/firewall.py +155 -156
- pulumi_linode/firewall_device.py +70 -71
- pulumi_linode/get_account.py +33 -34
- pulumi_linode/get_account_availabilities.py +5 -6
- pulumi_linode/get_account_availability.py +13 -14
- pulumi_linode/get_account_login.py +17 -18
- pulumi_linode/get_account_logins.py +5 -6
- pulumi_linode/get_account_settings.py +13 -14
- pulumi_linode/get_child_account.py +37 -38
- pulumi_linode/get_child_accounts.py +5 -6
- pulumi_linode/get_database_backups.py +35 -36
- pulumi_linode/get_database_engines.py +23 -24
- pulumi_linode/get_database_mysql.py +52 -53
- pulumi_linode/get_database_mysql_backups.py +29 -30
- pulumi_linode/get_database_mysql_config.py +5 -6
- pulumi_linode/get_database_mysql_v2.py +115 -116
- pulumi_linode/get_database_postgresql.py +56 -57
- pulumi_linode/get_database_postgresql_config.py +7 -8
- pulumi_linode/get_database_postgresql_v2.py +153 -154
- pulumi_linode/get_databases.py +17 -18
- pulumi_linode/get_domain.py +37 -38
- pulumi_linode/get_domain_record.py +37 -38
- pulumi_linode/get_domain_zonefile.py +11 -12
- pulumi_linode/get_domains.py +17 -18
- pulumi_linode/get_firewall.py +30 -31
- pulumi_linode/get_firewalls.py +17 -18
- pulumi_linode/get_image.py +36 -37
- pulumi_linode/get_images.py +23 -24
- pulumi_linode/get_instance_backups.py +12 -13
- pulumi_linode/get_instance_networking.py +11 -12
- pulumi_linode/get_instance_type.py +30 -31
- pulumi_linode/get_instance_types.py +17 -18
- pulumi_linode/get_instances.py +17 -18
- pulumi_linode/get_ipv6_range.py +17 -18
- pulumi_linode/get_ipv6_ranges.py +5 -6
- pulumi_linode/get_kernel.py +23 -24
- pulumi_linode/get_kernels.py +17 -18
- pulumi_linode/get_linode_object_storage_bucket.py +33 -34
- pulumi_linode/get_lke_cluster.py +33 -34
- pulumi_linode/get_lke_clusters.py +17 -18
- pulumi_linode/get_lke_types.py +17 -18
- pulumi_linode/get_lke_version.py +13 -14
- pulumi_linode/get_lke_versions.py +10 -11
- pulumi_linode/get_nb_types.py +13 -14
- pulumi_linode/get_network_transfer_prices.py +17 -18
- pulumi_linode/get_networking_ip.py +28 -29
- pulumi_linode/get_networking_ips.py +17 -18
- pulumi_linode/get_node_balancer.py +29 -30
- pulumi_linode/get_node_balancer_config.py +48 -49
- pulumi_linode/get_node_balancer_node.py +29 -30
- pulumi_linode/get_nodebalancer_configs.py +23 -24
- pulumi_linode/get_nodebalancers.py +17 -18
- pulumi_linode/get_object_storage_cluster.py +15 -16
- pulumi_linode/get_object_storage_endpoints.py +17 -18
- pulumi_linode/get_object_storage_quota.py +22 -23
- pulumi_linode/get_object_storage_quotas.py +5 -6
- pulumi_linode/get_placement_group.py +19 -20
- pulumi_linode/get_placement_groups.py +13 -14
- pulumi_linode/get_profile.py +22 -23
- pulumi_linode/get_region.py +19 -20
- pulumi_linode/get_regions.py +5 -6
- pulumi_linode/get_ssh_key.py +17 -18
- pulumi_linode/get_sshkeys.py +17 -18
- pulumi_linode/get_stack_script.py +32 -33
- pulumi_linode/get_stack_scripts.py +23 -24
- pulumi_linode/get_user.py +35 -36
- pulumi_linode/get_users.py +17 -18
- pulumi_linode/get_vlans.py +17 -18
- pulumi_linode/get_volume.py +27 -28
- pulumi_linode/get_volume_types.py +17 -18
- pulumi_linode/get_volumes.py +17 -18
- pulumi_linode/get_vpc.py +17 -18
- pulumi_linode/get_vpc_ips.py +11 -12
- pulumi_linode/get_vpc_subnet.py +22 -23
- pulumi_linode/get_vpc_subnets.py +11 -12
- pulumi_linode/get_vpcs.py +5 -6
- pulumi_linode/image.py +292 -293
- pulumi_linode/instance.py +520 -521
- pulumi_linode/instance_config.py +166 -167
- pulumi_linode/instance_disk.py +210 -211
- pulumi_linode/instance_ip.py +125 -126
- pulumi_linode/instance_shared_ips.py +35 -36
- pulumi_linode/ipv6_range.py +88 -89
- pulumi_linode/lke_cluster.py +162 -163
- pulumi_linode/lke_node_pool.py +137 -138
- pulumi_linode/networking_ip.py +133 -134
- pulumi_linode/networking_ip_assignment.py +21 -22
- pulumi_linode/node_balancer.py +152 -153
- pulumi_linode/node_balancer_config.py +319 -320
- pulumi_linode/node_balancer_node.py +112 -113
- pulumi_linode/object_storage_bucket.py +195 -196
- pulumi_linode/object_storage_key.py +67 -68
- pulumi_linode/object_storage_object.py +350 -351
- pulumi_linode/outputs.py +5305 -5306
- pulumi_linode/placement_group.py +80 -81
- pulumi_linode/placement_group_assignment.py +48 -49
- pulumi_linode/provider.py +180 -181
- pulumi_linode/pulumi-plugin.json +1 -1
- pulumi_linode/rdns.py +55 -56
- pulumi_linode/reserved_ip_assignment.py +142 -143
- pulumi_linode/ssh_key.py +44 -45
- pulumi_linode/stack_script.py +159 -160
- pulumi_linode/token.py +70 -71
- pulumi_linode/user.py +112 -113
- pulumi_linode/volume.py +141 -142
- pulumi_linode/vpc.py +70 -71
- pulumi_linode/vpc_subnet.py +72 -73
- {pulumi_linode-5.1.0a1752810302.dist-info → pulumi_linode-5.1.1.dist-info}/METADATA +1 -1
- pulumi_linode-5.1.1.dist-info/RECORD +126 -0
- pulumi_linode-5.1.0a1752810302.dist-info/RECORD +0 -126
- {pulumi_linode-5.1.0a1752810302.dist-info → pulumi_linode-5.1.1.dist-info}/WHEEL +0 -0
- {pulumi_linode-5.1.0a1752810302.dist-info → pulumi_linode-5.1.1.dist-info}/top_level.txt +0 -0
pulumi_linode/database_mysql.py
CHANGED
|
@@ -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
|
|
@@ -22,33 +21,33 @@ __all__ = ['DatabaseMysqlArgs', 'DatabaseMysql']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class DatabaseMysqlArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
engine_id: pulumi.Input[
|
|
26
|
-
label: pulumi.Input[
|
|
27
|
-
region: pulumi.Input[
|
|
28
|
-
type: pulumi.Input[
|
|
29
|
-
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
30
|
-
cluster_size: Optional[pulumi.Input[
|
|
31
|
-
encrypted: Optional[pulumi.Input[
|
|
32
|
-
replication_type: Optional[pulumi.Input[
|
|
33
|
-
ssl_connection: Optional[pulumi.Input[
|
|
24
|
+
engine_id: pulumi.Input[_builtins.str],
|
|
25
|
+
label: pulumi.Input[_builtins.str],
|
|
26
|
+
region: pulumi.Input[_builtins.str],
|
|
27
|
+
type: pulumi.Input[_builtins.str],
|
|
28
|
+
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
replication_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
33
|
updates: Optional[pulumi.Input['DatabaseMysqlUpdatesArgs']] = None):
|
|
35
34
|
"""
|
|
36
35
|
The set of arguments for constructing a DatabaseMysql resource.
|
|
37
|
-
:param pulumi.Input[
|
|
38
|
-
:param pulumi.Input[
|
|
39
|
-
:param pulumi.Input[
|
|
40
|
-
:param pulumi.Input[
|
|
36
|
+
:param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
37
|
+
:param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
|
|
38
|
+
:param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
|
|
39
|
+
:param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
|
|
41
40
|
|
|
42
41
|
- - -
|
|
43
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
44
|
-
:param pulumi.Input[
|
|
45
|
-
:param pulumi.Input[
|
|
46
|
-
:param pulumi.Input[
|
|
42
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
43
|
+
:param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
44
|
+
:param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
|
|
45
|
+
:param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
47
46
|
|
|
48
47
|
* Must be `none` for a single node cluster.
|
|
49
48
|
|
|
50
49
|
* Must be `asynch` or `semi_synch` for a high availability cluster.
|
|
51
|
-
:param pulumi.Input[
|
|
50
|
+
:param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
52
51
|
|
|
53
52
|
* `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
|
|
54
53
|
:param pulumi.Input['DatabaseMysqlUpdatesArgs'] updates: Configuration settings for automated patch update maintenance for the Managed Database.
|
|
@@ -70,45 +69,45 @@ class DatabaseMysqlArgs:
|
|
|
70
69
|
if updates is not None:
|
|
71
70
|
pulumi.set(__self__, "updates", updates)
|
|
72
71
|
|
|
73
|
-
@property
|
|
72
|
+
@_builtins.property
|
|
74
73
|
@pulumi.getter(name="engineId")
|
|
75
|
-
def engine_id(self) -> pulumi.Input[
|
|
74
|
+
def engine_id(self) -> pulumi.Input[_builtins.str]:
|
|
76
75
|
"""
|
|
77
76
|
The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
78
77
|
"""
|
|
79
78
|
return pulumi.get(self, "engine_id")
|
|
80
79
|
|
|
81
80
|
@engine_id.setter
|
|
82
|
-
def engine_id(self, value: pulumi.Input[
|
|
81
|
+
def engine_id(self, value: pulumi.Input[_builtins.str]):
|
|
83
82
|
pulumi.set(self, "engine_id", value)
|
|
84
83
|
|
|
85
|
-
@property
|
|
84
|
+
@_builtins.property
|
|
86
85
|
@pulumi.getter
|
|
87
|
-
def label(self) -> pulumi.Input[
|
|
86
|
+
def label(self) -> pulumi.Input[_builtins.str]:
|
|
88
87
|
"""
|
|
89
88
|
A unique, user-defined string referring to the Managed Database.
|
|
90
89
|
"""
|
|
91
90
|
return pulumi.get(self, "label")
|
|
92
91
|
|
|
93
92
|
@label.setter
|
|
94
|
-
def label(self, value: pulumi.Input[
|
|
93
|
+
def label(self, value: pulumi.Input[_builtins.str]):
|
|
95
94
|
pulumi.set(self, "label", value)
|
|
96
95
|
|
|
97
|
-
@property
|
|
96
|
+
@_builtins.property
|
|
98
97
|
@pulumi.getter
|
|
99
|
-
def region(self) -> pulumi.Input[
|
|
98
|
+
def region(self) -> pulumi.Input[_builtins.str]:
|
|
100
99
|
"""
|
|
101
100
|
The region to use for the Managed Database.
|
|
102
101
|
"""
|
|
103
102
|
return pulumi.get(self, "region")
|
|
104
103
|
|
|
105
104
|
@region.setter
|
|
106
|
-
def region(self, value: pulumi.Input[
|
|
105
|
+
def region(self, value: pulumi.Input[_builtins.str]):
|
|
107
106
|
pulumi.set(self, "region", value)
|
|
108
107
|
|
|
109
|
-
@property
|
|
108
|
+
@_builtins.property
|
|
110
109
|
@pulumi.getter
|
|
111
|
-
def type(self) -> pulumi.Input[
|
|
110
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
112
111
|
"""
|
|
113
112
|
The Linode Instance type used for the nodes of the Managed Database instance.
|
|
114
113
|
|
|
@@ -117,48 +116,48 @@ class DatabaseMysqlArgs:
|
|
|
117
116
|
return pulumi.get(self, "type")
|
|
118
117
|
|
|
119
118
|
@type.setter
|
|
120
|
-
def type(self, value: pulumi.Input[
|
|
119
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
121
120
|
pulumi.set(self, "type", value)
|
|
122
121
|
|
|
123
|
-
@property
|
|
122
|
+
@_builtins.property
|
|
124
123
|
@pulumi.getter(name="allowLists")
|
|
125
|
-
def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
124
|
+
def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
126
125
|
"""
|
|
127
126
|
A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
128
127
|
"""
|
|
129
128
|
return pulumi.get(self, "allow_lists")
|
|
130
129
|
|
|
131
130
|
@allow_lists.setter
|
|
132
|
-
def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
131
|
+
def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
133
132
|
pulumi.set(self, "allow_lists", value)
|
|
134
133
|
|
|
135
|
-
@property
|
|
134
|
+
@_builtins.property
|
|
136
135
|
@pulumi.getter(name="clusterSize")
|
|
137
|
-
def cluster_size(self) -> Optional[pulumi.Input[
|
|
136
|
+
def cluster_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
138
137
|
"""
|
|
139
138
|
The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
140
139
|
"""
|
|
141
140
|
return pulumi.get(self, "cluster_size")
|
|
142
141
|
|
|
143
142
|
@cluster_size.setter
|
|
144
|
-
def cluster_size(self, value: Optional[pulumi.Input[
|
|
143
|
+
def cluster_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
145
144
|
pulumi.set(self, "cluster_size", value)
|
|
146
145
|
|
|
147
|
-
@property
|
|
146
|
+
@_builtins.property
|
|
148
147
|
@pulumi.getter
|
|
149
|
-
def encrypted(self) -> Optional[pulumi.Input[
|
|
148
|
+
def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
150
149
|
"""
|
|
151
150
|
Whether the Managed Databases is encrypted. (default `false`)
|
|
152
151
|
"""
|
|
153
152
|
return pulumi.get(self, "encrypted")
|
|
154
153
|
|
|
155
154
|
@encrypted.setter
|
|
156
|
-
def encrypted(self, value: Optional[pulumi.Input[
|
|
155
|
+
def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
157
156
|
pulumi.set(self, "encrypted", value)
|
|
158
157
|
|
|
159
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
160
159
|
@pulumi.getter(name="replicationType")
|
|
161
|
-
def replication_type(self) -> Optional[pulumi.Input[
|
|
160
|
+
def replication_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
162
161
|
"""
|
|
163
162
|
The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
164
163
|
|
|
@@ -169,12 +168,12 @@ class DatabaseMysqlArgs:
|
|
|
169
168
|
return pulumi.get(self, "replication_type")
|
|
170
169
|
|
|
171
170
|
@replication_type.setter
|
|
172
|
-
def replication_type(self, value: Optional[pulumi.Input[
|
|
171
|
+
def replication_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
173
172
|
pulumi.set(self, "replication_type", value)
|
|
174
173
|
|
|
175
|
-
@property
|
|
174
|
+
@_builtins.property
|
|
176
175
|
@pulumi.getter(name="sslConnection")
|
|
177
|
-
def ssl_connection(self) -> Optional[pulumi.Input[
|
|
176
|
+
def ssl_connection(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
178
177
|
"""
|
|
179
178
|
Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
180
179
|
|
|
@@ -183,10 +182,10 @@ class DatabaseMysqlArgs:
|
|
|
183
182
|
return pulumi.get(self, "ssl_connection")
|
|
184
183
|
|
|
185
184
|
@ssl_connection.setter
|
|
186
|
-
def ssl_connection(self, value: Optional[pulumi.Input[
|
|
185
|
+
def ssl_connection(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
187
186
|
pulumi.set(self, "ssl_connection", value)
|
|
188
187
|
|
|
189
|
-
@property
|
|
188
|
+
@_builtins.property
|
|
190
189
|
@pulumi.getter
|
|
191
190
|
def updates(self) -> Optional[pulumi.Input['DatabaseMysqlUpdatesArgs']]:
|
|
192
191
|
"""
|
|
@@ -202,56 +201,56 @@ class DatabaseMysqlArgs:
|
|
|
202
201
|
@pulumi.input_type
|
|
203
202
|
class _DatabaseMysqlState:
|
|
204
203
|
def __init__(__self__, *,
|
|
205
|
-
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
206
|
-
ca_cert: Optional[pulumi.Input[
|
|
207
|
-
cluster_size: Optional[pulumi.Input[
|
|
208
|
-
created: Optional[pulumi.Input[
|
|
209
|
-
encrypted: Optional[pulumi.Input[
|
|
210
|
-
engine: Optional[pulumi.Input[
|
|
211
|
-
engine_id: Optional[pulumi.Input[
|
|
212
|
-
host_primary: Optional[pulumi.Input[
|
|
213
|
-
host_secondary: Optional[pulumi.Input[
|
|
214
|
-
label: Optional[pulumi.Input[
|
|
215
|
-
region: Optional[pulumi.Input[
|
|
216
|
-
replication_type: Optional[pulumi.Input[
|
|
217
|
-
root_password: Optional[pulumi.Input[
|
|
218
|
-
root_username: Optional[pulumi.Input[
|
|
219
|
-
ssl_connection: Optional[pulumi.Input[
|
|
220
|
-
status: Optional[pulumi.Input[
|
|
221
|
-
type: Optional[pulumi.Input[
|
|
222
|
-
updated: Optional[pulumi.Input[
|
|
204
|
+
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
205
|
+
ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
206
|
+
cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
207
|
+
created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
208
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
209
|
+
engine: Optional[pulumi.Input[_builtins.str]] = None,
|
|
210
|
+
engine_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
211
|
+
host_primary: Optional[pulumi.Input[_builtins.str]] = None,
|
|
212
|
+
host_secondary: Optional[pulumi.Input[_builtins.str]] = None,
|
|
213
|
+
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
214
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
215
|
+
replication_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
216
|
+
root_password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
217
|
+
root_username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
218
|
+
ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
219
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
220
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
221
|
+
updated: Optional[pulumi.Input[_builtins.str]] = None,
|
|
223
222
|
updates: Optional[pulumi.Input['DatabaseMysqlUpdatesArgs']] = None,
|
|
224
|
-
version: Optional[pulumi.Input[
|
|
223
|
+
version: Optional[pulumi.Input[_builtins.str]] = None):
|
|
225
224
|
"""
|
|
226
225
|
Input properties used for looking up and filtering DatabaseMysql resources.
|
|
227
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
228
|
-
:param pulumi.Input[
|
|
229
|
-
:param pulumi.Input[
|
|
230
|
-
:param pulumi.Input[
|
|
231
|
-
:param pulumi.Input[
|
|
232
|
-
:param pulumi.Input[
|
|
233
|
-
:param pulumi.Input[
|
|
234
|
-
:param pulumi.Input[
|
|
235
|
-
:param pulumi.Input[
|
|
236
|
-
:param pulumi.Input[
|
|
237
|
-
:param pulumi.Input[
|
|
238
|
-
:param pulumi.Input[
|
|
226
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
227
|
+
:param pulumi.Input[_builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
|
|
228
|
+
:param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
229
|
+
:param pulumi.Input[_builtins.str] created: When this Managed Database was created.
|
|
230
|
+
:param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
|
|
231
|
+
:param pulumi.Input[_builtins.str] engine: The Managed Database engine. (e.g. `mysql`)
|
|
232
|
+
:param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
233
|
+
:param pulumi.Input[_builtins.str] host_primary: The primary host for the Managed Database.
|
|
234
|
+
:param pulumi.Input[_builtins.str] host_secondary: The secondary/private network host for the Managed Database.
|
|
235
|
+
:param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
|
|
236
|
+
:param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
|
|
237
|
+
:param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
239
238
|
|
|
240
239
|
* Must be `none` for a single node cluster.
|
|
241
240
|
|
|
242
241
|
* Must be `asynch` or `semi_synch` for a high availability cluster.
|
|
243
|
-
:param pulumi.Input[
|
|
244
|
-
:param pulumi.Input[
|
|
245
|
-
:param pulumi.Input[
|
|
242
|
+
:param pulumi.Input[_builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
|
|
243
|
+
:param pulumi.Input[_builtins.str] root_username: The root username for the Managed Database instance.
|
|
244
|
+
:param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
246
245
|
|
|
247
246
|
* `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
|
|
248
|
-
:param pulumi.Input[
|
|
249
|
-
:param pulumi.Input[
|
|
247
|
+
:param pulumi.Input[_builtins.str] status: The operating status of the Managed Database.
|
|
248
|
+
:param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
|
|
250
249
|
|
|
251
250
|
- - -
|
|
252
|
-
:param pulumi.Input[
|
|
251
|
+
:param pulumi.Input[_builtins.str] updated: When this Managed Database was last updated.
|
|
253
252
|
:param pulumi.Input['DatabaseMysqlUpdatesArgs'] updates: Configuration settings for automated patch update maintenance for the Managed Database.
|
|
254
|
-
:param pulumi.Input[
|
|
253
|
+
:param pulumi.Input[_builtins.str] version: The Managed Database engine version. (e.g. `v8.0.26`)
|
|
255
254
|
"""
|
|
256
255
|
if allow_lists is not None:
|
|
257
256
|
pulumi.set(__self__, "allow_lists", allow_lists)
|
|
@@ -294,141 +293,141 @@ class _DatabaseMysqlState:
|
|
|
294
293
|
if version is not None:
|
|
295
294
|
pulumi.set(__self__, "version", version)
|
|
296
295
|
|
|
297
|
-
@property
|
|
296
|
+
@_builtins.property
|
|
298
297
|
@pulumi.getter(name="allowLists")
|
|
299
|
-
def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
298
|
+
def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
300
299
|
"""
|
|
301
300
|
A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
302
301
|
"""
|
|
303
302
|
return pulumi.get(self, "allow_lists")
|
|
304
303
|
|
|
305
304
|
@allow_lists.setter
|
|
306
|
-
def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
305
|
+
def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
307
306
|
pulumi.set(self, "allow_lists", value)
|
|
308
307
|
|
|
309
|
-
@property
|
|
308
|
+
@_builtins.property
|
|
310
309
|
@pulumi.getter(name="caCert")
|
|
311
|
-
def ca_cert(self) -> Optional[pulumi.Input[
|
|
310
|
+
def ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
312
311
|
"""
|
|
313
312
|
The base64-encoded SSL CA certificate for the Managed Database instance.
|
|
314
313
|
"""
|
|
315
314
|
return pulumi.get(self, "ca_cert")
|
|
316
315
|
|
|
317
316
|
@ca_cert.setter
|
|
318
|
-
def ca_cert(self, value: Optional[pulumi.Input[
|
|
317
|
+
def ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
319
318
|
pulumi.set(self, "ca_cert", value)
|
|
320
319
|
|
|
321
|
-
@property
|
|
320
|
+
@_builtins.property
|
|
322
321
|
@pulumi.getter(name="clusterSize")
|
|
323
|
-
def cluster_size(self) -> Optional[pulumi.Input[
|
|
322
|
+
def cluster_size(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
324
323
|
"""
|
|
325
324
|
The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
326
325
|
"""
|
|
327
326
|
return pulumi.get(self, "cluster_size")
|
|
328
327
|
|
|
329
328
|
@cluster_size.setter
|
|
330
|
-
def cluster_size(self, value: Optional[pulumi.Input[
|
|
329
|
+
def cluster_size(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
331
330
|
pulumi.set(self, "cluster_size", value)
|
|
332
331
|
|
|
333
|
-
@property
|
|
332
|
+
@_builtins.property
|
|
334
333
|
@pulumi.getter
|
|
335
|
-
def created(self) -> Optional[pulumi.Input[
|
|
334
|
+
def created(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
336
335
|
"""
|
|
337
336
|
When this Managed Database was created.
|
|
338
337
|
"""
|
|
339
338
|
return pulumi.get(self, "created")
|
|
340
339
|
|
|
341
340
|
@created.setter
|
|
342
|
-
def created(self, value: Optional[pulumi.Input[
|
|
341
|
+
def created(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
343
342
|
pulumi.set(self, "created", value)
|
|
344
343
|
|
|
345
|
-
@property
|
|
344
|
+
@_builtins.property
|
|
346
345
|
@pulumi.getter
|
|
347
|
-
def encrypted(self) -> Optional[pulumi.Input[
|
|
346
|
+
def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
348
347
|
"""
|
|
349
348
|
Whether the Managed Databases is encrypted. (default `false`)
|
|
350
349
|
"""
|
|
351
350
|
return pulumi.get(self, "encrypted")
|
|
352
351
|
|
|
353
352
|
@encrypted.setter
|
|
354
|
-
def encrypted(self, value: Optional[pulumi.Input[
|
|
353
|
+
def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
355
354
|
pulumi.set(self, "encrypted", value)
|
|
356
355
|
|
|
357
|
-
@property
|
|
356
|
+
@_builtins.property
|
|
358
357
|
@pulumi.getter
|
|
359
|
-
def engine(self) -> Optional[pulumi.Input[
|
|
358
|
+
def engine(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
360
359
|
"""
|
|
361
360
|
The Managed Database engine. (e.g. `mysql`)
|
|
362
361
|
"""
|
|
363
362
|
return pulumi.get(self, "engine")
|
|
364
363
|
|
|
365
364
|
@engine.setter
|
|
366
|
-
def engine(self, value: Optional[pulumi.Input[
|
|
365
|
+
def engine(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
367
366
|
pulumi.set(self, "engine", value)
|
|
368
367
|
|
|
369
|
-
@property
|
|
368
|
+
@_builtins.property
|
|
370
369
|
@pulumi.getter(name="engineId")
|
|
371
|
-
def engine_id(self) -> Optional[pulumi.Input[
|
|
370
|
+
def engine_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
372
371
|
"""
|
|
373
372
|
The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
374
373
|
"""
|
|
375
374
|
return pulumi.get(self, "engine_id")
|
|
376
375
|
|
|
377
376
|
@engine_id.setter
|
|
378
|
-
def engine_id(self, value: Optional[pulumi.Input[
|
|
377
|
+
def engine_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
379
378
|
pulumi.set(self, "engine_id", value)
|
|
380
379
|
|
|
381
|
-
@property
|
|
380
|
+
@_builtins.property
|
|
382
381
|
@pulumi.getter(name="hostPrimary")
|
|
383
|
-
def host_primary(self) -> Optional[pulumi.Input[
|
|
382
|
+
def host_primary(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
384
383
|
"""
|
|
385
384
|
The primary host for the Managed Database.
|
|
386
385
|
"""
|
|
387
386
|
return pulumi.get(self, "host_primary")
|
|
388
387
|
|
|
389
388
|
@host_primary.setter
|
|
390
|
-
def host_primary(self, value: Optional[pulumi.Input[
|
|
389
|
+
def host_primary(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
391
390
|
pulumi.set(self, "host_primary", value)
|
|
392
391
|
|
|
393
|
-
@property
|
|
392
|
+
@_builtins.property
|
|
394
393
|
@pulumi.getter(name="hostSecondary")
|
|
395
|
-
def host_secondary(self) -> Optional[pulumi.Input[
|
|
394
|
+
def host_secondary(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
396
395
|
"""
|
|
397
396
|
The secondary/private network host for the Managed Database.
|
|
398
397
|
"""
|
|
399
398
|
return pulumi.get(self, "host_secondary")
|
|
400
399
|
|
|
401
400
|
@host_secondary.setter
|
|
402
|
-
def host_secondary(self, value: Optional[pulumi.Input[
|
|
401
|
+
def host_secondary(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
403
402
|
pulumi.set(self, "host_secondary", value)
|
|
404
403
|
|
|
405
|
-
@property
|
|
404
|
+
@_builtins.property
|
|
406
405
|
@pulumi.getter
|
|
407
|
-
def label(self) -> Optional[pulumi.Input[
|
|
406
|
+
def label(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
408
407
|
"""
|
|
409
408
|
A unique, user-defined string referring to the Managed Database.
|
|
410
409
|
"""
|
|
411
410
|
return pulumi.get(self, "label")
|
|
412
411
|
|
|
413
412
|
@label.setter
|
|
414
|
-
def label(self, value: Optional[pulumi.Input[
|
|
413
|
+
def label(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
415
414
|
pulumi.set(self, "label", value)
|
|
416
415
|
|
|
417
|
-
@property
|
|
416
|
+
@_builtins.property
|
|
418
417
|
@pulumi.getter
|
|
419
|
-
def region(self) -> Optional[pulumi.Input[
|
|
418
|
+
def region(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
420
419
|
"""
|
|
421
420
|
The region to use for the Managed Database.
|
|
422
421
|
"""
|
|
423
422
|
return pulumi.get(self, "region")
|
|
424
423
|
|
|
425
424
|
@region.setter
|
|
426
|
-
def region(self, value: Optional[pulumi.Input[
|
|
425
|
+
def region(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
427
426
|
pulumi.set(self, "region", value)
|
|
428
427
|
|
|
429
|
-
@property
|
|
428
|
+
@_builtins.property
|
|
430
429
|
@pulumi.getter(name="replicationType")
|
|
431
|
-
def replication_type(self) -> Optional[pulumi.Input[
|
|
430
|
+
def replication_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
432
431
|
"""
|
|
433
432
|
The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
434
433
|
|
|
@@ -439,36 +438,36 @@ class _DatabaseMysqlState:
|
|
|
439
438
|
return pulumi.get(self, "replication_type")
|
|
440
439
|
|
|
441
440
|
@replication_type.setter
|
|
442
|
-
def replication_type(self, value: Optional[pulumi.Input[
|
|
441
|
+
def replication_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
443
442
|
pulumi.set(self, "replication_type", value)
|
|
444
443
|
|
|
445
|
-
@property
|
|
444
|
+
@_builtins.property
|
|
446
445
|
@pulumi.getter(name="rootPassword")
|
|
447
|
-
def root_password(self) -> Optional[pulumi.Input[
|
|
446
|
+
def root_password(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
448
447
|
"""
|
|
449
448
|
The randomly-generated root password for the Managed Database instance.
|
|
450
449
|
"""
|
|
451
450
|
return pulumi.get(self, "root_password")
|
|
452
451
|
|
|
453
452
|
@root_password.setter
|
|
454
|
-
def root_password(self, value: Optional[pulumi.Input[
|
|
453
|
+
def root_password(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
455
454
|
pulumi.set(self, "root_password", value)
|
|
456
455
|
|
|
457
|
-
@property
|
|
456
|
+
@_builtins.property
|
|
458
457
|
@pulumi.getter(name="rootUsername")
|
|
459
|
-
def root_username(self) -> Optional[pulumi.Input[
|
|
458
|
+
def root_username(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
460
459
|
"""
|
|
461
460
|
The root username for the Managed Database instance.
|
|
462
461
|
"""
|
|
463
462
|
return pulumi.get(self, "root_username")
|
|
464
463
|
|
|
465
464
|
@root_username.setter
|
|
466
|
-
def root_username(self, value: Optional[pulumi.Input[
|
|
465
|
+
def root_username(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
467
466
|
pulumi.set(self, "root_username", value)
|
|
468
467
|
|
|
469
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
470
469
|
@pulumi.getter(name="sslConnection")
|
|
471
|
-
def ssl_connection(self) -> Optional[pulumi.Input[
|
|
470
|
+
def ssl_connection(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
472
471
|
"""
|
|
473
472
|
Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
474
473
|
|
|
@@ -477,24 +476,24 @@ class _DatabaseMysqlState:
|
|
|
477
476
|
return pulumi.get(self, "ssl_connection")
|
|
478
477
|
|
|
479
478
|
@ssl_connection.setter
|
|
480
|
-
def ssl_connection(self, value: Optional[pulumi.Input[
|
|
479
|
+
def ssl_connection(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
481
480
|
pulumi.set(self, "ssl_connection", value)
|
|
482
481
|
|
|
483
|
-
@property
|
|
482
|
+
@_builtins.property
|
|
484
483
|
@pulumi.getter
|
|
485
|
-
def status(self) -> Optional[pulumi.Input[
|
|
484
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
486
485
|
"""
|
|
487
486
|
The operating status of the Managed Database.
|
|
488
487
|
"""
|
|
489
488
|
return pulumi.get(self, "status")
|
|
490
489
|
|
|
491
490
|
@status.setter
|
|
492
|
-
def status(self, value: Optional[pulumi.Input[
|
|
491
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
493
492
|
pulumi.set(self, "status", value)
|
|
494
493
|
|
|
495
|
-
@property
|
|
494
|
+
@_builtins.property
|
|
496
495
|
@pulumi.getter
|
|
497
|
-
def type(self) -> Optional[pulumi.Input[
|
|
496
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
498
497
|
"""
|
|
499
498
|
The Linode Instance type used for the nodes of the Managed Database instance.
|
|
500
499
|
|
|
@@ -503,22 +502,22 @@ class _DatabaseMysqlState:
|
|
|
503
502
|
return pulumi.get(self, "type")
|
|
504
503
|
|
|
505
504
|
@type.setter
|
|
506
|
-
def type(self, value: Optional[pulumi.Input[
|
|
505
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
507
506
|
pulumi.set(self, "type", value)
|
|
508
507
|
|
|
509
|
-
@property
|
|
508
|
+
@_builtins.property
|
|
510
509
|
@pulumi.getter
|
|
511
|
-
def updated(self) -> Optional[pulumi.Input[
|
|
510
|
+
def updated(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
512
511
|
"""
|
|
513
512
|
When this Managed Database was last updated.
|
|
514
513
|
"""
|
|
515
514
|
return pulumi.get(self, "updated")
|
|
516
515
|
|
|
517
516
|
@updated.setter
|
|
518
|
-
def updated(self, value: Optional[pulumi.Input[
|
|
517
|
+
def updated(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
519
518
|
pulumi.set(self, "updated", value)
|
|
520
519
|
|
|
521
|
-
@property
|
|
520
|
+
@_builtins.property
|
|
522
521
|
@pulumi.getter
|
|
523
522
|
def updates(self) -> Optional[pulumi.Input['DatabaseMysqlUpdatesArgs']]:
|
|
524
523
|
"""
|
|
@@ -530,16 +529,16 @@ class _DatabaseMysqlState:
|
|
|
530
529
|
def updates(self, value: Optional[pulumi.Input['DatabaseMysqlUpdatesArgs']]):
|
|
531
530
|
pulumi.set(self, "updates", value)
|
|
532
531
|
|
|
533
|
-
@property
|
|
532
|
+
@_builtins.property
|
|
534
533
|
@pulumi.getter
|
|
535
|
-
def version(self) -> Optional[pulumi.Input[
|
|
534
|
+
def version(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
536
535
|
"""
|
|
537
536
|
The Managed Database engine version. (e.g. `v8.0.26`)
|
|
538
537
|
"""
|
|
539
538
|
return pulumi.get(self, "version")
|
|
540
539
|
|
|
541
540
|
@version.setter
|
|
542
|
-
def version(self, value: Optional[pulumi.Input[
|
|
541
|
+
def version(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
543
542
|
pulumi.set(self, "version", value)
|
|
544
543
|
|
|
545
544
|
|
|
@@ -549,15 +548,15 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
549
548
|
def __init__(__self__,
|
|
550
549
|
resource_name: str,
|
|
551
550
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
552
|
-
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
553
|
-
cluster_size: Optional[pulumi.Input[
|
|
554
|
-
encrypted: Optional[pulumi.Input[
|
|
555
|
-
engine_id: Optional[pulumi.Input[
|
|
556
|
-
label: Optional[pulumi.Input[
|
|
557
|
-
region: Optional[pulumi.Input[
|
|
558
|
-
replication_type: Optional[pulumi.Input[
|
|
559
|
-
ssl_connection: Optional[pulumi.Input[
|
|
560
|
-
type: Optional[pulumi.Input[
|
|
551
|
+
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
552
|
+
cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
553
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
554
|
+
engine_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
555
|
+
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
556
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
557
|
+
replication_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
558
|
+
ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
559
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
561
560
|
updates: Optional[pulumi.Input[Union['DatabaseMysqlUpdatesArgs', 'DatabaseMysqlUpdatesArgsDict']]] = None,
|
|
562
561
|
__props__=None):
|
|
563
562
|
"""
|
|
@@ -632,21 +631,21 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
632
631
|
|
|
633
632
|
:param str resource_name: The name of the resource.
|
|
634
633
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
635
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
636
|
-
:param pulumi.Input[
|
|
637
|
-
:param pulumi.Input[
|
|
638
|
-
:param pulumi.Input[
|
|
639
|
-
:param pulumi.Input[
|
|
640
|
-
:param pulumi.Input[
|
|
641
|
-
:param pulumi.Input[
|
|
634
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
635
|
+
:param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
636
|
+
:param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
|
|
637
|
+
:param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
638
|
+
:param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
|
|
639
|
+
:param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
|
|
640
|
+
:param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
642
641
|
|
|
643
642
|
* Must be `none` for a single node cluster.
|
|
644
643
|
|
|
645
644
|
* Must be `asynch` or `semi_synch` for a high availability cluster.
|
|
646
|
-
:param pulumi.Input[
|
|
645
|
+
:param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
647
646
|
|
|
648
647
|
* `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
|
|
649
|
-
:param pulumi.Input[
|
|
648
|
+
:param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
|
|
650
649
|
|
|
651
650
|
- - -
|
|
652
651
|
:param pulumi.Input[Union['DatabaseMysqlUpdatesArgs', 'DatabaseMysqlUpdatesArgsDict']] updates: Configuration settings for automated patch update maintenance for the Managed Database.
|
|
@@ -742,15 +741,15 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
742
741
|
def _internal_init(__self__,
|
|
743
742
|
resource_name: str,
|
|
744
743
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
745
|
-
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
746
|
-
cluster_size: Optional[pulumi.Input[
|
|
747
|
-
encrypted: Optional[pulumi.Input[
|
|
748
|
-
engine_id: Optional[pulumi.Input[
|
|
749
|
-
label: Optional[pulumi.Input[
|
|
750
|
-
region: Optional[pulumi.Input[
|
|
751
|
-
replication_type: Optional[pulumi.Input[
|
|
752
|
-
ssl_connection: Optional[pulumi.Input[
|
|
753
|
-
type: Optional[pulumi.Input[
|
|
744
|
+
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
745
|
+
cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
746
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
747
|
+
engine_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
748
|
+
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
749
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
750
|
+
replication_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
751
|
+
ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
752
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
754
753
|
updates: Optional[pulumi.Input[Union['DatabaseMysqlUpdatesArgs', 'DatabaseMysqlUpdatesArgsDict']]] = None,
|
|
755
754
|
__props__=None):
|
|
756
755
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
@@ -801,26 +800,26 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
801
800
|
def get(resource_name: str,
|
|
802
801
|
id: pulumi.Input[str],
|
|
803
802
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
804
|
-
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
805
|
-
ca_cert: Optional[pulumi.Input[
|
|
806
|
-
cluster_size: Optional[pulumi.Input[
|
|
807
|
-
created: Optional[pulumi.Input[
|
|
808
|
-
encrypted: Optional[pulumi.Input[
|
|
809
|
-
engine: Optional[pulumi.Input[
|
|
810
|
-
engine_id: Optional[pulumi.Input[
|
|
811
|
-
host_primary: Optional[pulumi.Input[
|
|
812
|
-
host_secondary: Optional[pulumi.Input[
|
|
813
|
-
label: Optional[pulumi.Input[
|
|
814
|
-
region: Optional[pulumi.Input[
|
|
815
|
-
replication_type: Optional[pulumi.Input[
|
|
816
|
-
root_password: Optional[pulumi.Input[
|
|
817
|
-
root_username: Optional[pulumi.Input[
|
|
818
|
-
ssl_connection: Optional[pulumi.Input[
|
|
819
|
-
status: Optional[pulumi.Input[
|
|
820
|
-
type: Optional[pulumi.Input[
|
|
821
|
-
updated: Optional[pulumi.Input[
|
|
803
|
+
allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
804
|
+
ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
805
|
+
cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
|
|
806
|
+
created: Optional[pulumi.Input[_builtins.str]] = None,
|
|
807
|
+
encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
808
|
+
engine: Optional[pulumi.Input[_builtins.str]] = None,
|
|
809
|
+
engine_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
810
|
+
host_primary: Optional[pulumi.Input[_builtins.str]] = None,
|
|
811
|
+
host_secondary: Optional[pulumi.Input[_builtins.str]] = None,
|
|
812
|
+
label: Optional[pulumi.Input[_builtins.str]] = None,
|
|
813
|
+
region: Optional[pulumi.Input[_builtins.str]] = None,
|
|
814
|
+
replication_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
815
|
+
root_password: Optional[pulumi.Input[_builtins.str]] = None,
|
|
816
|
+
root_username: Optional[pulumi.Input[_builtins.str]] = None,
|
|
817
|
+
ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
818
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
819
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
820
|
+
updated: Optional[pulumi.Input[_builtins.str]] = None,
|
|
822
821
|
updates: Optional[pulumi.Input[Union['DatabaseMysqlUpdatesArgs', 'DatabaseMysqlUpdatesArgsDict']]] = None,
|
|
823
|
-
version: Optional[pulumi.Input[
|
|
822
|
+
version: Optional[pulumi.Input[_builtins.str]] = None) -> 'DatabaseMysql':
|
|
824
823
|
"""
|
|
825
824
|
Get an existing DatabaseMysql resource's state with the given name, id, and optional extra
|
|
826
825
|
properties used to qualify the lookup.
|
|
@@ -828,34 +827,34 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
828
827
|
:param str resource_name: The unique name of the resulting resource.
|
|
829
828
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
830
829
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
831
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
832
|
-
:param pulumi.Input[
|
|
833
|
-
:param pulumi.Input[
|
|
834
|
-
:param pulumi.Input[
|
|
835
|
-
:param pulumi.Input[
|
|
836
|
-
:param pulumi.Input[
|
|
837
|
-
:param pulumi.Input[
|
|
838
|
-
:param pulumi.Input[
|
|
839
|
-
:param pulumi.Input[
|
|
840
|
-
:param pulumi.Input[
|
|
841
|
-
:param pulumi.Input[
|
|
842
|
-
:param pulumi.Input[
|
|
830
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
831
|
+
:param pulumi.Input[_builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
|
|
832
|
+
:param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
833
|
+
:param pulumi.Input[_builtins.str] created: When this Managed Database was created.
|
|
834
|
+
:param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
|
|
835
|
+
:param pulumi.Input[_builtins.str] engine: The Managed Database engine. (e.g. `mysql`)
|
|
836
|
+
:param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
837
|
+
:param pulumi.Input[_builtins.str] host_primary: The primary host for the Managed Database.
|
|
838
|
+
:param pulumi.Input[_builtins.str] host_secondary: The secondary/private network host for the Managed Database.
|
|
839
|
+
:param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
|
|
840
|
+
:param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
|
|
841
|
+
:param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
843
842
|
|
|
844
843
|
* Must be `none` for a single node cluster.
|
|
845
844
|
|
|
846
845
|
* Must be `asynch` or `semi_synch` for a high availability cluster.
|
|
847
|
-
:param pulumi.Input[
|
|
848
|
-
:param pulumi.Input[
|
|
849
|
-
:param pulumi.Input[
|
|
846
|
+
:param pulumi.Input[_builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
|
|
847
|
+
:param pulumi.Input[_builtins.str] root_username: The root username for the Managed Database instance.
|
|
848
|
+
:param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
850
849
|
|
|
851
850
|
* `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
|
|
852
|
-
:param pulumi.Input[
|
|
853
|
-
:param pulumi.Input[
|
|
851
|
+
:param pulumi.Input[_builtins.str] status: The operating status of the Managed Database.
|
|
852
|
+
:param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
|
|
854
853
|
|
|
855
854
|
- - -
|
|
856
|
-
:param pulumi.Input[
|
|
855
|
+
:param pulumi.Input[_builtins.str] updated: When this Managed Database was last updated.
|
|
857
856
|
:param pulumi.Input[Union['DatabaseMysqlUpdatesArgs', 'DatabaseMysqlUpdatesArgsDict']] updates: Configuration settings for automated patch update maintenance for the Managed Database.
|
|
858
|
-
:param pulumi.Input[
|
|
857
|
+
:param pulumi.Input[_builtins.str] version: The Managed Database engine version. (e.g. `v8.0.26`)
|
|
859
858
|
"""
|
|
860
859
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
861
860
|
|
|
@@ -883,97 +882,97 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
883
882
|
__props__.__dict__["version"] = version
|
|
884
883
|
return DatabaseMysql(resource_name, opts=opts, __props__=__props__)
|
|
885
884
|
|
|
886
|
-
@property
|
|
885
|
+
@_builtins.property
|
|
887
886
|
@pulumi.getter(name="allowLists")
|
|
888
|
-
def allow_lists(self) -> pulumi.Output[Sequence[
|
|
887
|
+
def allow_lists(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
889
888
|
"""
|
|
890
889
|
A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
|
|
891
890
|
"""
|
|
892
891
|
return pulumi.get(self, "allow_lists")
|
|
893
892
|
|
|
894
|
-
@property
|
|
893
|
+
@_builtins.property
|
|
895
894
|
@pulumi.getter(name="caCert")
|
|
896
|
-
def ca_cert(self) -> pulumi.Output[
|
|
895
|
+
def ca_cert(self) -> pulumi.Output[_builtins.str]:
|
|
897
896
|
"""
|
|
898
897
|
The base64-encoded SSL CA certificate for the Managed Database instance.
|
|
899
898
|
"""
|
|
900
899
|
return pulumi.get(self, "ca_cert")
|
|
901
900
|
|
|
902
|
-
@property
|
|
901
|
+
@_builtins.property
|
|
903
902
|
@pulumi.getter(name="clusterSize")
|
|
904
|
-
def cluster_size(self) -> pulumi.Output[Optional[
|
|
903
|
+
def cluster_size(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
905
904
|
"""
|
|
906
905
|
The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
|
|
907
906
|
"""
|
|
908
907
|
return pulumi.get(self, "cluster_size")
|
|
909
908
|
|
|
910
|
-
@property
|
|
909
|
+
@_builtins.property
|
|
911
910
|
@pulumi.getter
|
|
912
|
-
def created(self) -> pulumi.Output[
|
|
911
|
+
def created(self) -> pulumi.Output[_builtins.str]:
|
|
913
912
|
"""
|
|
914
913
|
When this Managed Database was created.
|
|
915
914
|
"""
|
|
916
915
|
return pulumi.get(self, "created")
|
|
917
916
|
|
|
918
|
-
@property
|
|
917
|
+
@_builtins.property
|
|
919
918
|
@pulumi.getter
|
|
920
|
-
def encrypted(self) -> pulumi.Output[Optional[
|
|
919
|
+
def encrypted(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
921
920
|
"""
|
|
922
921
|
Whether the Managed Databases is encrypted. (default `false`)
|
|
923
922
|
"""
|
|
924
923
|
return pulumi.get(self, "encrypted")
|
|
925
924
|
|
|
926
|
-
@property
|
|
925
|
+
@_builtins.property
|
|
927
926
|
@pulumi.getter
|
|
928
|
-
def engine(self) -> pulumi.Output[
|
|
927
|
+
def engine(self) -> pulumi.Output[_builtins.str]:
|
|
929
928
|
"""
|
|
930
929
|
The Managed Database engine. (e.g. `mysql`)
|
|
931
930
|
"""
|
|
932
931
|
return pulumi.get(self, "engine")
|
|
933
932
|
|
|
934
|
-
@property
|
|
933
|
+
@_builtins.property
|
|
935
934
|
@pulumi.getter(name="engineId")
|
|
936
|
-
def engine_id(self) -> pulumi.Output[
|
|
935
|
+
def engine_id(self) -> pulumi.Output[_builtins.str]:
|
|
937
936
|
"""
|
|
938
937
|
The Managed Database engine in engine/version format. (e.g. `mysql/8.0.30`)
|
|
939
938
|
"""
|
|
940
939
|
return pulumi.get(self, "engine_id")
|
|
941
940
|
|
|
942
|
-
@property
|
|
941
|
+
@_builtins.property
|
|
943
942
|
@pulumi.getter(name="hostPrimary")
|
|
944
|
-
def host_primary(self) -> pulumi.Output[
|
|
943
|
+
def host_primary(self) -> pulumi.Output[_builtins.str]:
|
|
945
944
|
"""
|
|
946
945
|
The primary host for the Managed Database.
|
|
947
946
|
"""
|
|
948
947
|
return pulumi.get(self, "host_primary")
|
|
949
948
|
|
|
950
|
-
@property
|
|
949
|
+
@_builtins.property
|
|
951
950
|
@pulumi.getter(name="hostSecondary")
|
|
952
|
-
def host_secondary(self) -> pulumi.Output[
|
|
951
|
+
def host_secondary(self) -> pulumi.Output[_builtins.str]:
|
|
953
952
|
"""
|
|
954
953
|
The secondary/private network host for the Managed Database.
|
|
955
954
|
"""
|
|
956
955
|
return pulumi.get(self, "host_secondary")
|
|
957
956
|
|
|
958
|
-
@property
|
|
957
|
+
@_builtins.property
|
|
959
958
|
@pulumi.getter
|
|
960
|
-
def label(self) -> pulumi.Output[
|
|
959
|
+
def label(self) -> pulumi.Output[_builtins.str]:
|
|
961
960
|
"""
|
|
962
961
|
A unique, user-defined string referring to the Managed Database.
|
|
963
962
|
"""
|
|
964
963
|
return pulumi.get(self, "label")
|
|
965
964
|
|
|
966
|
-
@property
|
|
965
|
+
@_builtins.property
|
|
967
966
|
@pulumi.getter
|
|
968
|
-
def region(self) -> pulumi.Output[
|
|
967
|
+
def region(self) -> pulumi.Output[_builtins.str]:
|
|
969
968
|
"""
|
|
970
969
|
The region to use for the Managed Database.
|
|
971
970
|
"""
|
|
972
971
|
return pulumi.get(self, "region")
|
|
973
972
|
|
|
974
|
-
@property
|
|
973
|
+
@_builtins.property
|
|
975
974
|
@pulumi.getter(name="replicationType")
|
|
976
|
-
def replication_type(self) -> pulumi.Output[Optional[
|
|
975
|
+
def replication_type(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
977
976
|
"""
|
|
978
977
|
The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
|
|
979
978
|
|
|
@@ -983,25 +982,25 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
983
982
|
"""
|
|
984
983
|
return pulumi.get(self, "replication_type")
|
|
985
984
|
|
|
986
|
-
@property
|
|
985
|
+
@_builtins.property
|
|
987
986
|
@pulumi.getter(name="rootPassword")
|
|
988
|
-
def root_password(self) -> pulumi.Output[
|
|
987
|
+
def root_password(self) -> pulumi.Output[_builtins.str]:
|
|
989
988
|
"""
|
|
990
989
|
The randomly-generated root password for the Managed Database instance.
|
|
991
990
|
"""
|
|
992
991
|
return pulumi.get(self, "root_password")
|
|
993
992
|
|
|
994
|
-
@property
|
|
993
|
+
@_builtins.property
|
|
995
994
|
@pulumi.getter(name="rootUsername")
|
|
996
|
-
def root_username(self) -> pulumi.Output[
|
|
995
|
+
def root_username(self) -> pulumi.Output[_builtins.str]:
|
|
997
996
|
"""
|
|
998
997
|
The root username for the Managed Database instance.
|
|
999
998
|
"""
|
|
1000
999
|
return pulumi.get(self, "root_username")
|
|
1001
1000
|
|
|
1002
|
-
@property
|
|
1001
|
+
@_builtins.property
|
|
1003
1002
|
@pulumi.getter(name="sslConnection")
|
|
1004
|
-
def ssl_connection(self) -> pulumi.Output[Optional[
|
|
1003
|
+
def ssl_connection(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1005
1004
|
"""
|
|
1006
1005
|
Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
|
|
1007
1006
|
|
|
@@ -1009,17 +1008,17 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
1009
1008
|
"""
|
|
1010
1009
|
return pulumi.get(self, "ssl_connection")
|
|
1011
1010
|
|
|
1012
|
-
@property
|
|
1011
|
+
@_builtins.property
|
|
1013
1012
|
@pulumi.getter
|
|
1014
|
-
def status(self) -> pulumi.Output[
|
|
1013
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1015
1014
|
"""
|
|
1016
1015
|
The operating status of the Managed Database.
|
|
1017
1016
|
"""
|
|
1018
1017
|
return pulumi.get(self, "status")
|
|
1019
1018
|
|
|
1020
|
-
@property
|
|
1019
|
+
@_builtins.property
|
|
1021
1020
|
@pulumi.getter
|
|
1022
|
-
def type(self) -> pulumi.Output[
|
|
1021
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1023
1022
|
"""
|
|
1024
1023
|
The Linode Instance type used for the nodes of the Managed Database instance.
|
|
1025
1024
|
|
|
@@ -1027,15 +1026,15 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
1027
1026
|
"""
|
|
1028
1027
|
return pulumi.get(self, "type")
|
|
1029
1028
|
|
|
1030
|
-
@property
|
|
1029
|
+
@_builtins.property
|
|
1031
1030
|
@pulumi.getter
|
|
1032
|
-
def updated(self) -> pulumi.Output[
|
|
1031
|
+
def updated(self) -> pulumi.Output[_builtins.str]:
|
|
1033
1032
|
"""
|
|
1034
1033
|
When this Managed Database was last updated.
|
|
1035
1034
|
"""
|
|
1036
1035
|
return pulumi.get(self, "updated")
|
|
1037
1036
|
|
|
1038
|
-
@property
|
|
1037
|
+
@_builtins.property
|
|
1039
1038
|
@pulumi.getter
|
|
1040
1039
|
def updates(self) -> pulumi.Output['outputs.DatabaseMysqlUpdates']:
|
|
1041
1040
|
"""
|
|
@@ -1043,9 +1042,9 @@ class DatabaseMysql(pulumi.CustomResource):
|
|
|
1043
1042
|
"""
|
|
1044
1043
|
return pulumi.get(self, "updates")
|
|
1045
1044
|
|
|
1046
|
-
@property
|
|
1045
|
+
@_builtins.property
|
|
1047
1046
|
@pulumi.getter
|
|
1048
|
-
def version(self) -> pulumi.Output[
|
|
1047
|
+
def version(self) -> pulumi.Output[_builtins.str]:
|
|
1049
1048
|
"""
|
|
1050
1049
|
The Managed Database engine version. (e.g. `v8.0.26`)
|
|
1051
1050
|
"""
|