pulumi-linode 5.1.0a1752772340__py3-none-any.whl → 5.1.1a1753933550__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 +5224 -5147
- 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 +34 -35
- 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 +5340 -5291
- 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.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.dist-info}/METADATA +1 -1
- pulumi_linode-5.1.1a1753933550.dist-info/RECORD +126 -0
- pulumi_linode-5.1.0a1752772340.dist-info/RECORD +0 -126
- {pulumi_linode-5.1.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.dist-info}/WHEEL +0 -0
- {pulumi_linode-5.1.0a1752772340.dist-info → pulumi_linode-5.1.1a1753933550.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
|
|
@@ -22,45 +21,45 @@ __all__ = ['NodeBalancerConfigArgs', 'NodeBalancerConfig']
|
|
|
22
21
|
@pulumi.input_type
|
|
23
22
|
class NodeBalancerConfigArgs:
|
|
24
23
|
def __init__(__self__, *,
|
|
25
|
-
nodebalancer_id: pulumi.Input[
|
|
26
|
-
algorithm: Optional[pulumi.Input[
|
|
27
|
-
check: Optional[pulumi.Input[
|
|
28
|
-
check_attempts: Optional[pulumi.Input[
|
|
29
|
-
check_body: Optional[pulumi.Input[
|
|
30
|
-
check_interval: Optional[pulumi.Input[
|
|
31
|
-
check_passive: Optional[pulumi.Input[
|
|
32
|
-
check_path: Optional[pulumi.Input[
|
|
33
|
-
check_timeout: Optional[pulumi.Input[
|
|
34
|
-
cipher_suite: Optional[pulumi.Input[
|
|
35
|
-
port: Optional[pulumi.Input[
|
|
36
|
-
protocol: Optional[pulumi.Input[
|
|
37
|
-
proxy_protocol: Optional[pulumi.Input[
|
|
38
|
-
ssl_cert: Optional[pulumi.Input[
|
|
39
|
-
ssl_key: Optional[pulumi.Input[
|
|
40
|
-
stickiness: Optional[pulumi.Input[
|
|
41
|
-
udp_check_port: Optional[pulumi.Input[
|
|
24
|
+
nodebalancer_id: pulumi.Input[_builtins.int],
|
|
25
|
+
algorithm: Optional[pulumi.Input[_builtins.str]] = None,
|
|
26
|
+
check: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
check_attempts: Optional[pulumi.Input[_builtins.int]] = None,
|
|
28
|
+
check_body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
check_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
30
|
+
check_passive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
check_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
32
|
+
check_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
33
|
+
cipher_suite: Optional[pulumi.Input[_builtins.str]] = None,
|
|
34
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
35
|
+
protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
proxy_protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
37
|
+
ssl_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
ssl_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
stickiness: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
udp_check_port: Optional[pulumi.Input[_builtins.int]] = None):
|
|
42
41
|
"""
|
|
43
42
|
The set of arguments for constructing a NodeBalancerConfig resource.
|
|
44
|
-
:param pulumi.Input[
|
|
43
|
+
:param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
|
|
45
44
|
|
|
46
45
|
- - -
|
|
47
|
-
:param pulumi.Input[
|
|
48
|
-
:param pulumi.Input[
|
|
49
|
-
:param pulumi.Input[
|
|
50
|
-
:param pulumi.Input[
|
|
46
|
+
:param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
47
|
+
:param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
48
|
+
:param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
|
|
49
|
+
:param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
51
50
|
the response body of a check request, the backend is considered to be down
|
|
52
|
-
:param pulumi.Input[
|
|
53
|
-
:param pulumi.Input[
|
|
54
|
-
:param pulumi.Input[
|
|
55
|
-
:param pulumi.Input[
|
|
56
|
-
:param pulumi.Input[
|
|
57
|
-
:param pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
59
|
-
:param pulumi.Input[
|
|
60
|
-
:param pulumi.Input[
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
51
|
+
:param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
|
|
52
|
+
:param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
53
|
+
:param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
54
|
+
:param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
55
|
+
:param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
56
|
+
:param pulumi.Input[_builtins.int] port: The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
57
|
+
:param pulumi.Input[_builtins.str] protocol: The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
58
|
+
:param pulumi.Input[_builtins.str] proxy_protocol: The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
59
|
+
:param pulumi.Input[_builtins.str] ssl_cert: The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
60
|
+
:param pulumi.Input[_builtins.str] ssl_key: The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
61
|
+
:param pulumi.Input[_builtins.str] stickiness: Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
62
|
+
:param pulumi.Input[_builtins.int] udp_check_port: Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
64
63
|
|
|
65
64
|
* **NOTE: This argument may not be generally available.**
|
|
66
65
|
"""
|
|
@@ -98,9 +97,9 @@ class NodeBalancerConfigArgs:
|
|
|
98
97
|
if udp_check_port is not None:
|
|
99
98
|
pulumi.set(__self__, "udp_check_port", udp_check_port)
|
|
100
99
|
|
|
101
|
-
@property
|
|
100
|
+
@_builtins.property
|
|
102
101
|
@pulumi.getter(name="nodebalancerId")
|
|
103
|
-
def nodebalancer_id(self) -> pulumi.Input[
|
|
102
|
+
def nodebalancer_id(self) -> pulumi.Input[_builtins.int]:
|
|
104
103
|
"""
|
|
105
104
|
The ID of the NodeBalancer to access.
|
|
106
105
|
|
|
@@ -109,48 +108,48 @@ class NodeBalancerConfigArgs:
|
|
|
109
108
|
return pulumi.get(self, "nodebalancer_id")
|
|
110
109
|
|
|
111
110
|
@nodebalancer_id.setter
|
|
112
|
-
def nodebalancer_id(self, value: pulumi.Input[
|
|
111
|
+
def nodebalancer_id(self, value: pulumi.Input[_builtins.int]):
|
|
113
112
|
pulumi.set(self, "nodebalancer_id", value)
|
|
114
113
|
|
|
115
|
-
@property
|
|
114
|
+
@_builtins.property
|
|
116
115
|
@pulumi.getter
|
|
117
|
-
def algorithm(self) -> Optional[pulumi.Input[
|
|
116
|
+
def algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
118
117
|
"""
|
|
119
118
|
What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
120
119
|
"""
|
|
121
120
|
return pulumi.get(self, "algorithm")
|
|
122
121
|
|
|
123
122
|
@algorithm.setter
|
|
124
|
-
def algorithm(self, value: Optional[pulumi.Input[
|
|
123
|
+
def algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
125
124
|
pulumi.set(self, "algorithm", value)
|
|
126
125
|
|
|
127
|
-
@property
|
|
126
|
+
@_builtins.property
|
|
128
127
|
@pulumi.getter
|
|
129
|
-
def check(self) -> Optional[pulumi.Input[
|
|
128
|
+
def check(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
130
129
|
"""
|
|
131
130
|
The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
132
131
|
"""
|
|
133
132
|
return pulumi.get(self, "check")
|
|
134
133
|
|
|
135
134
|
@check.setter
|
|
136
|
-
def check(self, value: Optional[pulumi.Input[
|
|
135
|
+
def check(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
137
136
|
pulumi.set(self, "check", value)
|
|
138
137
|
|
|
139
|
-
@property
|
|
138
|
+
@_builtins.property
|
|
140
139
|
@pulumi.getter(name="checkAttempts")
|
|
141
|
-
def check_attempts(self) -> Optional[pulumi.Input[
|
|
140
|
+
def check_attempts(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
142
141
|
"""
|
|
143
142
|
How many times to attempt a check before considering a backend to be down. (1-30)
|
|
144
143
|
"""
|
|
145
144
|
return pulumi.get(self, "check_attempts")
|
|
146
145
|
|
|
147
146
|
@check_attempts.setter
|
|
148
|
-
def check_attempts(self, value: Optional[pulumi.Input[
|
|
147
|
+
def check_attempts(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
149
148
|
pulumi.set(self, "check_attempts", value)
|
|
150
149
|
|
|
151
|
-
@property
|
|
150
|
+
@_builtins.property
|
|
152
151
|
@pulumi.getter(name="checkBody")
|
|
153
|
-
def check_body(self) -> Optional[pulumi.Input[
|
|
152
|
+
def check_body(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
154
153
|
"""
|
|
155
154
|
This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
156
155
|
the response body of a check request, the backend is considered to be down
|
|
@@ -158,144 +157,144 @@ class NodeBalancerConfigArgs:
|
|
|
158
157
|
return pulumi.get(self, "check_body")
|
|
159
158
|
|
|
160
159
|
@check_body.setter
|
|
161
|
-
def check_body(self, value: Optional[pulumi.Input[
|
|
160
|
+
def check_body(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
162
161
|
pulumi.set(self, "check_body", value)
|
|
163
162
|
|
|
164
|
-
@property
|
|
163
|
+
@_builtins.property
|
|
165
164
|
@pulumi.getter(name="checkInterval")
|
|
166
|
-
def check_interval(self) -> Optional[pulumi.Input[
|
|
165
|
+
def check_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
167
166
|
"""
|
|
168
167
|
How often, in seconds, to check that backends are up and serving requests.
|
|
169
168
|
"""
|
|
170
169
|
return pulumi.get(self, "check_interval")
|
|
171
170
|
|
|
172
171
|
@check_interval.setter
|
|
173
|
-
def check_interval(self, value: Optional[pulumi.Input[
|
|
172
|
+
def check_interval(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
174
173
|
pulumi.set(self, "check_interval", value)
|
|
175
174
|
|
|
176
|
-
@property
|
|
175
|
+
@_builtins.property
|
|
177
176
|
@pulumi.getter(name="checkPassive")
|
|
178
|
-
def check_passive(self) -> Optional[pulumi.Input[
|
|
177
|
+
def check_passive(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
179
178
|
"""
|
|
180
179
|
If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
181
180
|
"""
|
|
182
181
|
return pulumi.get(self, "check_passive")
|
|
183
182
|
|
|
184
183
|
@check_passive.setter
|
|
185
|
-
def check_passive(self, value: Optional[pulumi.Input[
|
|
184
|
+
def check_passive(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
186
185
|
pulumi.set(self, "check_passive", value)
|
|
187
186
|
|
|
188
|
-
@property
|
|
187
|
+
@_builtins.property
|
|
189
188
|
@pulumi.getter(name="checkPath")
|
|
190
|
-
def check_path(self) -> Optional[pulumi.Input[
|
|
189
|
+
def check_path(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
191
190
|
"""
|
|
192
191
|
The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
193
192
|
"""
|
|
194
193
|
return pulumi.get(self, "check_path")
|
|
195
194
|
|
|
196
195
|
@check_path.setter
|
|
197
|
-
def check_path(self, value: Optional[pulumi.Input[
|
|
196
|
+
def check_path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
198
197
|
pulumi.set(self, "check_path", value)
|
|
199
198
|
|
|
200
|
-
@property
|
|
199
|
+
@_builtins.property
|
|
201
200
|
@pulumi.getter(name="checkTimeout")
|
|
202
|
-
def check_timeout(self) -> Optional[pulumi.Input[
|
|
201
|
+
def check_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
203
202
|
"""
|
|
204
203
|
How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
205
204
|
"""
|
|
206
205
|
return pulumi.get(self, "check_timeout")
|
|
207
206
|
|
|
208
207
|
@check_timeout.setter
|
|
209
|
-
def check_timeout(self, value: Optional[pulumi.Input[
|
|
208
|
+
def check_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
210
209
|
pulumi.set(self, "check_timeout", value)
|
|
211
210
|
|
|
212
|
-
@property
|
|
211
|
+
@_builtins.property
|
|
213
212
|
@pulumi.getter(name="cipherSuite")
|
|
214
|
-
def cipher_suite(self) -> Optional[pulumi.Input[
|
|
213
|
+
def cipher_suite(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
215
214
|
"""
|
|
216
215
|
What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
217
216
|
"""
|
|
218
217
|
return pulumi.get(self, "cipher_suite")
|
|
219
218
|
|
|
220
219
|
@cipher_suite.setter
|
|
221
|
-
def cipher_suite(self, value: Optional[pulumi.Input[
|
|
220
|
+
def cipher_suite(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
222
221
|
pulumi.set(self, "cipher_suite", value)
|
|
223
222
|
|
|
224
|
-
@property
|
|
223
|
+
@_builtins.property
|
|
225
224
|
@pulumi.getter
|
|
226
|
-
def port(self) -> Optional[pulumi.Input[
|
|
225
|
+
def port(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
227
226
|
"""
|
|
228
227
|
The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
229
228
|
"""
|
|
230
229
|
return pulumi.get(self, "port")
|
|
231
230
|
|
|
232
231
|
@port.setter
|
|
233
|
-
def port(self, value: Optional[pulumi.Input[
|
|
232
|
+
def port(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
234
233
|
pulumi.set(self, "port", value)
|
|
235
234
|
|
|
236
|
-
@property
|
|
235
|
+
@_builtins.property
|
|
237
236
|
@pulumi.getter
|
|
238
|
-
def protocol(self) -> Optional[pulumi.Input[
|
|
237
|
+
def protocol(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
239
238
|
"""
|
|
240
239
|
The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
241
240
|
"""
|
|
242
241
|
return pulumi.get(self, "protocol")
|
|
243
242
|
|
|
244
243
|
@protocol.setter
|
|
245
|
-
def protocol(self, value: Optional[pulumi.Input[
|
|
244
|
+
def protocol(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
246
245
|
pulumi.set(self, "protocol", value)
|
|
247
246
|
|
|
248
|
-
@property
|
|
247
|
+
@_builtins.property
|
|
249
248
|
@pulumi.getter(name="proxyProtocol")
|
|
250
|
-
def proxy_protocol(self) -> Optional[pulumi.Input[
|
|
249
|
+
def proxy_protocol(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
251
250
|
"""
|
|
252
251
|
The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
253
252
|
"""
|
|
254
253
|
return pulumi.get(self, "proxy_protocol")
|
|
255
254
|
|
|
256
255
|
@proxy_protocol.setter
|
|
257
|
-
def proxy_protocol(self, value: Optional[pulumi.Input[
|
|
256
|
+
def proxy_protocol(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
258
257
|
pulumi.set(self, "proxy_protocol", value)
|
|
259
258
|
|
|
260
|
-
@property
|
|
259
|
+
@_builtins.property
|
|
261
260
|
@pulumi.getter(name="sslCert")
|
|
262
|
-
def ssl_cert(self) -> Optional[pulumi.Input[
|
|
261
|
+
def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
263
262
|
"""
|
|
264
263
|
The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
265
264
|
"""
|
|
266
265
|
return pulumi.get(self, "ssl_cert")
|
|
267
266
|
|
|
268
267
|
@ssl_cert.setter
|
|
269
|
-
def ssl_cert(self, value: Optional[pulumi.Input[
|
|
268
|
+
def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
270
269
|
pulumi.set(self, "ssl_cert", value)
|
|
271
270
|
|
|
272
|
-
@property
|
|
271
|
+
@_builtins.property
|
|
273
272
|
@pulumi.getter(name="sslKey")
|
|
274
|
-
def ssl_key(self) -> Optional[pulumi.Input[
|
|
273
|
+
def ssl_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
275
274
|
"""
|
|
276
275
|
The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
277
276
|
"""
|
|
278
277
|
return pulumi.get(self, "ssl_key")
|
|
279
278
|
|
|
280
279
|
@ssl_key.setter
|
|
281
|
-
def ssl_key(self, value: Optional[pulumi.Input[
|
|
280
|
+
def ssl_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
282
281
|
pulumi.set(self, "ssl_key", value)
|
|
283
282
|
|
|
284
|
-
@property
|
|
283
|
+
@_builtins.property
|
|
285
284
|
@pulumi.getter
|
|
286
|
-
def stickiness(self) -> Optional[pulumi.Input[
|
|
285
|
+
def stickiness(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
287
286
|
"""
|
|
288
287
|
Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
289
288
|
"""
|
|
290
289
|
return pulumi.get(self, "stickiness")
|
|
291
290
|
|
|
292
291
|
@stickiness.setter
|
|
293
|
-
def stickiness(self, value: Optional[pulumi.Input[
|
|
292
|
+
def stickiness(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
294
293
|
pulumi.set(self, "stickiness", value)
|
|
295
294
|
|
|
296
|
-
@property
|
|
295
|
+
@_builtins.property
|
|
297
296
|
@pulumi.getter(name="udpCheckPort")
|
|
298
|
-
def udp_check_port(self) -> Optional[pulumi.Input[
|
|
297
|
+
def udp_check_port(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
299
298
|
"""
|
|
300
299
|
Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
301
300
|
|
|
@@ -304,63 +303,63 @@ class NodeBalancerConfigArgs:
|
|
|
304
303
|
return pulumi.get(self, "udp_check_port")
|
|
305
304
|
|
|
306
305
|
@udp_check_port.setter
|
|
307
|
-
def udp_check_port(self, value: Optional[pulumi.Input[
|
|
306
|
+
def udp_check_port(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
308
307
|
pulumi.set(self, "udp_check_port", value)
|
|
309
308
|
|
|
310
309
|
|
|
311
310
|
@pulumi.input_type
|
|
312
311
|
class _NodeBalancerConfigState:
|
|
313
312
|
def __init__(__self__, *,
|
|
314
|
-
algorithm: Optional[pulumi.Input[
|
|
315
|
-
check: Optional[pulumi.Input[
|
|
316
|
-
check_attempts: Optional[pulumi.Input[
|
|
317
|
-
check_body: Optional[pulumi.Input[
|
|
318
|
-
check_interval: Optional[pulumi.Input[
|
|
319
|
-
check_passive: Optional[pulumi.Input[
|
|
320
|
-
check_path: Optional[pulumi.Input[
|
|
321
|
-
check_timeout: Optional[pulumi.Input[
|
|
322
|
-
cipher_suite: Optional[pulumi.Input[
|
|
313
|
+
algorithm: Optional[pulumi.Input[_builtins.str]] = None,
|
|
314
|
+
check: Optional[pulumi.Input[_builtins.str]] = None,
|
|
315
|
+
check_attempts: Optional[pulumi.Input[_builtins.int]] = None,
|
|
316
|
+
check_body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
317
|
+
check_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
318
|
+
check_passive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
319
|
+
check_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
320
|
+
check_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
321
|
+
cipher_suite: Optional[pulumi.Input[_builtins.str]] = None,
|
|
323
322
|
node_statuses: Optional[pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]]] = None,
|
|
324
|
-
nodebalancer_id: Optional[pulumi.Input[
|
|
325
|
-
port: Optional[pulumi.Input[
|
|
326
|
-
protocol: Optional[pulumi.Input[
|
|
327
|
-
proxy_protocol: Optional[pulumi.Input[
|
|
328
|
-
ssl_cert: Optional[pulumi.Input[
|
|
329
|
-
ssl_commonname: Optional[pulumi.Input[
|
|
330
|
-
ssl_fingerprint: Optional[pulumi.Input[
|
|
331
|
-
ssl_key: Optional[pulumi.Input[
|
|
332
|
-
stickiness: Optional[pulumi.Input[
|
|
333
|
-
udp_check_port: Optional[pulumi.Input[
|
|
334
|
-
udp_session_timeout: Optional[pulumi.Input[
|
|
323
|
+
nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
324
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
325
|
+
protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
326
|
+
proxy_protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
327
|
+
ssl_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
328
|
+
ssl_commonname: Optional[pulumi.Input[_builtins.str]] = None,
|
|
329
|
+
ssl_fingerprint: Optional[pulumi.Input[_builtins.str]] = None,
|
|
330
|
+
ssl_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
331
|
+
stickiness: Optional[pulumi.Input[_builtins.str]] = None,
|
|
332
|
+
udp_check_port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
333
|
+
udp_session_timeout: Optional[pulumi.Input[_builtins.int]] = None):
|
|
335
334
|
"""
|
|
336
335
|
Input properties used for looking up and filtering NodeBalancerConfig resources.
|
|
337
|
-
:param pulumi.Input[
|
|
338
|
-
:param pulumi.Input[
|
|
339
|
-
:param pulumi.Input[
|
|
340
|
-
:param pulumi.Input[
|
|
336
|
+
:param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
337
|
+
:param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
338
|
+
:param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
|
|
339
|
+
:param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
341
340
|
the response body of a check request, the backend is considered to be down
|
|
342
|
-
:param pulumi.Input[
|
|
343
|
-
:param pulumi.Input[
|
|
344
|
-
:param pulumi.Input[
|
|
345
|
-
:param pulumi.Input[
|
|
346
|
-
:param pulumi.Input[
|
|
341
|
+
:param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
|
|
342
|
+
:param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
343
|
+
:param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
344
|
+
:param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
345
|
+
:param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
347
346
|
:param pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated
|
|
348
347
|
periodically as checks are performed against backends.
|
|
349
|
-
:param pulumi.Input[
|
|
348
|
+
:param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
|
|
350
349
|
|
|
351
350
|
- - -
|
|
352
|
-
:param pulumi.Input[
|
|
353
|
-
:param pulumi.Input[
|
|
354
|
-
:param pulumi.Input[
|
|
355
|
-
:param pulumi.Input[
|
|
356
|
-
:param pulumi.Input[
|
|
357
|
-
:param pulumi.Input[
|
|
358
|
-
:param pulumi.Input[
|
|
359
|
-
:param pulumi.Input[
|
|
360
|
-
:param pulumi.Input[
|
|
351
|
+
:param pulumi.Input[_builtins.int] port: The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
352
|
+
:param pulumi.Input[_builtins.str] protocol: The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
353
|
+
:param pulumi.Input[_builtins.str] proxy_protocol: The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
354
|
+
:param pulumi.Input[_builtins.str] ssl_cert: The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
355
|
+
:param pulumi.Input[_builtins.str] ssl_commonname: The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
356
|
+
:param pulumi.Input[_builtins.str] ssl_fingerprint: The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
357
|
+
:param pulumi.Input[_builtins.str] ssl_key: The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
358
|
+
:param pulumi.Input[_builtins.str] stickiness: Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
359
|
+
:param pulumi.Input[_builtins.int] udp_check_port: Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
361
360
|
|
|
362
361
|
* **NOTE: This argument may not be generally available.**
|
|
363
|
-
:param pulumi.Input[
|
|
362
|
+
:param pulumi.Input[_builtins.int] udp_session_timeout: The read-only idle time in seconds after which a session that hasn’t received packets is destroyed.
|
|
364
363
|
"""
|
|
365
364
|
if algorithm is not None:
|
|
366
365
|
pulumi.set(__self__, "algorithm", algorithm)
|
|
@@ -405,45 +404,45 @@ class _NodeBalancerConfigState:
|
|
|
405
404
|
if udp_session_timeout is not None:
|
|
406
405
|
pulumi.set(__self__, "udp_session_timeout", udp_session_timeout)
|
|
407
406
|
|
|
408
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
409
408
|
@pulumi.getter
|
|
410
|
-
def algorithm(self) -> Optional[pulumi.Input[
|
|
409
|
+
def algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
411
410
|
"""
|
|
412
411
|
What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
413
412
|
"""
|
|
414
413
|
return pulumi.get(self, "algorithm")
|
|
415
414
|
|
|
416
415
|
@algorithm.setter
|
|
417
|
-
def algorithm(self, value: Optional[pulumi.Input[
|
|
416
|
+
def algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
418
417
|
pulumi.set(self, "algorithm", value)
|
|
419
418
|
|
|
420
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
421
420
|
@pulumi.getter
|
|
422
|
-
def check(self) -> Optional[pulumi.Input[
|
|
421
|
+
def check(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
423
422
|
"""
|
|
424
423
|
The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
425
424
|
"""
|
|
426
425
|
return pulumi.get(self, "check")
|
|
427
426
|
|
|
428
427
|
@check.setter
|
|
429
|
-
def check(self, value: Optional[pulumi.Input[
|
|
428
|
+
def check(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
430
429
|
pulumi.set(self, "check", value)
|
|
431
430
|
|
|
432
|
-
@property
|
|
431
|
+
@_builtins.property
|
|
433
432
|
@pulumi.getter(name="checkAttempts")
|
|
434
|
-
def check_attempts(self) -> Optional[pulumi.Input[
|
|
433
|
+
def check_attempts(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
435
434
|
"""
|
|
436
435
|
How many times to attempt a check before considering a backend to be down. (1-30)
|
|
437
436
|
"""
|
|
438
437
|
return pulumi.get(self, "check_attempts")
|
|
439
438
|
|
|
440
439
|
@check_attempts.setter
|
|
441
|
-
def check_attempts(self, value: Optional[pulumi.Input[
|
|
440
|
+
def check_attempts(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
442
441
|
pulumi.set(self, "check_attempts", value)
|
|
443
442
|
|
|
444
|
-
@property
|
|
443
|
+
@_builtins.property
|
|
445
444
|
@pulumi.getter(name="checkBody")
|
|
446
|
-
def check_body(self) -> Optional[pulumi.Input[
|
|
445
|
+
def check_body(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
447
446
|
"""
|
|
448
447
|
This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
449
448
|
the response body of a check request, the backend is considered to be down
|
|
@@ -451,70 +450,70 @@ class _NodeBalancerConfigState:
|
|
|
451
450
|
return pulumi.get(self, "check_body")
|
|
452
451
|
|
|
453
452
|
@check_body.setter
|
|
454
|
-
def check_body(self, value: Optional[pulumi.Input[
|
|
453
|
+
def check_body(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
455
454
|
pulumi.set(self, "check_body", value)
|
|
456
455
|
|
|
457
|
-
@property
|
|
456
|
+
@_builtins.property
|
|
458
457
|
@pulumi.getter(name="checkInterval")
|
|
459
|
-
def check_interval(self) -> Optional[pulumi.Input[
|
|
458
|
+
def check_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
460
459
|
"""
|
|
461
460
|
How often, in seconds, to check that backends are up and serving requests.
|
|
462
461
|
"""
|
|
463
462
|
return pulumi.get(self, "check_interval")
|
|
464
463
|
|
|
465
464
|
@check_interval.setter
|
|
466
|
-
def check_interval(self, value: Optional[pulumi.Input[
|
|
465
|
+
def check_interval(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
467
466
|
pulumi.set(self, "check_interval", value)
|
|
468
467
|
|
|
469
|
-
@property
|
|
468
|
+
@_builtins.property
|
|
470
469
|
@pulumi.getter(name="checkPassive")
|
|
471
|
-
def check_passive(self) -> Optional[pulumi.Input[
|
|
470
|
+
def check_passive(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
472
471
|
"""
|
|
473
472
|
If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
474
473
|
"""
|
|
475
474
|
return pulumi.get(self, "check_passive")
|
|
476
475
|
|
|
477
476
|
@check_passive.setter
|
|
478
|
-
def check_passive(self, value: Optional[pulumi.Input[
|
|
477
|
+
def check_passive(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
479
478
|
pulumi.set(self, "check_passive", value)
|
|
480
479
|
|
|
481
|
-
@property
|
|
480
|
+
@_builtins.property
|
|
482
481
|
@pulumi.getter(name="checkPath")
|
|
483
|
-
def check_path(self) -> Optional[pulumi.Input[
|
|
482
|
+
def check_path(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
484
483
|
"""
|
|
485
484
|
The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
486
485
|
"""
|
|
487
486
|
return pulumi.get(self, "check_path")
|
|
488
487
|
|
|
489
488
|
@check_path.setter
|
|
490
|
-
def check_path(self, value: Optional[pulumi.Input[
|
|
489
|
+
def check_path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
491
490
|
pulumi.set(self, "check_path", value)
|
|
492
491
|
|
|
493
|
-
@property
|
|
492
|
+
@_builtins.property
|
|
494
493
|
@pulumi.getter(name="checkTimeout")
|
|
495
|
-
def check_timeout(self) -> Optional[pulumi.Input[
|
|
494
|
+
def check_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
496
495
|
"""
|
|
497
496
|
How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
498
497
|
"""
|
|
499
498
|
return pulumi.get(self, "check_timeout")
|
|
500
499
|
|
|
501
500
|
@check_timeout.setter
|
|
502
|
-
def check_timeout(self, value: Optional[pulumi.Input[
|
|
501
|
+
def check_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
503
502
|
pulumi.set(self, "check_timeout", value)
|
|
504
503
|
|
|
505
|
-
@property
|
|
504
|
+
@_builtins.property
|
|
506
505
|
@pulumi.getter(name="cipherSuite")
|
|
507
|
-
def cipher_suite(self) -> Optional[pulumi.Input[
|
|
506
|
+
def cipher_suite(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
508
507
|
"""
|
|
509
508
|
What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
510
509
|
"""
|
|
511
510
|
return pulumi.get(self, "cipher_suite")
|
|
512
511
|
|
|
513
512
|
@cipher_suite.setter
|
|
514
|
-
def cipher_suite(self, value: Optional[pulumi.Input[
|
|
513
|
+
def cipher_suite(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
515
514
|
pulumi.set(self, "cipher_suite", value)
|
|
516
515
|
|
|
517
|
-
@property
|
|
516
|
+
@_builtins.property
|
|
518
517
|
@pulumi.getter(name="nodeStatuses")
|
|
519
518
|
def node_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]]]:
|
|
520
519
|
"""
|
|
@@ -527,9 +526,9 @@ class _NodeBalancerConfigState:
|
|
|
527
526
|
def node_statuses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodeBalancerConfigNodeStatusArgs']]]]):
|
|
528
527
|
pulumi.set(self, "node_statuses", value)
|
|
529
528
|
|
|
530
|
-
@property
|
|
529
|
+
@_builtins.property
|
|
531
530
|
@pulumi.getter(name="nodebalancerId")
|
|
532
|
-
def nodebalancer_id(self) -> Optional[pulumi.Input[
|
|
531
|
+
def nodebalancer_id(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
533
532
|
"""
|
|
534
533
|
The ID of the NodeBalancer to access.
|
|
535
534
|
|
|
@@ -538,108 +537,108 @@ class _NodeBalancerConfigState:
|
|
|
538
537
|
return pulumi.get(self, "nodebalancer_id")
|
|
539
538
|
|
|
540
539
|
@nodebalancer_id.setter
|
|
541
|
-
def nodebalancer_id(self, value: Optional[pulumi.Input[
|
|
540
|
+
def nodebalancer_id(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
542
541
|
pulumi.set(self, "nodebalancer_id", value)
|
|
543
542
|
|
|
544
|
-
@property
|
|
543
|
+
@_builtins.property
|
|
545
544
|
@pulumi.getter
|
|
546
|
-
def port(self) -> Optional[pulumi.Input[
|
|
545
|
+
def port(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
547
546
|
"""
|
|
548
547
|
The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
549
548
|
"""
|
|
550
549
|
return pulumi.get(self, "port")
|
|
551
550
|
|
|
552
551
|
@port.setter
|
|
553
|
-
def port(self, value: Optional[pulumi.Input[
|
|
552
|
+
def port(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
554
553
|
pulumi.set(self, "port", value)
|
|
555
554
|
|
|
556
|
-
@property
|
|
555
|
+
@_builtins.property
|
|
557
556
|
@pulumi.getter
|
|
558
|
-
def protocol(self) -> Optional[pulumi.Input[
|
|
557
|
+
def protocol(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
559
558
|
"""
|
|
560
559
|
The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
561
560
|
"""
|
|
562
561
|
return pulumi.get(self, "protocol")
|
|
563
562
|
|
|
564
563
|
@protocol.setter
|
|
565
|
-
def protocol(self, value: Optional[pulumi.Input[
|
|
564
|
+
def protocol(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
566
565
|
pulumi.set(self, "protocol", value)
|
|
567
566
|
|
|
568
|
-
@property
|
|
567
|
+
@_builtins.property
|
|
569
568
|
@pulumi.getter(name="proxyProtocol")
|
|
570
|
-
def proxy_protocol(self) -> Optional[pulumi.Input[
|
|
569
|
+
def proxy_protocol(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
571
570
|
"""
|
|
572
571
|
The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
573
572
|
"""
|
|
574
573
|
return pulumi.get(self, "proxy_protocol")
|
|
575
574
|
|
|
576
575
|
@proxy_protocol.setter
|
|
577
|
-
def proxy_protocol(self, value: Optional[pulumi.Input[
|
|
576
|
+
def proxy_protocol(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
578
577
|
pulumi.set(self, "proxy_protocol", value)
|
|
579
578
|
|
|
580
|
-
@property
|
|
579
|
+
@_builtins.property
|
|
581
580
|
@pulumi.getter(name="sslCert")
|
|
582
|
-
def ssl_cert(self) -> Optional[pulumi.Input[
|
|
581
|
+
def ssl_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
583
582
|
"""
|
|
584
583
|
The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
585
584
|
"""
|
|
586
585
|
return pulumi.get(self, "ssl_cert")
|
|
587
586
|
|
|
588
587
|
@ssl_cert.setter
|
|
589
|
-
def ssl_cert(self, value: Optional[pulumi.Input[
|
|
588
|
+
def ssl_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
590
589
|
pulumi.set(self, "ssl_cert", value)
|
|
591
590
|
|
|
592
|
-
@property
|
|
591
|
+
@_builtins.property
|
|
593
592
|
@pulumi.getter(name="sslCommonname")
|
|
594
|
-
def ssl_commonname(self) -> Optional[pulumi.Input[
|
|
593
|
+
def ssl_commonname(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
595
594
|
"""
|
|
596
595
|
The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
597
596
|
"""
|
|
598
597
|
return pulumi.get(self, "ssl_commonname")
|
|
599
598
|
|
|
600
599
|
@ssl_commonname.setter
|
|
601
|
-
def ssl_commonname(self, value: Optional[pulumi.Input[
|
|
600
|
+
def ssl_commonname(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
602
601
|
pulumi.set(self, "ssl_commonname", value)
|
|
603
602
|
|
|
604
|
-
@property
|
|
603
|
+
@_builtins.property
|
|
605
604
|
@pulumi.getter(name="sslFingerprint")
|
|
606
|
-
def ssl_fingerprint(self) -> Optional[pulumi.Input[
|
|
605
|
+
def ssl_fingerprint(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
607
606
|
"""
|
|
608
607
|
The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
609
608
|
"""
|
|
610
609
|
return pulumi.get(self, "ssl_fingerprint")
|
|
611
610
|
|
|
612
611
|
@ssl_fingerprint.setter
|
|
613
|
-
def ssl_fingerprint(self, value: Optional[pulumi.Input[
|
|
612
|
+
def ssl_fingerprint(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
614
613
|
pulumi.set(self, "ssl_fingerprint", value)
|
|
615
614
|
|
|
616
|
-
@property
|
|
615
|
+
@_builtins.property
|
|
617
616
|
@pulumi.getter(name="sslKey")
|
|
618
|
-
def ssl_key(self) -> Optional[pulumi.Input[
|
|
617
|
+
def ssl_key(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
619
618
|
"""
|
|
620
619
|
The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
621
620
|
"""
|
|
622
621
|
return pulumi.get(self, "ssl_key")
|
|
623
622
|
|
|
624
623
|
@ssl_key.setter
|
|
625
|
-
def ssl_key(self, value: Optional[pulumi.Input[
|
|
624
|
+
def ssl_key(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
626
625
|
pulumi.set(self, "ssl_key", value)
|
|
627
626
|
|
|
628
|
-
@property
|
|
627
|
+
@_builtins.property
|
|
629
628
|
@pulumi.getter
|
|
630
|
-
def stickiness(self) -> Optional[pulumi.Input[
|
|
629
|
+
def stickiness(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
631
630
|
"""
|
|
632
631
|
Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
633
632
|
"""
|
|
634
633
|
return pulumi.get(self, "stickiness")
|
|
635
634
|
|
|
636
635
|
@stickiness.setter
|
|
637
|
-
def stickiness(self, value: Optional[pulumi.Input[
|
|
636
|
+
def stickiness(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
638
637
|
pulumi.set(self, "stickiness", value)
|
|
639
638
|
|
|
640
|
-
@property
|
|
639
|
+
@_builtins.property
|
|
641
640
|
@pulumi.getter(name="udpCheckPort")
|
|
642
|
-
def udp_check_port(self) -> Optional[pulumi.Input[
|
|
641
|
+
def udp_check_port(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
643
642
|
"""
|
|
644
643
|
Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
645
644
|
|
|
@@ -648,19 +647,19 @@ class _NodeBalancerConfigState:
|
|
|
648
647
|
return pulumi.get(self, "udp_check_port")
|
|
649
648
|
|
|
650
649
|
@udp_check_port.setter
|
|
651
|
-
def udp_check_port(self, value: Optional[pulumi.Input[
|
|
650
|
+
def udp_check_port(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
652
651
|
pulumi.set(self, "udp_check_port", value)
|
|
653
652
|
|
|
654
|
-
@property
|
|
653
|
+
@_builtins.property
|
|
655
654
|
@pulumi.getter(name="udpSessionTimeout")
|
|
656
|
-
def udp_session_timeout(self) -> Optional[pulumi.Input[
|
|
655
|
+
def udp_session_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
657
656
|
"""
|
|
658
657
|
The read-only idle time in seconds after which a session that hasn’t received packets is destroyed.
|
|
659
658
|
"""
|
|
660
659
|
return pulumi.get(self, "udp_session_timeout")
|
|
661
660
|
|
|
662
661
|
@udp_session_timeout.setter
|
|
663
|
-
def udp_session_timeout(self, value: Optional[pulumi.Input[
|
|
662
|
+
def udp_session_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
664
663
|
pulumi.set(self, "udp_session_timeout", value)
|
|
665
664
|
|
|
666
665
|
|
|
@@ -670,23 +669,23 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
670
669
|
def __init__(__self__,
|
|
671
670
|
resource_name: str,
|
|
672
671
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
673
|
-
algorithm: Optional[pulumi.Input[
|
|
674
|
-
check: Optional[pulumi.Input[
|
|
675
|
-
check_attempts: Optional[pulumi.Input[
|
|
676
|
-
check_body: Optional[pulumi.Input[
|
|
677
|
-
check_interval: Optional[pulumi.Input[
|
|
678
|
-
check_passive: Optional[pulumi.Input[
|
|
679
|
-
check_path: Optional[pulumi.Input[
|
|
680
|
-
check_timeout: Optional[pulumi.Input[
|
|
681
|
-
cipher_suite: Optional[pulumi.Input[
|
|
682
|
-
nodebalancer_id: Optional[pulumi.Input[
|
|
683
|
-
port: Optional[pulumi.Input[
|
|
684
|
-
protocol: Optional[pulumi.Input[
|
|
685
|
-
proxy_protocol: Optional[pulumi.Input[
|
|
686
|
-
ssl_cert: Optional[pulumi.Input[
|
|
687
|
-
ssl_key: Optional[pulumi.Input[
|
|
688
|
-
stickiness: Optional[pulumi.Input[
|
|
689
|
-
udp_check_port: Optional[pulumi.Input[
|
|
672
|
+
algorithm: Optional[pulumi.Input[_builtins.str]] = None,
|
|
673
|
+
check: Optional[pulumi.Input[_builtins.str]] = None,
|
|
674
|
+
check_attempts: Optional[pulumi.Input[_builtins.int]] = None,
|
|
675
|
+
check_body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
676
|
+
check_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
677
|
+
check_passive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
678
|
+
check_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
679
|
+
check_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
680
|
+
cipher_suite: Optional[pulumi.Input[_builtins.str]] = None,
|
|
681
|
+
nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
682
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
683
|
+
protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
684
|
+
proxy_protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
685
|
+
ssl_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
686
|
+
ssl_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
687
|
+
stickiness: Optional[pulumi.Input[_builtins.str]] = None,
|
|
688
|
+
udp_check_port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
690
689
|
__props__=None):
|
|
691
690
|
"""
|
|
692
691
|
Provides a Linode NodeBalancer Config resource. This can be used to create, modify, and delete Linodes NodeBalancer Configs.
|
|
@@ -727,26 +726,26 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
727
726
|
|
|
728
727
|
:param str resource_name: The name of the resource.
|
|
729
728
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
730
|
-
:param pulumi.Input[
|
|
731
|
-
:param pulumi.Input[
|
|
732
|
-
:param pulumi.Input[
|
|
733
|
-
:param pulumi.Input[
|
|
729
|
+
:param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
730
|
+
:param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
731
|
+
:param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
|
|
732
|
+
:param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
734
733
|
the response body of a check request, the backend is considered to be down
|
|
735
|
-
:param pulumi.Input[
|
|
736
|
-
:param pulumi.Input[
|
|
737
|
-
:param pulumi.Input[
|
|
738
|
-
:param pulumi.Input[
|
|
739
|
-
:param pulumi.Input[
|
|
740
|
-
:param pulumi.Input[
|
|
734
|
+
:param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
|
|
735
|
+
:param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
736
|
+
:param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
737
|
+
:param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
738
|
+
:param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
739
|
+
:param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
|
|
741
740
|
|
|
742
741
|
- - -
|
|
743
|
-
:param pulumi.Input[
|
|
744
|
-
:param pulumi.Input[
|
|
745
|
-
:param pulumi.Input[
|
|
746
|
-
:param pulumi.Input[
|
|
747
|
-
:param pulumi.Input[
|
|
748
|
-
:param pulumi.Input[
|
|
749
|
-
:param pulumi.Input[
|
|
742
|
+
:param pulumi.Input[_builtins.int] port: The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
743
|
+
:param pulumi.Input[_builtins.str] protocol: The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
744
|
+
:param pulumi.Input[_builtins.str] proxy_protocol: The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
745
|
+
:param pulumi.Input[_builtins.str] ssl_cert: The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
746
|
+
:param pulumi.Input[_builtins.str] ssl_key: The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
747
|
+
:param pulumi.Input[_builtins.str] stickiness: Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
748
|
+
:param pulumi.Input[_builtins.int] udp_check_port: Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
750
749
|
|
|
751
750
|
* **NOTE: This argument may not be generally available.**
|
|
752
751
|
"""
|
|
@@ -808,23 +807,23 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
808
807
|
def _internal_init(__self__,
|
|
809
808
|
resource_name: str,
|
|
810
809
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
811
|
-
algorithm: Optional[pulumi.Input[
|
|
812
|
-
check: Optional[pulumi.Input[
|
|
813
|
-
check_attempts: Optional[pulumi.Input[
|
|
814
|
-
check_body: Optional[pulumi.Input[
|
|
815
|
-
check_interval: Optional[pulumi.Input[
|
|
816
|
-
check_passive: Optional[pulumi.Input[
|
|
817
|
-
check_path: Optional[pulumi.Input[
|
|
818
|
-
check_timeout: Optional[pulumi.Input[
|
|
819
|
-
cipher_suite: Optional[pulumi.Input[
|
|
820
|
-
nodebalancer_id: Optional[pulumi.Input[
|
|
821
|
-
port: Optional[pulumi.Input[
|
|
822
|
-
protocol: Optional[pulumi.Input[
|
|
823
|
-
proxy_protocol: Optional[pulumi.Input[
|
|
824
|
-
ssl_cert: Optional[pulumi.Input[
|
|
825
|
-
ssl_key: Optional[pulumi.Input[
|
|
826
|
-
stickiness: Optional[pulumi.Input[
|
|
827
|
-
udp_check_port: Optional[pulumi.Input[
|
|
810
|
+
algorithm: Optional[pulumi.Input[_builtins.str]] = None,
|
|
811
|
+
check: Optional[pulumi.Input[_builtins.str]] = None,
|
|
812
|
+
check_attempts: Optional[pulumi.Input[_builtins.int]] = None,
|
|
813
|
+
check_body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
814
|
+
check_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
815
|
+
check_passive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
816
|
+
check_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
817
|
+
check_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
818
|
+
cipher_suite: Optional[pulumi.Input[_builtins.str]] = None,
|
|
819
|
+
nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
820
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
821
|
+
protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
822
|
+
proxy_protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
823
|
+
ssl_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
824
|
+
ssl_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
825
|
+
stickiness: Optional[pulumi.Input[_builtins.str]] = None,
|
|
826
|
+
udp_check_port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
828
827
|
__props__=None):
|
|
829
828
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
830
829
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -869,27 +868,27 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
869
868
|
def get(resource_name: str,
|
|
870
869
|
id: pulumi.Input[str],
|
|
871
870
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
872
|
-
algorithm: Optional[pulumi.Input[
|
|
873
|
-
check: Optional[pulumi.Input[
|
|
874
|
-
check_attempts: Optional[pulumi.Input[
|
|
875
|
-
check_body: Optional[pulumi.Input[
|
|
876
|
-
check_interval: Optional[pulumi.Input[
|
|
877
|
-
check_passive: Optional[pulumi.Input[
|
|
878
|
-
check_path: Optional[pulumi.Input[
|
|
879
|
-
check_timeout: Optional[pulumi.Input[
|
|
880
|
-
cipher_suite: Optional[pulumi.Input[
|
|
871
|
+
algorithm: Optional[pulumi.Input[_builtins.str]] = None,
|
|
872
|
+
check: Optional[pulumi.Input[_builtins.str]] = None,
|
|
873
|
+
check_attempts: Optional[pulumi.Input[_builtins.int]] = None,
|
|
874
|
+
check_body: Optional[pulumi.Input[_builtins.str]] = None,
|
|
875
|
+
check_interval: Optional[pulumi.Input[_builtins.int]] = None,
|
|
876
|
+
check_passive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
877
|
+
check_path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
878
|
+
check_timeout: Optional[pulumi.Input[_builtins.int]] = None,
|
|
879
|
+
cipher_suite: Optional[pulumi.Input[_builtins.str]] = None,
|
|
881
880
|
node_statuses: Optional[pulumi.Input[Sequence[pulumi.Input[Union['NodeBalancerConfigNodeStatusArgs', 'NodeBalancerConfigNodeStatusArgsDict']]]]] = None,
|
|
882
|
-
nodebalancer_id: Optional[pulumi.Input[
|
|
883
|
-
port: Optional[pulumi.Input[
|
|
884
|
-
protocol: Optional[pulumi.Input[
|
|
885
|
-
proxy_protocol: Optional[pulumi.Input[
|
|
886
|
-
ssl_cert: Optional[pulumi.Input[
|
|
887
|
-
ssl_commonname: Optional[pulumi.Input[
|
|
888
|
-
ssl_fingerprint: Optional[pulumi.Input[
|
|
889
|
-
ssl_key: Optional[pulumi.Input[
|
|
890
|
-
stickiness: Optional[pulumi.Input[
|
|
891
|
-
udp_check_port: Optional[pulumi.Input[
|
|
892
|
-
udp_session_timeout: Optional[pulumi.Input[
|
|
881
|
+
nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
882
|
+
port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
883
|
+
protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
884
|
+
proxy_protocol: Optional[pulumi.Input[_builtins.str]] = None,
|
|
885
|
+
ssl_cert: Optional[pulumi.Input[_builtins.str]] = None,
|
|
886
|
+
ssl_commonname: Optional[pulumi.Input[_builtins.str]] = None,
|
|
887
|
+
ssl_fingerprint: Optional[pulumi.Input[_builtins.str]] = None,
|
|
888
|
+
ssl_key: Optional[pulumi.Input[_builtins.str]] = None,
|
|
889
|
+
stickiness: Optional[pulumi.Input[_builtins.str]] = None,
|
|
890
|
+
udp_check_port: Optional[pulumi.Input[_builtins.int]] = None,
|
|
891
|
+
udp_session_timeout: Optional[pulumi.Input[_builtins.int]] = None) -> 'NodeBalancerConfig':
|
|
893
892
|
"""
|
|
894
893
|
Get an existing NodeBalancerConfig resource's state with the given name, id, and optional extra
|
|
895
894
|
properties used to qualify the lookup.
|
|
@@ -897,33 +896,33 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
897
896
|
:param str resource_name: The unique name of the resulting resource.
|
|
898
897
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
899
898
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
900
|
-
:param pulumi.Input[
|
|
901
|
-
:param pulumi.Input[
|
|
902
|
-
:param pulumi.Input[
|
|
903
|
-
:param pulumi.Input[
|
|
899
|
+
:param pulumi.Input[_builtins.str] algorithm: What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
900
|
+
:param pulumi.Input[_builtins.str] check: The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
901
|
+
:param pulumi.Input[_builtins.int] check_attempts: How many times to attempt a check before considering a backend to be down. (1-30)
|
|
902
|
+
:param pulumi.Input[_builtins.str] check_body: This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
904
903
|
the response body of a check request, the backend is considered to be down
|
|
905
|
-
:param pulumi.Input[
|
|
906
|
-
:param pulumi.Input[
|
|
907
|
-
:param pulumi.Input[
|
|
908
|
-
:param pulumi.Input[
|
|
909
|
-
:param pulumi.Input[
|
|
904
|
+
:param pulumi.Input[_builtins.int] check_interval: How often, in seconds, to check that backends are up and serving requests.
|
|
905
|
+
:param pulumi.Input[_builtins.bool] check_passive: If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
906
|
+
:param pulumi.Input[_builtins.str] check_path: The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
907
|
+
:param pulumi.Input[_builtins.int] check_timeout: How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
908
|
+
:param pulumi.Input[_builtins.str] cipher_suite: What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
910
909
|
:param pulumi.Input[Sequence[pulumi.Input[Union['NodeBalancerConfigNodeStatusArgs', 'NodeBalancerConfigNodeStatusArgsDict']]]] node_statuses: A structure containing information about the health of the backends for this port. This information is updated
|
|
911
910
|
periodically as checks are performed against backends.
|
|
912
|
-
:param pulumi.Input[
|
|
911
|
+
:param pulumi.Input[_builtins.int] nodebalancer_id: The ID of the NodeBalancer to access.
|
|
913
912
|
|
|
914
913
|
- - -
|
|
915
|
-
:param pulumi.Input[
|
|
916
|
-
:param pulumi.Input[
|
|
917
|
-
:param pulumi.Input[
|
|
918
|
-
:param pulumi.Input[
|
|
919
|
-
:param pulumi.Input[
|
|
920
|
-
:param pulumi.Input[
|
|
921
|
-
:param pulumi.Input[
|
|
922
|
-
:param pulumi.Input[
|
|
923
|
-
:param pulumi.Input[
|
|
914
|
+
:param pulumi.Input[_builtins.int] port: The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
915
|
+
:param pulumi.Input[_builtins.str] protocol: The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
916
|
+
:param pulumi.Input[_builtins.str] proxy_protocol: The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
917
|
+
:param pulumi.Input[_builtins.str] ssl_cert: The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
918
|
+
:param pulumi.Input[_builtins.str] ssl_commonname: The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
919
|
+
:param pulumi.Input[_builtins.str] ssl_fingerprint: The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
920
|
+
:param pulumi.Input[_builtins.str] ssl_key: The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
921
|
+
:param pulumi.Input[_builtins.str] stickiness: Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
922
|
+
:param pulumi.Input[_builtins.int] udp_check_port: Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
924
923
|
|
|
925
924
|
* **NOTE: This argument may not be generally available.**
|
|
926
|
-
:param pulumi.Input[
|
|
925
|
+
:param pulumi.Input[_builtins.int] udp_session_timeout: The read-only idle time in seconds after which a session that hasn’t received packets is destroyed.
|
|
927
926
|
"""
|
|
928
927
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
929
928
|
|
|
@@ -952,80 +951,80 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
952
951
|
__props__.__dict__["udp_session_timeout"] = udp_session_timeout
|
|
953
952
|
return NodeBalancerConfig(resource_name, opts=opts, __props__=__props__)
|
|
954
953
|
|
|
955
|
-
@property
|
|
954
|
+
@_builtins.property
|
|
956
955
|
@pulumi.getter
|
|
957
|
-
def algorithm(self) -> pulumi.Output[
|
|
956
|
+
def algorithm(self) -> pulumi.Output[_builtins.str]:
|
|
958
957
|
"""
|
|
959
958
|
What algorithm this NodeBalancer should use for routing traffic to backends. (`roundrobin`, `leastconn`, `source`)
|
|
960
959
|
"""
|
|
961
960
|
return pulumi.get(self, "algorithm")
|
|
962
961
|
|
|
963
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
964
963
|
@pulumi.getter
|
|
965
|
-
def check(self) -> pulumi.Output[
|
|
964
|
+
def check(self) -> pulumi.Output[_builtins.str]:
|
|
966
965
|
"""
|
|
967
966
|
The type of check to perform against backends to ensure they are serving requests. This is used to determine if backends are up or down. If none no check is performed. connection requires only a connection to the backend to succeed. http and http_body rely on the backend serving HTTP, and that the response returned matches what is expected. (`none`, `connection`, `http`, `http_body`)
|
|
968
967
|
"""
|
|
969
968
|
return pulumi.get(self, "check")
|
|
970
969
|
|
|
971
|
-
@property
|
|
970
|
+
@_builtins.property
|
|
972
971
|
@pulumi.getter(name="checkAttempts")
|
|
973
|
-
def check_attempts(self) -> pulumi.Output[
|
|
972
|
+
def check_attempts(self) -> pulumi.Output[_builtins.int]:
|
|
974
973
|
"""
|
|
975
974
|
How many times to attempt a check before considering a backend to be down. (1-30)
|
|
976
975
|
"""
|
|
977
976
|
return pulumi.get(self, "check_attempts")
|
|
978
977
|
|
|
979
|
-
@property
|
|
978
|
+
@_builtins.property
|
|
980
979
|
@pulumi.getter(name="checkBody")
|
|
981
|
-
def check_body(self) -> pulumi.Output[
|
|
980
|
+
def check_body(self) -> pulumi.Output[_builtins.str]:
|
|
982
981
|
"""
|
|
983
982
|
This value must be present in the response body of the check in order for it to pass. If this value is not present in
|
|
984
983
|
the response body of a check request, the backend is considered to be down
|
|
985
984
|
"""
|
|
986
985
|
return pulumi.get(self, "check_body")
|
|
987
986
|
|
|
988
|
-
@property
|
|
987
|
+
@_builtins.property
|
|
989
988
|
@pulumi.getter(name="checkInterval")
|
|
990
|
-
def check_interval(self) -> pulumi.Output[
|
|
989
|
+
def check_interval(self) -> pulumi.Output[_builtins.int]:
|
|
991
990
|
"""
|
|
992
991
|
How often, in seconds, to check that backends are up and serving requests.
|
|
993
992
|
"""
|
|
994
993
|
return pulumi.get(self, "check_interval")
|
|
995
994
|
|
|
996
|
-
@property
|
|
995
|
+
@_builtins.property
|
|
997
996
|
@pulumi.getter(name="checkPassive")
|
|
998
|
-
def check_passive(self) -> pulumi.Output[
|
|
997
|
+
def check_passive(self) -> pulumi.Output[_builtins.bool]:
|
|
999
998
|
"""
|
|
1000
999
|
If true, any response from this backend with a 5xx status code will be enough for it to be considered unhealthy and taken out of rotation.
|
|
1001
1000
|
"""
|
|
1002
1001
|
return pulumi.get(self, "check_passive")
|
|
1003
1002
|
|
|
1004
|
-
@property
|
|
1003
|
+
@_builtins.property
|
|
1005
1004
|
@pulumi.getter(name="checkPath")
|
|
1006
|
-
def check_path(self) -> pulumi.Output[
|
|
1005
|
+
def check_path(self) -> pulumi.Output[_builtins.str]:
|
|
1007
1006
|
"""
|
|
1008
1007
|
The URL path to check on each backend. If the backend does not respond to this request it is considered to be down.
|
|
1009
1008
|
"""
|
|
1010
1009
|
return pulumi.get(self, "check_path")
|
|
1011
1010
|
|
|
1012
|
-
@property
|
|
1011
|
+
@_builtins.property
|
|
1013
1012
|
@pulumi.getter(name="checkTimeout")
|
|
1014
|
-
def check_timeout(self) -> pulumi.Output[
|
|
1013
|
+
def check_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
1015
1014
|
"""
|
|
1016
1015
|
How long, in seconds, to wait for a check attempt before considering it failed. (1-30)
|
|
1017
1016
|
"""
|
|
1018
1017
|
return pulumi.get(self, "check_timeout")
|
|
1019
1018
|
|
|
1020
|
-
@property
|
|
1019
|
+
@_builtins.property
|
|
1021
1020
|
@pulumi.getter(name="cipherSuite")
|
|
1022
|
-
def cipher_suite(self) -> pulumi.Output[
|
|
1021
|
+
def cipher_suite(self) -> pulumi.Output[_builtins.str]:
|
|
1023
1022
|
"""
|
|
1024
1023
|
What ciphers to use for SSL connections served by this NodeBalancer. `legacy` is considered insecure and should only be used if necessary.
|
|
1025
1024
|
"""
|
|
1026
1025
|
return pulumi.get(self, "cipher_suite")
|
|
1027
1026
|
|
|
1028
|
-
@property
|
|
1027
|
+
@_builtins.property
|
|
1029
1028
|
@pulumi.getter(name="nodeStatuses")
|
|
1030
1029
|
def node_statuses(self) -> pulumi.Output[Sequence['outputs.NodeBalancerConfigNodeStatus']]:
|
|
1031
1030
|
"""
|
|
@@ -1034,9 +1033,9 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
1034
1033
|
"""
|
|
1035
1034
|
return pulumi.get(self, "node_statuses")
|
|
1036
1035
|
|
|
1037
|
-
@property
|
|
1036
|
+
@_builtins.property
|
|
1038
1037
|
@pulumi.getter(name="nodebalancerId")
|
|
1039
|
-
def nodebalancer_id(self) -> pulumi.Output[
|
|
1038
|
+
def nodebalancer_id(self) -> pulumi.Output[_builtins.int]:
|
|
1040
1039
|
"""
|
|
1041
1040
|
The ID of the NodeBalancer to access.
|
|
1042
1041
|
|
|
@@ -1044,73 +1043,73 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
1044
1043
|
"""
|
|
1045
1044
|
return pulumi.get(self, "nodebalancer_id")
|
|
1046
1045
|
|
|
1047
|
-
@property
|
|
1046
|
+
@_builtins.property
|
|
1048
1047
|
@pulumi.getter
|
|
1049
|
-
def port(self) -> pulumi.Output[
|
|
1048
|
+
def port(self) -> pulumi.Output[_builtins.int]:
|
|
1050
1049
|
"""
|
|
1051
1050
|
The TCP port this Config is for. These values must be unique across configs on a single NodeBalancer (you can't have two configs for port 80, for example). While some ports imply some protocols, no enforcement is done and you may configure your NodeBalancer however is useful to you. For example, while port 443 is generally used for HTTPS, you do not need SSL configured to have a NodeBalancer listening on port 443. (Defaults to 80)
|
|
1052
1051
|
"""
|
|
1053
1052
|
return pulumi.get(self, "port")
|
|
1054
1053
|
|
|
1055
|
-
@property
|
|
1054
|
+
@_builtins.property
|
|
1056
1055
|
@pulumi.getter
|
|
1057
|
-
def protocol(self) -> pulumi.Output[
|
|
1056
|
+
def protocol(self) -> pulumi.Output[_builtins.str]:
|
|
1058
1057
|
"""
|
|
1059
1058
|
The protocol this port is configured to serve. If this is set to https you must include an ssl_cert and an ssl_key. (`http`, `https`, `tcp`) (Defaults to `http`)
|
|
1060
1059
|
"""
|
|
1061
1060
|
return pulumi.get(self, "protocol")
|
|
1062
1061
|
|
|
1063
|
-
@property
|
|
1062
|
+
@_builtins.property
|
|
1064
1063
|
@pulumi.getter(name="proxyProtocol")
|
|
1065
|
-
def proxy_protocol(self) -> pulumi.Output[
|
|
1064
|
+
def proxy_protocol(self) -> pulumi.Output[_builtins.str]:
|
|
1066
1065
|
"""
|
|
1067
1066
|
The version of ProxyProtocol to use for the underlying NodeBalancer. This requires protocol to be `tcp`. (`none`, `v1`, `v2`) (Defaults to `none`)
|
|
1068
1067
|
"""
|
|
1069
1068
|
return pulumi.get(self, "proxy_protocol")
|
|
1070
1069
|
|
|
1071
|
-
@property
|
|
1070
|
+
@_builtins.property
|
|
1072
1071
|
@pulumi.getter(name="sslCert")
|
|
1073
|
-
def ssl_cert(self) -> pulumi.Output[Optional[
|
|
1072
|
+
def ssl_cert(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1074
1073
|
"""
|
|
1075
1074
|
The certificate this port is serving. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
1076
1075
|
"""
|
|
1077
1076
|
return pulumi.get(self, "ssl_cert")
|
|
1078
1077
|
|
|
1079
|
-
@property
|
|
1078
|
+
@_builtins.property
|
|
1080
1079
|
@pulumi.getter(name="sslCommonname")
|
|
1081
|
-
def ssl_commonname(self) -> pulumi.Output[
|
|
1080
|
+
def ssl_commonname(self) -> pulumi.Output[_builtins.str]:
|
|
1082
1081
|
"""
|
|
1083
1082
|
The read-only common name automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
1084
1083
|
"""
|
|
1085
1084
|
return pulumi.get(self, "ssl_commonname")
|
|
1086
1085
|
|
|
1087
|
-
@property
|
|
1086
|
+
@_builtins.property
|
|
1088
1087
|
@pulumi.getter(name="sslFingerprint")
|
|
1089
|
-
def ssl_fingerprint(self) -> pulumi.Output[
|
|
1088
|
+
def ssl_fingerprint(self) -> pulumi.Output[_builtins.str]:
|
|
1090
1089
|
"""
|
|
1091
1090
|
The read-only fingerprint automatically derived from the SSL certificate assigned to this NodeBalancerConfig. Please refer to this field to verify that the appropriate certificate is assigned to your NodeBalancerConfig.
|
|
1092
1091
|
"""
|
|
1093
1092
|
return pulumi.get(self, "ssl_fingerprint")
|
|
1094
1093
|
|
|
1095
|
-
@property
|
|
1094
|
+
@_builtins.property
|
|
1096
1095
|
@pulumi.getter(name="sslKey")
|
|
1097
|
-
def ssl_key(self) -> pulumi.Output[Optional[
|
|
1096
|
+
def ssl_key(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1098
1097
|
"""
|
|
1099
1098
|
The private key corresponding to this port's certificate. This is not returned. If set, this field will come back as `<REDACTED>`. Please use the ssl_commonname and ssl_fingerprint to identify the certificate.
|
|
1100
1099
|
"""
|
|
1101
1100
|
return pulumi.get(self, "ssl_key")
|
|
1102
1101
|
|
|
1103
|
-
@property
|
|
1102
|
+
@_builtins.property
|
|
1104
1103
|
@pulumi.getter
|
|
1105
|
-
def stickiness(self) -> pulumi.Output[
|
|
1104
|
+
def stickiness(self) -> pulumi.Output[_builtins.str]:
|
|
1106
1105
|
"""
|
|
1107
1106
|
Controls how session stickiness is handled on this port. (`none`, `table`, `http_cookie`)
|
|
1108
1107
|
"""
|
|
1109
1108
|
return pulumi.get(self, "stickiness")
|
|
1110
1109
|
|
|
1111
|
-
@property
|
|
1110
|
+
@_builtins.property
|
|
1112
1111
|
@pulumi.getter(name="udpCheckPort")
|
|
1113
|
-
def udp_check_port(self) -> pulumi.Output[
|
|
1112
|
+
def udp_check_port(self) -> pulumi.Output[_builtins.int]:
|
|
1114
1113
|
"""
|
|
1115
1114
|
Specifies the port on the backend node used for active health checks, which may differ from the port serving traffic. Defaults to 80.
|
|
1116
1115
|
|
|
@@ -1118,9 +1117,9 @@ class NodeBalancerConfig(pulumi.CustomResource):
|
|
|
1118
1117
|
"""
|
|
1119
1118
|
return pulumi.get(self, "udp_check_port")
|
|
1120
1119
|
|
|
1121
|
-
@property
|
|
1120
|
+
@_builtins.property
|
|
1122
1121
|
@pulumi.getter(name="udpSessionTimeout")
|
|
1123
|
-
def udp_session_timeout(self) -> pulumi.Output[
|
|
1122
|
+
def udp_session_timeout(self) -> pulumi.Output[_builtins.int]:
|
|
1124
1123
|
"""
|
|
1125
1124
|
The read-only idle time in seconds after which a session that hasn’t received packets is destroyed.
|
|
1126
1125
|
"""
|