pulumi-digitalocean 4.50.0a1753335988__py3-none-any.whl → 4.50.0a1753508712__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-digitalocean might be problematic. Click here for more details.
- pulumi_digitalocean/__init__.py +1 -1
- pulumi_digitalocean/_enums.py +9 -9
- pulumi_digitalocean/_inputs.py +5705 -5706
- pulumi_digitalocean/app.py +87 -88
- pulumi_digitalocean/cdn.py +104 -105
- pulumi_digitalocean/certificate.py +137 -138
- pulumi_digitalocean/config/__init__.py +1 -1
- pulumi_digitalocean/config/__init__.pyi +1 -2
- pulumi_digitalocean/config/vars.py +10 -11
- pulumi_digitalocean/container_registry.py +88 -89
- pulumi_digitalocean/container_registry_docker_credentials.py +70 -71
- pulumi_digitalocean/custom_image.py +175 -176
- pulumi_digitalocean/database_cluster.py +346 -347
- pulumi_digitalocean/database_connection_pool.py +157 -158
- pulumi_digitalocean/database_db.py +35 -36
- pulumi_digitalocean/database_firewall.py +21 -22
- pulumi_digitalocean/database_kafka_config.py +307 -308
- pulumi_digitalocean/database_kafka_topic.py +81 -82
- pulumi_digitalocean/database_mongodb_config.py +103 -104
- pulumi_digitalocean/database_mysql_config.py +477 -478
- pulumi_digitalocean/database_opensearch_config.py +664 -665
- pulumi_digitalocean/database_postgresql_config.py +857 -858
- pulumi_digitalocean/database_redis_config.py +205 -206
- pulumi_digitalocean/database_replica.py +197 -198
- pulumi_digitalocean/database_user.py +91 -92
- pulumi_digitalocean/dns_record.py +180 -181
- pulumi_digitalocean/domain.py +53 -54
- pulumi_digitalocean/droplet.py +388 -389
- pulumi_digitalocean/droplet_autoscale.py +53 -54
- pulumi_digitalocean/droplet_snapshot.py +71 -72
- pulumi_digitalocean/firewall.py +78 -79
- pulumi_digitalocean/floating_ip.py +61 -62
- pulumi_digitalocean/floating_ip_assignment.py +35 -36
- pulumi_digitalocean/genai_agent.py +452 -453
- pulumi_digitalocean/get_account.py +17 -18
- pulumi_digitalocean/get_app.py +27 -28
- pulumi_digitalocean/get_certificate.py +21 -22
- pulumi_digitalocean/get_container_registry.py +21 -22
- pulumi_digitalocean/get_database_ca.py +11 -12
- pulumi_digitalocean/get_database_cluster.py +60 -61
- pulumi_digitalocean/get_database_connection_pool.py +35 -36
- pulumi_digitalocean/get_database_replica.py +45 -46
- pulumi_digitalocean/get_database_user.py +26 -27
- pulumi_digitalocean/get_domain.py +15 -16
- pulumi_digitalocean/get_domains.py +6 -7
- pulumi_digitalocean/get_droplet.py +71 -72
- pulumi_digitalocean/get_droplet_autoscale.py +22 -23
- pulumi_digitalocean/get_droplet_snapshot.py +37 -38
- pulumi_digitalocean/get_droplets.py +12 -13
- pulumi_digitalocean/get_firewall.py +30 -31
- pulumi_digitalocean/get_floating_ip.py +15 -16
- pulumi_digitalocean/get_genai_agent.py +89 -90
- pulumi_digitalocean/get_genai_agents.py +10 -11
- pulumi_digitalocean/get_image.py +49 -50
- pulumi_digitalocean/get_images.py +6 -7
- pulumi_digitalocean/get_kubernetes_cluster.py +53 -54
- pulumi_digitalocean/get_kubernetes_versions.py +13 -14
- pulumi_digitalocean/get_load_balancer.py +59 -60
- pulumi_digitalocean/get_partner_attachment.py +30 -31
- pulumi_digitalocean/get_partner_attachment_service_key.py +13 -14
- pulumi_digitalocean/get_project.py +31 -32
- pulumi_digitalocean/get_projects.py +6 -7
- pulumi_digitalocean/get_record.py +31 -32
- pulumi_digitalocean/get_records.py +12 -13
- pulumi_digitalocean/get_region.py +17 -18
- pulumi_digitalocean/get_regions.py +6 -7
- pulumi_digitalocean/get_reserved_ip.py +15 -16
- pulumi_digitalocean/get_reserved_ipv6.py +15 -16
- pulumi_digitalocean/get_sizes.py +6 -7
- pulumi_digitalocean/get_spaces_bucket.py +21 -22
- pulumi_digitalocean/get_spaces_bucket_object.py +57 -58
- pulumi_digitalocean/get_spaces_bucket_objects.py +45 -46
- pulumi_digitalocean/get_spaces_buckets.py +6 -7
- pulumi_digitalocean/get_spaces_key.py +14 -15
- pulumi_digitalocean/get_ssh_key.py +13 -14
- pulumi_digitalocean/get_ssh_keys.py +6 -7
- pulumi_digitalocean/get_tag.py +21 -22
- pulumi_digitalocean/get_tags.py +6 -7
- pulumi_digitalocean/get_volume.py +33 -34
- pulumi_digitalocean/get_volume_snapshot.py +39 -40
- pulumi_digitalocean/get_vpc.py +29 -30
- pulumi_digitalocean/get_vpc_nat_gateway.py +33 -34
- pulumi_digitalocean/get_vpc_peering.py +23 -24
- pulumi_digitalocean/kubernetes_cluster.py +293 -294
- pulumi_digitalocean/kubernetes_node_pool.py +168 -169
- pulumi_digitalocean/load_balancer.py +374 -375
- pulumi_digitalocean/monitor_alert.py +149 -150
- pulumi_digitalocean/outputs.py +7064 -7065
- pulumi_digitalocean/partner_attachment.py +150 -151
- pulumi_digitalocean/project.py +139 -140
- pulumi_digitalocean/project_resources.py +35 -36
- pulumi_digitalocean/provider.py +84 -85
- pulumi_digitalocean/pulumi-plugin.json +1 -1
- pulumi_digitalocean/reserved_ip.py +61 -62
- pulumi_digitalocean/reserved_ip_assignment.py +35 -36
- pulumi_digitalocean/reserved_ipv6.py +53 -54
- pulumi_digitalocean/reserved_ipv6_assignment.py +35 -36
- pulumi_digitalocean/spaces_bucket.py +105 -106
- pulumi_digitalocean/spaces_bucket_cors_configuration.py +38 -39
- pulumi_digitalocean/spaces_bucket_logging.py +69 -70
- pulumi_digitalocean/spaces_bucket_object.py +282 -283
- pulumi_digitalocean/spaces_bucket_policy.py +52 -53
- pulumi_digitalocean/spaces_key.py +48 -49
- pulumi_digitalocean/ssh_key.py +44 -45
- pulumi_digitalocean/tag.py +72 -73
- pulumi_digitalocean/uptime_alert.py +106 -107
- pulumi_digitalocean/uptime_check.py +86 -87
- pulumi_digitalocean/volume.py +181 -182
- pulumi_digitalocean/volume_attachment.py +35 -36
- pulumi_digitalocean/volume_snapshot.py +88 -89
- pulumi_digitalocean/vpc.py +96 -97
- pulumi_digitalocean/vpc_nat_gateway.py +152 -153
- pulumi_digitalocean/vpc_peering.py +53 -54
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/METADATA +1 -1
- pulumi_digitalocean-4.50.0a1753508712.dist-info/RECORD +119 -0
- pulumi_digitalocean-4.50.0a1753335988.dist-info/RECORD +0 -119
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/WHEEL +0 -0
- {pulumi_digitalocean-4.50.0a1753335988.dist-info → pulumi_digitalocean-4.50.0a1753508712.dist-info}/top_level.txt +0 -0
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -23,41 +22,41 @@ __all__ = ['LoadBalancerArgs', 'LoadBalancer']
|
|
|
23
22
|
@pulumi.input_type
|
|
24
23
|
class LoadBalancerArgs:
|
|
25
24
|
def __init__(__self__, *,
|
|
26
|
-
algorithm: Optional[pulumi.Input[Union[
|
|
27
|
-
disable_lets_encrypt_dns_records: Optional[pulumi.Input[
|
|
25
|
+
algorithm: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]] = None,
|
|
26
|
+
disable_lets_encrypt_dns_records: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
28
27
|
domains: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]] = None,
|
|
29
|
-
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
30
|
-
droplet_tag: Optional[pulumi.Input[
|
|
31
|
-
enable_backend_keepalive: Optional[pulumi.Input[
|
|
32
|
-
enable_proxy_protocol: Optional[pulumi.Input[
|
|
28
|
+
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
29
|
+
droplet_tag: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
enable_backend_keepalive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
31
|
+
enable_proxy_protocol: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
32
|
firewall: Optional[pulumi.Input['LoadBalancerFirewallArgs']] = None,
|
|
34
33
|
forwarding_rules: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]] = None,
|
|
35
34
|
glb_settings: Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']] = None,
|
|
36
35
|
healthcheck: Optional[pulumi.Input['LoadBalancerHealthcheckArgs']] = None,
|
|
37
|
-
http_idle_timeout_seconds: Optional[pulumi.Input[
|
|
38
|
-
name: Optional[pulumi.Input[
|
|
39
|
-
network: Optional[pulumi.Input[
|
|
40
|
-
network_stack: Optional[pulumi.Input[
|
|
41
|
-
project_id: Optional[pulumi.Input[
|
|
42
|
-
redirect_http_to_https: Optional[pulumi.Input[
|
|
43
|
-
region: Optional[pulumi.Input[Union[
|
|
44
|
-
size: Optional[pulumi.Input[
|
|
45
|
-
size_unit: Optional[pulumi.Input[
|
|
36
|
+
http_idle_timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
37
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
network: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
network_stack: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
redirect_http_to_https: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
42
|
+
region: Optional[pulumi.Input[Union[_builtins.str, 'Region']]] = None,
|
|
43
|
+
size: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
size_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
46
45
|
sticky_sessions: Optional[pulumi.Input['LoadBalancerStickySessionsArgs']] = None,
|
|
47
|
-
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
48
|
-
tls_cipher_policy: Optional[pulumi.Input[
|
|
49
|
-
type: Optional[pulumi.Input[
|
|
50
|
-
vpc_uuid: Optional[pulumi.Input[
|
|
46
|
+
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
47
|
+
tls_cipher_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
49
|
+
vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None):
|
|
51
50
|
"""
|
|
52
51
|
The set of arguments for constructing a LoadBalancer resource.
|
|
53
|
-
:param pulumi.Input[Union[
|
|
52
|
+
:param pulumi.Input[Union[_builtins.str, 'Algorithm']] algorithm: **Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
54
53
|
or `least_connections`. The default value is `round_robin`.
|
|
55
|
-
:param pulumi.Input[
|
|
54
|
+
:param pulumi.Input[_builtins.bool] disable_lets_encrypt_dns_records: A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
56
55
|
:param pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]] domains: A list of `domains` required to ingress traffic to a Global Load Balancer. The `domains` block is documented below.
|
|
57
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
58
|
-
:param pulumi.Input[
|
|
59
|
-
:param pulumi.Input[
|
|
60
|
-
:param pulumi.Input[
|
|
56
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] droplet_ids: A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
57
|
+
:param pulumi.Input[_builtins.str] droplet_tag: The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
58
|
+
:param pulumi.Input[_builtins.bool] enable_backend_keepalive: A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
59
|
+
:param pulumi.Input[_builtins.bool] enable_proxy_protocol: A boolean value indicating whether PROXY
|
|
61
60
|
Protocol should be used to pass information from connecting client requests to
|
|
62
61
|
the backend service. Default value is `false`.
|
|
63
62
|
:param pulumi.Input['LoadBalancerFirewallArgs'] firewall: A block containing rules for allowing/denying traffic to the Load Balancer. The `firewall` block is documented below. Only 1 firewall is allowed.
|
|
@@ -66,23 +65,23 @@ class LoadBalancerArgs:
|
|
|
66
65
|
:param pulumi.Input['LoadBalancerGlbSettingsArgs'] glb_settings: A block containing `glb_settings` required to define target rules for a Global Load Balancer. The `glb_settings` block is documented below.
|
|
67
66
|
:param pulumi.Input['LoadBalancerHealthcheckArgs'] healthcheck: A `healthcheck` block to be assigned to the
|
|
68
67
|
Load Balancer. The `healthcheck` block is documented below. Only 1 healthcheck is allowed.
|
|
69
|
-
:param pulumi.Input[
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
68
|
+
:param pulumi.Input[_builtins.int] http_idle_timeout_seconds: Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
69
|
+
:param pulumi.Input[_builtins.str] name: The Load Balancer name
|
|
70
|
+
:param pulumi.Input[_builtins.str] network: The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
71
|
+
:param pulumi.Input[_builtins.str] network_stack: The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
72
|
+
:param pulumi.Input[_builtins.str] project_id: The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
73
|
+
:param pulumi.Input[_builtins.bool] redirect_http_to_https: A boolean value indicating whether
|
|
75
74
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
76
75
|
Default value is `false`.
|
|
77
|
-
:param pulumi.Input[Union[
|
|
78
|
-
:param pulumi.Input[
|
|
79
|
-
:param pulumi.Input[
|
|
76
|
+
:param pulumi.Input[Union[_builtins.str, 'Region']] region: The region to start in
|
|
77
|
+
:param pulumi.Input[_builtins.str] size: The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
78
|
+
:param pulumi.Input[_builtins.int] size_unit: The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
80
79
|
:param pulumi.Input['LoadBalancerStickySessionsArgs'] sticky_sessions: A `sticky_sessions` block to be assigned to the
|
|
81
80
|
Load Balancer. The `sticky_sessions` block is documented below. Only 1 sticky_sessions block is allowed.
|
|
82
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
83
|
-
:param pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
81
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] target_load_balancer_ids: A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
82
|
+
:param pulumi.Input[_builtins.str] tls_cipher_policy: The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
83
|
+
:param pulumi.Input[_builtins.str] type: The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
84
|
+
:param pulumi.Input[_builtins.str] vpc_uuid: The ID of the VPC where the load balancer will be located.
|
|
86
85
|
"""
|
|
87
86
|
if algorithm is not None:
|
|
88
87
|
warnings.warn("""This field has been deprecated. You can no longer specify an algorithm for load balancers.""", DeprecationWarning)
|
|
@@ -138,10 +137,10 @@ class LoadBalancerArgs:
|
|
|
138
137
|
if vpc_uuid is not None:
|
|
139
138
|
pulumi.set(__self__, "vpc_uuid", vpc_uuid)
|
|
140
139
|
|
|
141
|
-
@property
|
|
140
|
+
@_builtins.property
|
|
142
141
|
@pulumi.getter
|
|
143
142
|
@_utilities.deprecated("""This field has been deprecated. You can no longer specify an algorithm for load balancers.""")
|
|
144
|
-
def algorithm(self) -> Optional[pulumi.Input[Union[
|
|
143
|
+
def algorithm(self) -> Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]]:
|
|
145
144
|
"""
|
|
146
145
|
**Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
147
146
|
or `least_connections`. The default value is `round_robin`.
|
|
@@ -149,22 +148,22 @@ class LoadBalancerArgs:
|
|
|
149
148
|
return pulumi.get(self, "algorithm")
|
|
150
149
|
|
|
151
150
|
@algorithm.setter
|
|
152
|
-
def algorithm(self, value: Optional[pulumi.Input[Union[
|
|
151
|
+
def algorithm(self, value: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]]):
|
|
153
152
|
pulumi.set(self, "algorithm", value)
|
|
154
153
|
|
|
155
|
-
@property
|
|
154
|
+
@_builtins.property
|
|
156
155
|
@pulumi.getter(name="disableLetsEncryptDnsRecords")
|
|
157
|
-
def disable_lets_encrypt_dns_records(self) -> Optional[pulumi.Input[
|
|
156
|
+
def disable_lets_encrypt_dns_records(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
158
157
|
"""
|
|
159
158
|
A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
160
159
|
"""
|
|
161
160
|
return pulumi.get(self, "disable_lets_encrypt_dns_records")
|
|
162
161
|
|
|
163
162
|
@disable_lets_encrypt_dns_records.setter
|
|
164
|
-
def disable_lets_encrypt_dns_records(self, value: Optional[pulumi.Input[
|
|
163
|
+
def disable_lets_encrypt_dns_records(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
165
164
|
pulumi.set(self, "disable_lets_encrypt_dns_records", value)
|
|
166
165
|
|
|
167
|
-
@property
|
|
166
|
+
@_builtins.property
|
|
168
167
|
@pulumi.getter
|
|
169
168
|
def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]]:
|
|
170
169
|
"""
|
|
@@ -176,45 +175,45 @@ class LoadBalancerArgs:
|
|
|
176
175
|
def domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]]):
|
|
177
176
|
pulumi.set(self, "domains", value)
|
|
178
177
|
|
|
179
|
-
@property
|
|
178
|
+
@_builtins.property
|
|
180
179
|
@pulumi.getter(name="dropletIds")
|
|
181
|
-
def droplet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
180
|
+
def droplet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
|
|
182
181
|
"""
|
|
183
182
|
A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
184
183
|
"""
|
|
185
184
|
return pulumi.get(self, "droplet_ids")
|
|
186
185
|
|
|
187
186
|
@droplet_ids.setter
|
|
188
|
-
def droplet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
187
|
+
def droplet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
|
|
189
188
|
pulumi.set(self, "droplet_ids", value)
|
|
190
189
|
|
|
191
|
-
@property
|
|
190
|
+
@_builtins.property
|
|
192
191
|
@pulumi.getter(name="dropletTag")
|
|
193
|
-
def droplet_tag(self) -> Optional[pulumi.Input[
|
|
192
|
+
def droplet_tag(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
194
193
|
"""
|
|
195
194
|
The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
196
195
|
"""
|
|
197
196
|
return pulumi.get(self, "droplet_tag")
|
|
198
197
|
|
|
199
198
|
@droplet_tag.setter
|
|
200
|
-
def droplet_tag(self, value: Optional[pulumi.Input[
|
|
199
|
+
def droplet_tag(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
201
200
|
pulumi.set(self, "droplet_tag", value)
|
|
202
201
|
|
|
203
|
-
@property
|
|
202
|
+
@_builtins.property
|
|
204
203
|
@pulumi.getter(name="enableBackendKeepalive")
|
|
205
|
-
def enable_backend_keepalive(self) -> Optional[pulumi.Input[
|
|
204
|
+
def enable_backend_keepalive(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
206
205
|
"""
|
|
207
206
|
A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
208
207
|
"""
|
|
209
208
|
return pulumi.get(self, "enable_backend_keepalive")
|
|
210
209
|
|
|
211
210
|
@enable_backend_keepalive.setter
|
|
212
|
-
def enable_backend_keepalive(self, value: Optional[pulumi.Input[
|
|
211
|
+
def enable_backend_keepalive(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
213
212
|
pulumi.set(self, "enable_backend_keepalive", value)
|
|
214
213
|
|
|
215
|
-
@property
|
|
214
|
+
@_builtins.property
|
|
216
215
|
@pulumi.getter(name="enableProxyProtocol")
|
|
217
|
-
def enable_proxy_protocol(self) -> Optional[pulumi.Input[
|
|
216
|
+
def enable_proxy_protocol(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
218
217
|
"""
|
|
219
218
|
A boolean value indicating whether PROXY
|
|
220
219
|
Protocol should be used to pass information from connecting client requests to
|
|
@@ -223,10 +222,10 @@ class LoadBalancerArgs:
|
|
|
223
222
|
return pulumi.get(self, "enable_proxy_protocol")
|
|
224
223
|
|
|
225
224
|
@enable_proxy_protocol.setter
|
|
226
|
-
def enable_proxy_protocol(self, value: Optional[pulumi.Input[
|
|
225
|
+
def enable_proxy_protocol(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
227
226
|
pulumi.set(self, "enable_proxy_protocol", value)
|
|
228
227
|
|
|
229
|
-
@property
|
|
228
|
+
@_builtins.property
|
|
230
229
|
@pulumi.getter
|
|
231
230
|
def firewall(self) -> Optional[pulumi.Input['LoadBalancerFirewallArgs']]:
|
|
232
231
|
"""
|
|
@@ -238,7 +237,7 @@ class LoadBalancerArgs:
|
|
|
238
237
|
def firewall(self, value: Optional[pulumi.Input['LoadBalancerFirewallArgs']]):
|
|
239
238
|
pulumi.set(self, "firewall", value)
|
|
240
239
|
|
|
241
|
-
@property
|
|
240
|
+
@_builtins.property
|
|
242
241
|
@pulumi.getter(name="forwardingRules")
|
|
243
242
|
def forwarding_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]]:
|
|
244
243
|
"""
|
|
@@ -251,7 +250,7 @@ class LoadBalancerArgs:
|
|
|
251
250
|
def forwarding_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]]):
|
|
252
251
|
pulumi.set(self, "forwarding_rules", value)
|
|
253
252
|
|
|
254
|
-
@property
|
|
253
|
+
@_builtins.property
|
|
255
254
|
@pulumi.getter(name="glbSettings")
|
|
256
255
|
def glb_settings(self) -> Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']]:
|
|
257
256
|
"""
|
|
@@ -263,7 +262,7 @@ class LoadBalancerArgs:
|
|
|
263
262
|
def glb_settings(self, value: Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']]):
|
|
264
263
|
pulumi.set(self, "glb_settings", value)
|
|
265
264
|
|
|
266
|
-
@property
|
|
265
|
+
@_builtins.property
|
|
267
266
|
@pulumi.getter
|
|
268
267
|
def healthcheck(self) -> Optional[pulumi.Input['LoadBalancerHealthcheckArgs']]:
|
|
269
268
|
"""
|
|
@@ -276,69 +275,69 @@ class LoadBalancerArgs:
|
|
|
276
275
|
def healthcheck(self, value: Optional[pulumi.Input['LoadBalancerHealthcheckArgs']]):
|
|
277
276
|
pulumi.set(self, "healthcheck", value)
|
|
278
277
|
|
|
279
|
-
@property
|
|
278
|
+
@_builtins.property
|
|
280
279
|
@pulumi.getter(name="httpIdleTimeoutSeconds")
|
|
281
|
-
def http_idle_timeout_seconds(self) -> Optional[pulumi.Input[
|
|
280
|
+
def http_idle_timeout_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
282
281
|
"""
|
|
283
282
|
Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
284
283
|
"""
|
|
285
284
|
return pulumi.get(self, "http_idle_timeout_seconds")
|
|
286
285
|
|
|
287
286
|
@http_idle_timeout_seconds.setter
|
|
288
|
-
def http_idle_timeout_seconds(self, value: Optional[pulumi.Input[
|
|
287
|
+
def http_idle_timeout_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
289
288
|
pulumi.set(self, "http_idle_timeout_seconds", value)
|
|
290
289
|
|
|
291
|
-
@property
|
|
290
|
+
@_builtins.property
|
|
292
291
|
@pulumi.getter
|
|
293
|
-
def name(self) -> Optional[pulumi.Input[
|
|
292
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
294
293
|
"""
|
|
295
294
|
The Load Balancer name
|
|
296
295
|
"""
|
|
297
296
|
return pulumi.get(self, "name")
|
|
298
297
|
|
|
299
298
|
@name.setter
|
|
300
|
-
def name(self, value: Optional[pulumi.Input[
|
|
299
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
301
300
|
pulumi.set(self, "name", value)
|
|
302
301
|
|
|
303
|
-
@property
|
|
302
|
+
@_builtins.property
|
|
304
303
|
@pulumi.getter
|
|
305
|
-
def network(self) -> Optional[pulumi.Input[
|
|
304
|
+
def network(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
306
305
|
"""
|
|
307
306
|
The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
308
307
|
"""
|
|
309
308
|
return pulumi.get(self, "network")
|
|
310
309
|
|
|
311
310
|
@network.setter
|
|
312
|
-
def network(self, value: Optional[pulumi.Input[
|
|
311
|
+
def network(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
313
312
|
pulumi.set(self, "network", value)
|
|
314
313
|
|
|
315
|
-
@property
|
|
314
|
+
@_builtins.property
|
|
316
315
|
@pulumi.getter(name="networkStack")
|
|
317
|
-
def network_stack(self) -> Optional[pulumi.Input[
|
|
316
|
+
def network_stack(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
318
317
|
"""
|
|
319
318
|
The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
320
319
|
"""
|
|
321
320
|
return pulumi.get(self, "network_stack")
|
|
322
321
|
|
|
323
322
|
@network_stack.setter
|
|
324
|
-
def network_stack(self, value: Optional[pulumi.Input[
|
|
323
|
+
def network_stack(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
325
324
|
pulumi.set(self, "network_stack", value)
|
|
326
325
|
|
|
327
|
-
@property
|
|
326
|
+
@_builtins.property
|
|
328
327
|
@pulumi.getter(name="projectId")
|
|
329
|
-
def project_id(self) -> Optional[pulumi.Input[
|
|
328
|
+
def project_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
330
329
|
"""
|
|
331
330
|
The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
332
331
|
"""
|
|
333
332
|
return pulumi.get(self, "project_id")
|
|
334
333
|
|
|
335
334
|
@project_id.setter
|
|
336
|
-
def project_id(self, value: Optional[pulumi.Input[
|
|
335
|
+
def project_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
337
336
|
pulumi.set(self, "project_id", value)
|
|
338
337
|
|
|
339
|
-
@property
|
|
338
|
+
@_builtins.property
|
|
340
339
|
@pulumi.getter(name="redirectHttpToHttps")
|
|
341
|
-
def redirect_http_to_https(self) -> Optional[pulumi.Input[
|
|
340
|
+
def redirect_http_to_https(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
342
341
|
"""
|
|
343
342
|
A boolean value indicating whether
|
|
344
343
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
@@ -347,46 +346,46 @@ class LoadBalancerArgs:
|
|
|
347
346
|
return pulumi.get(self, "redirect_http_to_https")
|
|
348
347
|
|
|
349
348
|
@redirect_http_to_https.setter
|
|
350
|
-
def redirect_http_to_https(self, value: Optional[pulumi.Input[
|
|
349
|
+
def redirect_http_to_https(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
351
350
|
pulumi.set(self, "redirect_http_to_https", value)
|
|
352
351
|
|
|
353
|
-
@property
|
|
352
|
+
@_builtins.property
|
|
354
353
|
@pulumi.getter
|
|
355
|
-
def region(self) -> Optional[pulumi.Input[Union[
|
|
354
|
+
def region(self) -> Optional[pulumi.Input[Union[_builtins.str, 'Region']]]:
|
|
356
355
|
"""
|
|
357
356
|
The region to start in
|
|
358
357
|
"""
|
|
359
358
|
return pulumi.get(self, "region")
|
|
360
359
|
|
|
361
360
|
@region.setter
|
|
362
|
-
def region(self, value: Optional[pulumi.Input[Union[
|
|
361
|
+
def region(self, value: Optional[pulumi.Input[Union[_builtins.str, 'Region']]]):
|
|
363
362
|
pulumi.set(self, "region", value)
|
|
364
363
|
|
|
365
|
-
@property
|
|
364
|
+
@_builtins.property
|
|
366
365
|
@pulumi.getter
|
|
367
|
-
def size(self) -> Optional[pulumi.Input[
|
|
366
|
+
def size(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
368
367
|
"""
|
|
369
368
|
The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
370
369
|
"""
|
|
371
370
|
return pulumi.get(self, "size")
|
|
372
371
|
|
|
373
372
|
@size.setter
|
|
374
|
-
def size(self, value: Optional[pulumi.Input[
|
|
373
|
+
def size(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
375
374
|
pulumi.set(self, "size", value)
|
|
376
375
|
|
|
377
|
-
@property
|
|
376
|
+
@_builtins.property
|
|
378
377
|
@pulumi.getter(name="sizeUnit")
|
|
379
|
-
def size_unit(self) -> Optional[pulumi.Input[
|
|
378
|
+
def size_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
380
379
|
"""
|
|
381
380
|
The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
382
381
|
"""
|
|
383
382
|
return pulumi.get(self, "size_unit")
|
|
384
383
|
|
|
385
384
|
@size_unit.setter
|
|
386
|
-
def size_unit(self, value: Optional[pulumi.Input[
|
|
385
|
+
def size_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
387
386
|
pulumi.set(self, "size_unit", value)
|
|
388
387
|
|
|
389
|
-
@property
|
|
388
|
+
@_builtins.property
|
|
390
389
|
@pulumi.getter(name="stickySessions")
|
|
391
390
|
def sticky_sessions(self) -> Optional[pulumi.Input['LoadBalancerStickySessionsArgs']]:
|
|
392
391
|
"""
|
|
@@ -399,97 +398,97 @@ class LoadBalancerArgs:
|
|
|
399
398
|
def sticky_sessions(self, value: Optional[pulumi.Input['LoadBalancerStickySessionsArgs']]):
|
|
400
399
|
pulumi.set(self, "sticky_sessions", value)
|
|
401
400
|
|
|
402
|
-
@property
|
|
401
|
+
@_builtins.property
|
|
403
402
|
@pulumi.getter(name="targetLoadBalancerIds")
|
|
404
|
-
def target_load_balancer_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
403
|
+
def target_load_balancer_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
405
404
|
"""
|
|
406
405
|
A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
407
406
|
"""
|
|
408
407
|
return pulumi.get(self, "target_load_balancer_ids")
|
|
409
408
|
|
|
410
409
|
@target_load_balancer_ids.setter
|
|
411
|
-
def target_load_balancer_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
410
|
+
def target_load_balancer_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
412
411
|
pulumi.set(self, "target_load_balancer_ids", value)
|
|
413
412
|
|
|
414
|
-
@property
|
|
413
|
+
@_builtins.property
|
|
415
414
|
@pulumi.getter(name="tlsCipherPolicy")
|
|
416
|
-
def tls_cipher_policy(self) -> Optional[pulumi.Input[
|
|
415
|
+
def tls_cipher_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
417
416
|
"""
|
|
418
417
|
The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
419
418
|
"""
|
|
420
419
|
return pulumi.get(self, "tls_cipher_policy")
|
|
421
420
|
|
|
422
421
|
@tls_cipher_policy.setter
|
|
423
|
-
def tls_cipher_policy(self, value: Optional[pulumi.Input[
|
|
422
|
+
def tls_cipher_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
424
423
|
pulumi.set(self, "tls_cipher_policy", value)
|
|
425
424
|
|
|
426
|
-
@property
|
|
425
|
+
@_builtins.property
|
|
427
426
|
@pulumi.getter
|
|
428
|
-
def type(self) -> Optional[pulumi.Input[
|
|
427
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
429
428
|
"""
|
|
430
429
|
The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
431
430
|
"""
|
|
432
431
|
return pulumi.get(self, "type")
|
|
433
432
|
|
|
434
433
|
@type.setter
|
|
435
|
-
def type(self, value: Optional[pulumi.Input[
|
|
434
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
436
435
|
pulumi.set(self, "type", value)
|
|
437
436
|
|
|
438
|
-
@property
|
|
437
|
+
@_builtins.property
|
|
439
438
|
@pulumi.getter(name="vpcUuid")
|
|
440
|
-
def vpc_uuid(self) -> Optional[pulumi.Input[
|
|
439
|
+
def vpc_uuid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
441
440
|
"""
|
|
442
441
|
The ID of the VPC where the load balancer will be located.
|
|
443
442
|
"""
|
|
444
443
|
return pulumi.get(self, "vpc_uuid")
|
|
445
444
|
|
|
446
445
|
@vpc_uuid.setter
|
|
447
|
-
def vpc_uuid(self, value: Optional[pulumi.Input[
|
|
446
|
+
def vpc_uuid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
448
447
|
pulumi.set(self, "vpc_uuid", value)
|
|
449
448
|
|
|
450
449
|
|
|
451
450
|
@pulumi.input_type
|
|
452
451
|
class _LoadBalancerState:
|
|
453
452
|
def __init__(__self__, *,
|
|
454
|
-
algorithm: Optional[pulumi.Input[Union[
|
|
455
|
-
disable_lets_encrypt_dns_records: Optional[pulumi.Input[
|
|
453
|
+
algorithm: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]] = None,
|
|
454
|
+
disable_lets_encrypt_dns_records: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
456
455
|
domains: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]] = None,
|
|
457
|
-
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
458
|
-
droplet_tag: Optional[pulumi.Input[
|
|
459
|
-
enable_backend_keepalive: Optional[pulumi.Input[
|
|
460
|
-
enable_proxy_protocol: Optional[pulumi.Input[
|
|
456
|
+
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
457
|
+
droplet_tag: Optional[pulumi.Input[_builtins.str]] = None,
|
|
458
|
+
enable_backend_keepalive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
459
|
+
enable_proxy_protocol: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
461
460
|
firewall: Optional[pulumi.Input['LoadBalancerFirewallArgs']] = None,
|
|
462
461
|
forwarding_rules: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]] = None,
|
|
463
462
|
glb_settings: Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']] = None,
|
|
464
463
|
healthcheck: Optional[pulumi.Input['LoadBalancerHealthcheckArgs']] = None,
|
|
465
|
-
http_idle_timeout_seconds: Optional[pulumi.Input[
|
|
466
|
-
ip: Optional[pulumi.Input[
|
|
467
|
-
ipv6: Optional[pulumi.Input[
|
|
468
|
-
load_balancer_urn: Optional[pulumi.Input[
|
|
469
|
-
name: Optional[pulumi.Input[
|
|
470
|
-
network: Optional[pulumi.Input[
|
|
471
|
-
network_stack: Optional[pulumi.Input[
|
|
472
|
-
project_id: Optional[pulumi.Input[
|
|
473
|
-
redirect_http_to_https: Optional[pulumi.Input[
|
|
474
|
-
region: Optional[pulumi.Input[Union[
|
|
475
|
-
size: Optional[pulumi.Input[
|
|
476
|
-
size_unit: Optional[pulumi.Input[
|
|
477
|
-
status: Optional[pulumi.Input[
|
|
464
|
+
http_idle_timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
465
|
+
ip: Optional[pulumi.Input[_builtins.str]] = None,
|
|
466
|
+
ipv6: Optional[pulumi.Input[_builtins.str]] = None,
|
|
467
|
+
load_balancer_urn: Optional[pulumi.Input[_builtins.str]] = None,
|
|
468
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
469
|
+
network: Optional[pulumi.Input[_builtins.str]] = None,
|
|
470
|
+
network_stack: Optional[pulumi.Input[_builtins.str]] = None,
|
|
471
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
472
|
+
redirect_http_to_https: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
473
|
+
region: Optional[pulumi.Input[Union[_builtins.str, 'Region']]] = None,
|
|
474
|
+
size: Optional[pulumi.Input[_builtins.str]] = None,
|
|
475
|
+
size_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
476
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
478
477
|
sticky_sessions: Optional[pulumi.Input['LoadBalancerStickySessionsArgs']] = None,
|
|
479
|
-
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
480
|
-
tls_cipher_policy: Optional[pulumi.Input[
|
|
481
|
-
type: Optional[pulumi.Input[
|
|
482
|
-
vpc_uuid: Optional[pulumi.Input[
|
|
478
|
+
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
479
|
+
tls_cipher_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
480
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
481
|
+
vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None):
|
|
483
482
|
"""
|
|
484
483
|
Input properties used for looking up and filtering LoadBalancer resources.
|
|
485
|
-
:param pulumi.Input[Union[
|
|
484
|
+
:param pulumi.Input[Union[_builtins.str, 'Algorithm']] algorithm: **Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
486
485
|
or `least_connections`. The default value is `round_robin`.
|
|
487
|
-
:param pulumi.Input[
|
|
486
|
+
:param pulumi.Input[_builtins.bool] disable_lets_encrypt_dns_records: A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
488
487
|
:param pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]] domains: A list of `domains` required to ingress traffic to a Global Load Balancer. The `domains` block is documented below.
|
|
489
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
490
|
-
:param pulumi.Input[
|
|
491
|
-
:param pulumi.Input[
|
|
492
|
-
:param pulumi.Input[
|
|
488
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] droplet_ids: A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
489
|
+
:param pulumi.Input[_builtins.str] droplet_tag: The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
490
|
+
:param pulumi.Input[_builtins.bool] enable_backend_keepalive: A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
491
|
+
:param pulumi.Input[_builtins.bool] enable_proxy_protocol: A boolean value indicating whether PROXY
|
|
493
492
|
Protocol should be used to pass information from connecting client requests to
|
|
494
493
|
the backend service. Default value is `false`.
|
|
495
494
|
:param pulumi.Input['LoadBalancerFirewallArgs'] firewall: A block containing rules for allowing/denying traffic to the Load Balancer. The `firewall` block is documented below. Only 1 firewall is allowed.
|
|
@@ -498,25 +497,25 @@ class _LoadBalancerState:
|
|
|
498
497
|
:param pulumi.Input['LoadBalancerGlbSettingsArgs'] glb_settings: A block containing `glb_settings` required to define target rules for a Global Load Balancer. The `glb_settings` block is documented below.
|
|
499
498
|
:param pulumi.Input['LoadBalancerHealthcheckArgs'] healthcheck: A `healthcheck` block to be assigned to the
|
|
500
499
|
Load Balancer. The `healthcheck` block is documented below. Only 1 healthcheck is allowed.
|
|
501
|
-
:param pulumi.Input[
|
|
502
|
-
:param pulumi.Input[
|
|
503
|
-
:param pulumi.Input[
|
|
504
|
-
:param pulumi.Input[
|
|
505
|
-
:param pulumi.Input[
|
|
506
|
-
:param pulumi.Input[
|
|
507
|
-
:param pulumi.Input[
|
|
508
|
-
:param pulumi.Input[
|
|
500
|
+
:param pulumi.Input[_builtins.int] http_idle_timeout_seconds: Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
501
|
+
:param pulumi.Input[_builtins.str] ip: The ip of the Load Balancer
|
|
502
|
+
:param pulumi.Input[_builtins.str] load_balancer_urn: The uniform resource name for the Load Balancer
|
|
503
|
+
:param pulumi.Input[_builtins.str] name: The Load Balancer name
|
|
504
|
+
:param pulumi.Input[_builtins.str] network: The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
505
|
+
:param pulumi.Input[_builtins.str] network_stack: The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
506
|
+
:param pulumi.Input[_builtins.str] project_id: The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
507
|
+
:param pulumi.Input[_builtins.bool] redirect_http_to_https: A boolean value indicating whether
|
|
509
508
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
510
509
|
Default value is `false`.
|
|
511
|
-
:param pulumi.Input[Union[
|
|
512
|
-
:param pulumi.Input[
|
|
513
|
-
:param pulumi.Input[
|
|
510
|
+
:param pulumi.Input[Union[_builtins.str, 'Region']] region: The region to start in
|
|
511
|
+
:param pulumi.Input[_builtins.str] size: The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
512
|
+
:param pulumi.Input[_builtins.int] size_unit: The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
514
513
|
:param pulumi.Input['LoadBalancerStickySessionsArgs'] sticky_sessions: A `sticky_sessions` block to be assigned to the
|
|
515
514
|
Load Balancer. The `sticky_sessions` block is documented below. Only 1 sticky_sessions block is allowed.
|
|
516
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
517
|
-
:param pulumi.Input[
|
|
518
|
-
:param pulumi.Input[
|
|
519
|
-
:param pulumi.Input[
|
|
515
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] target_load_balancer_ids: A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
516
|
+
:param pulumi.Input[_builtins.str] tls_cipher_policy: The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
517
|
+
:param pulumi.Input[_builtins.str] type: The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
518
|
+
:param pulumi.Input[_builtins.str] vpc_uuid: The ID of the VPC where the load balancer will be located.
|
|
520
519
|
"""
|
|
521
520
|
if algorithm is not None:
|
|
522
521
|
warnings.warn("""This field has been deprecated. You can no longer specify an algorithm for load balancers.""", DeprecationWarning)
|
|
@@ -580,10 +579,10 @@ class _LoadBalancerState:
|
|
|
580
579
|
if vpc_uuid is not None:
|
|
581
580
|
pulumi.set(__self__, "vpc_uuid", vpc_uuid)
|
|
582
581
|
|
|
583
|
-
@property
|
|
582
|
+
@_builtins.property
|
|
584
583
|
@pulumi.getter
|
|
585
584
|
@_utilities.deprecated("""This field has been deprecated. You can no longer specify an algorithm for load balancers.""")
|
|
586
|
-
def algorithm(self) -> Optional[pulumi.Input[Union[
|
|
585
|
+
def algorithm(self) -> Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]]:
|
|
587
586
|
"""
|
|
588
587
|
**Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
589
588
|
or `least_connections`. The default value is `round_robin`.
|
|
@@ -591,22 +590,22 @@ class _LoadBalancerState:
|
|
|
591
590
|
return pulumi.get(self, "algorithm")
|
|
592
591
|
|
|
593
592
|
@algorithm.setter
|
|
594
|
-
def algorithm(self, value: Optional[pulumi.Input[Union[
|
|
593
|
+
def algorithm(self, value: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]]):
|
|
595
594
|
pulumi.set(self, "algorithm", value)
|
|
596
595
|
|
|
597
|
-
@property
|
|
596
|
+
@_builtins.property
|
|
598
597
|
@pulumi.getter(name="disableLetsEncryptDnsRecords")
|
|
599
|
-
def disable_lets_encrypt_dns_records(self) -> Optional[pulumi.Input[
|
|
598
|
+
def disable_lets_encrypt_dns_records(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
600
599
|
"""
|
|
601
600
|
A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
602
601
|
"""
|
|
603
602
|
return pulumi.get(self, "disable_lets_encrypt_dns_records")
|
|
604
603
|
|
|
605
604
|
@disable_lets_encrypt_dns_records.setter
|
|
606
|
-
def disable_lets_encrypt_dns_records(self, value: Optional[pulumi.Input[
|
|
605
|
+
def disable_lets_encrypt_dns_records(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
607
606
|
pulumi.set(self, "disable_lets_encrypt_dns_records", value)
|
|
608
607
|
|
|
609
|
-
@property
|
|
608
|
+
@_builtins.property
|
|
610
609
|
@pulumi.getter
|
|
611
610
|
def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]]:
|
|
612
611
|
"""
|
|
@@ -618,45 +617,45 @@ class _LoadBalancerState:
|
|
|
618
617
|
def domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerDomainArgs']]]]):
|
|
619
618
|
pulumi.set(self, "domains", value)
|
|
620
619
|
|
|
621
|
-
@property
|
|
620
|
+
@_builtins.property
|
|
622
621
|
@pulumi.getter(name="dropletIds")
|
|
623
|
-
def droplet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
622
|
+
def droplet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
|
|
624
623
|
"""
|
|
625
624
|
A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
626
625
|
"""
|
|
627
626
|
return pulumi.get(self, "droplet_ids")
|
|
628
627
|
|
|
629
628
|
@droplet_ids.setter
|
|
630
|
-
def droplet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
629
|
+
def droplet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
|
|
631
630
|
pulumi.set(self, "droplet_ids", value)
|
|
632
631
|
|
|
633
|
-
@property
|
|
632
|
+
@_builtins.property
|
|
634
633
|
@pulumi.getter(name="dropletTag")
|
|
635
|
-
def droplet_tag(self) -> Optional[pulumi.Input[
|
|
634
|
+
def droplet_tag(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
636
635
|
"""
|
|
637
636
|
The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
638
637
|
"""
|
|
639
638
|
return pulumi.get(self, "droplet_tag")
|
|
640
639
|
|
|
641
640
|
@droplet_tag.setter
|
|
642
|
-
def droplet_tag(self, value: Optional[pulumi.Input[
|
|
641
|
+
def droplet_tag(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
643
642
|
pulumi.set(self, "droplet_tag", value)
|
|
644
643
|
|
|
645
|
-
@property
|
|
644
|
+
@_builtins.property
|
|
646
645
|
@pulumi.getter(name="enableBackendKeepalive")
|
|
647
|
-
def enable_backend_keepalive(self) -> Optional[pulumi.Input[
|
|
646
|
+
def enable_backend_keepalive(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
648
647
|
"""
|
|
649
648
|
A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
650
649
|
"""
|
|
651
650
|
return pulumi.get(self, "enable_backend_keepalive")
|
|
652
651
|
|
|
653
652
|
@enable_backend_keepalive.setter
|
|
654
|
-
def enable_backend_keepalive(self, value: Optional[pulumi.Input[
|
|
653
|
+
def enable_backend_keepalive(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
655
654
|
pulumi.set(self, "enable_backend_keepalive", value)
|
|
656
655
|
|
|
657
|
-
@property
|
|
656
|
+
@_builtins.property
|
|
658
657
|
@pulumi.getter(name="enableProxyProtocol")
|
|
659
|
-
def enable_proxy_protocol(self) -> Optional[pulumi.Input[
|
|
658
|
+
def enable_proxy_protocol(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
660
659
|
"""
|
|
661
660
|
A boolean value indicating whether PROXY
|
|
662
661
|
Protocol should be used to pass information from connecting client requests to
|
|
@@ -665,10 +664,10 @@ class _LoadBalancerState:
|
|
|
665
664
|
return pulumi.get(self, "enable_proxy_protocol")
|
|
666
665
|
|
|
667
666
|
@enable_proxy_protocol.setter
|
|
668
|
-
def enable_proxy_protocol(self, value: Optional[pulumi.Input[
|
|
667
|
+
def enable_proxy_protocol(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
669
668
|
pulumi.set(self, "enable_proxy_protocol", value)
|
|
670
669
|
|
|
671
|
-
@property
|
|
670
|
+
@_builtins.property
|
|
672
671
|
@pulumi.getter
|
|
673
672
|
def firewall(self) -> Optional[pulumi.Input['LoadBalancerFirewallArgs']]:
|
|
674
673
|
"""
|
|
@@ -680,7 +679,7 @@ class _LoadBalancerState:
|
|
|
680
679
|
def firewall(self, value: Optional[pulumi.Input['LoadBalancerFirewallArgs']]):
|
|
681
680
|
pulumi.set(self, "firewall", value)
|
|
682
681
|
|
|
683
|
-
@property
|
|
682
|
+
@_builtins.property
|
|
684
683
|
@pulumi.getter(name="forwardingRules")
|
|
685
684
|
def forwarding_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]]:
|
|
686
685
|
"""
|
|
@@ -693,7 +692,7 @@ class _LoadBalancerState:
|
|
|
693
692
|
def forwarding_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerForwardingRuleArgs']]]]):
|
|
694
693
|
pulumi.set(self, "forwarding_rules", value)
|
|
695
694
|
|
|
696
|
-
@property
|
|
695
|
+
@_builtins.property
|
|
697
696
|
@pulumi.getter(name="glbSettings")
|
|
698
697
|
def glb_settings(self) -> Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']]:
|
|
699
698
|
"""
|
|
@@ -705,7 +704,7 @@ class _LoadBalancerState:
|
|
|
705
704
|
def glb_settings(self, value: Optional[pulumi.Input['LoadBalancerGlbSettingsArgs']]):
|
|
706
705
|
pulumi.set(self, "glb_settings", value)
|
|
707
706
|
|
|
708
|
-
@property
|
|
707
|
+
@_builtins.property
|
|
709
708
|
@pulumi.getter
|
|
710
709
|
def healthcheck(self) -> Optional[pulumi.Input['LoadBalancerHealthcheckArgs']]:
|
|
711
710
|
"""
|
|
@@ -718,102 +717,102 @@ class _LoadBalancerState:
|
|
|
718
717
|
def healthcheck(self, value: Optional[pulumi.Input['LoadBalancerHealthcheckArgs']]):
|
|
719
718
|
pulumi.set(self, "healthcheck", value)
|
|
720
719
|
|
|
721
|
-
@property
|
|
720
|
+
@_builtins.property
|
|
722
721
|
@pulumi.getter(name="httpIdleTimeoutSeconds")
|
|
723
|
-
def http_idle_timeout_seconds(self) -> Optional[pulumi.Input[
|
|
722
|
+
def http_idle_timeout_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
724
723
|
"""
|
|
725
724
|
Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
726
725
|
"""
|
|
727
726
|
return pulumi.get(self, "http_idle_timeout_seconds")
|
|
728
727
|
|
|
729
728
|
@http_idle_timeout_seconds.setter
|
|
730
|
-
def http_idle_timeout_seconds(self, value: Optional[pulumi.Input[
|
|
729
|
+
def http_idle_timeout_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
731
730
|
pulumi.set(self, "http_idle_timeout_seconds", value)
|
|
732
731
|
|
|
733
|
-
@property
|
|
732
|
+
@_builtins.property
|
|
734
733
|
@pulumi.getter
|
|
735
|
-
def ip(self) -> Optional[pulumi.Input[
|
|
734
|
+
def ip(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
736
735
|
"""
|
|
737
736
|
The ip of the Load Balancer
|
|
738
737
|
"""
|
|
739
738
|
return pulumi.get(self, "ip")
|
|
740
739
|
|
|
741
740
|
@ip.setter
|
|
742
|
-
def ip(self, value: Optional[pulumi.Input[
|
|
741
|
+
def ip(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
743
742
|
pulumi.set(self, "ip", value)
|
|
744
743
|
|
|
745
|
-
@property
|
|
744
|
+
@_builtins.property
|
|
746
745
|
@pulumi.getter
|
|
747
|
-
def ipv6(self) -> Optional[pulumi.Input[
|
|
746
|
+
def ipv6(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
748
747
|
return pulumi.get(self, "ipv6")
|
|
749
748
|
|
|
750
749
|
@ipv6.setter
|
|
751
|
-
def ipv6(self, value: Optional[pulumi.Input[
|
|
750
|
+
def ipv6(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
752
751
|
pulumi.set(self, "ipv6", value)
|
|
753
752
|
|
|
754
|
-
@property
|
|
753
|
+
@_builtins.property
|
|
755
754
|
@pulumi.getter(name="loadBalancerUrn")
|
|
756
|
-
def load_balancer_urn(self) -> Optional[pulumi.Input[
|
|
755
|
+
def load_balancer_urn(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
757
756
|
"""
|
|
758
757
|
The uniform resource name for the Load Balancer
|
|
759
758
|
"""
|
|
760
759
|
return pulumi.get(self, "load_balancer_urn")
|
|
761
760
|
|
|
762
761
|
@load_balancer_urn.setter
|
|
763
|
-
def load_balancer_urn(self, value: Optional[pulumi.Input[
|
|
762
|
+
def load_balancer_urn(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
764
763
|
pulumi.set(self, "load_balancer_urn", value)
|
|
765
764
|
|
|
766
|
-
@property
|
|
765
|
+
@_builtins.property
|
|
767
766
|
@pulumi.getter
|
|
768
|
-
def name(self) -> Optional[pulumi.Input[
|
|
767
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
769
768
|
"""
|
|
770
769
|
The Load Balancer name
|
|
771
770
|
"""
|
|
772
771
|
return pulumi.get(self, "name")
|
|
773
772
|
|
|
774
773
|
@name.setter
|
|
775
|
-
def name(self, value: Optional[pulumi.Input[
|
|
774
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
776
775
|
pulumi.set(self, "name", value)
|
|
777
776
|
|
|
778
|
-
@property
|
|
777
|
+
@_builtins.property
|
|
779
778
|
@pulumi.getter
|
|
780
|
-
def network(self) -> Optional[pulumi.Input[
|
|
779
|
+
def network(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
781
780
|
"""
|
|
782
781
|
The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
783
782
|
"""
|
|
784
783
|
return pulumi.get(self, "network")
|
|
785
784
|
|
|
786
785
|
@network.setter
|
|
787
|
-
def network(self, value: Optional[pulumi.Input[
|
|
786
|
+
def network(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
788
787
|
pulumi.set(self, "network", value)
|
|
789
788
|
|
|
790
|
-
@property
|
|
789
|
+
@_builtins.property
|
|
791
790
|
@pulumi.getter(name="networkStack")
|
|
792
|
-
def network_stack(self) -> Optional[pulumi.Input[
|
|
791
|
+
def network_stack(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
793
792
|
"""
|
|
794
793
|
The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
795
794
|
"""
|
|
796
795
|
return pulumi.get(self, "network_stack")
|
|
797
796
|
|
|
798
797
|
@network_stack.setter
|
|
799
|
-
def network_stack(self, value: Optional[pulumi.Input[
|
|
798
|
+
def network_stack(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
800
799
|
pulumi.set(self, "network_stack", value)
|
|
801
800
|
|
|
802
|
-
@property
|
|
801
|
+
@_builtins.property
|
|
803
802
|
@pulumi.getter(name="projectId")
|
|
804
|
-
def project_id(self) -> Optional[pulumi.Input[
|
|
803
|
+
def project_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
805
804
|
"""
|
|
806
805
|
The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
807
806
|
"""
|
|
808
807
|
return pulumi.get(self, "project_id")
|
|
809
808
|
|
|
810
809
|
@project_id.setter
|
|
811
|
-
def project_id(self, value: Optional[pulumi.Input[
|
|
810
|
+
def project_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
812
811
|
pulumi.set(self, "project_id", value)
|
|
813
812
|
|
|
814
|
-
@property
|
|
813
|
+
@_builtins.property
|
|
815
814
|
@pulumi.getter(name="redirectHttpToHttps")
|
|
816
|
-
def redirect_http_to_https(self) -> Optional[pulumi.Input[
|
|
815
|
+
def redirect_http_to_https(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
817
816
|
"""
|
|
818
817
|
A boolean value indicating whether
|
|
819
818
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
@@ -822,55 +821,55 @@ class _LoadBalancerState:
|
|
|
822
821
|
return pulumi.get(self, "redirect_http_to_https")
|
|
823
822
|
|
|
824
823
|
@redirect_http_to_https.setter
|
|
825
|
-
def redirect_http_to_https(self, value: Optional[pulumi.Input[
|
|
824
|
+
def redirect_http_to_https(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
826
825
|
pulumi.set(self, "redirect_http_to_https", value)
|
|
827
826
|
|
|
828
|
-
@property
|
|
827
|
+
@_builtins.property
|
|
829
828
|
@pulumi.getter
|
|
830
|
-
def region(self) -> Optional[pulumi.Input[Union[
|
|
829
|
+
def region(self) -> Optional[pulumi.Input[Union[_builtins.str, 'Region']]]:
|
|
831
830
|
"""
|
|
832
831
|
The region to start in
|
|
833
832
|
"""
|
|
834
833
|
return pulumi.get(self, "region")
|
|
835
834
|
|
|
836
835
|
@region.setter
|
|
837
|
-
def region(self, value: Optional[pulumi.Input[Union[
|
|
836
|
+
def region(self, value: Optional[pulumi.Input[Union[_builtins.str, 'Region']]]):
|
|
838
837
|
pulumi.set(self, "region", value)
|
|
839
838
|
|
|
840
|
-
@property
|
|
839
|
+
@_builtins.property
|
|
841
840
|
@pulumi.getter
|
|
842
|
-
def size(self) -> Optional[pulumi.Input[
|
|
841
|
+
def size(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
843
842
|
"""
|
|
844
843
|
The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
845
844
|
"""
|
|
846
845
|
return pulumi.get(self, "size")
|
|
847
846
|
|
|
848
847
|
@size.setter
|
|
849
|
-
def size(self, value: Optional[pulumi.Input[
|
|
848
|
+
def size(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
850
849
|
pulumi.set(self, "size", value)
|
|
851
850
|
|
|
852
|
-
@property
|
|
851
|
+
@_builtins.property
|
|
853
852
|
@pulumi.getter(name="sizeUnit")
|
|
854
|
-
def size_unit(self) -> Optional[pulumi.Input[
|
|
853
|
+
def size_unit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
855
854
|
"""
|
|
856
855
|
The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
857
856
|
"""
|
|
858
857
|
return pulumi.get(self, "size_unit")
|
|
859
858
|
|
|
860
859
|
@size_unit.setter
|
|
861
|
-
def size_unit(self, value: Optional[pulumi.Input[
|
|
860
|
+
def size_unit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
862
861
|
pulumi.set(self, "size_unit", value)
|
|
863
862
|
|
|
864
|
-
@property
|
|
863
|
+
@_builtins.property
|
|
865
864
|
@pulumi.getter
|
|
866
|
-
def status(self) -> Optional[pulumi.Input[
|
|
865
|
+
def status(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
867
866
|
return pulumi.get(self, "status")
|
|
868
867
|
|
|
869
868
|
@status.setter
|
|
870
|
-
def status(self, value: Optional[pulumi.Input[
|
|
869
|
+
def status(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
871
870
|
pulumi.set(self, "status", value)
|
|
872
871
|
|
|
873
|
-
@property
|
|
872
|
+
@_builtins.property
|
|
874
873
|
@pulumi.getter(name="stickySessions")
|
|
875
874
|
def sticky_sessions(self) -> Optional[pulumi.Input['LoadBalancerStickySessionsArgs']]:
|
|
876
875
|
"""
|
|
@@ -883,52 +882,52 @@ class _LoadBalancerState:
|
|
|
883
882
|
def sticky_sessions(self, value: Optional[pulumi.Input['LoadBalancerStickySessionsArgs']]):
|
|
884
883
|
pulumi.set(self, "sticky_sessions", value)
|
|
885
884
|
|
|
886
|
-
@property
|
|
885
|
+
@_builtins.property
|
|
887
886
|
@pulumi.getter(name="targetLoadBalancerIds")
|
|
888
|
-
def target_load_balancer_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
887
|
+
def target_load_balancer_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
889
888
|
"""
|
|
890
889
|
A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
891
890
|
"""
|
|
892
891
|
return pulumi.get(self, "target_load_balancer_ids")
|
|
893
892
|
|
|
894
893
|
@target_load_balancer_ids.setter
|
|
895
|
-
def target_load_balancer_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
894
|
+
def target_load_balancer_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
896
895
|
pulumi.set(self, "target_load_balancer_ids", value)
|
|
897
896
|
|
|
898
|
-
@property
|
|
897
|
+
@_builtins.property
|
|
899
898
|
@pulumi.getter(name="tlsCipherPolicy")
|
|
900
|
-
def tls_cipher_policy(self) -> Optional[pulumi.Input[
|
|
899
|
+
def tls_cipher_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
901
900
|
"""
|
|
902
901
|
The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
903
902
|
"""
|
|
904
903
|
return pulumi.get(self, "tls_cipher_policy")
|
|
905
904
|
|
|
906
905
|
@tls_cipher_policy.setter
|
|
907
|
-
def tls_cipher_policy(self, value: Optional[pulumi.Input[
|
|
906
|
+
def tls_cipher_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
908
907
|
pulumi.set(self, "tls_cipher_policy", value)
|
|
909
908
|
|
|
910
|
-
@property
|
|
909
|
+
@_builtins.property
|
|
911
910
|
@pulumi.getter
|
|
912
|
-
def type(self) -> Optional[pulumi.Input[
|
|
911
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
913
912
|
"""
|
|
914
913
|
The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
915
914
|
"""
|
|
916
915
|
return pulumi.get(self, "type")
|
|
917
916
|
|
|
918
917
|
@type.setter
|
|
919
|
-
def type(self, value: Optional[pulumi.Input[
|
|
918
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
920
919
|
pulumi.set(self, "type", value)
|
|
921
920
|
|
|
922
|
-
@property
|
|
921
|
+
@_builtins.property
|
|
923
922
|
@pulumi.getter(name="vpcUuid")
|
|
924
|
-
def vpc_uuid(self) -> Optional[pulumi.Input[
|
|
923
|
+
def vpc_uuid(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
925
924
|
"""
|
|
926
925
|
The ID of the VPC where the load balancer will be located.
|
|
927
926
|
"""
|
|
928
927
|
return pulumi.get(self, "vpc_uuid")
|
|
929
928
|
|
|
930
929
|
@vpc_uuid.setter
|
|
931
|
-
def vpc_uuid(self, value: Optional[pulumi.Input[
|
|
930
|
+
def vpc_uuid(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
932
931
|
pulumi.set(self, "vpc_uuid", value)
|
|
933
932
|
|
|
934
933
|
|
|
@@ -938,31 +937,31 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
938
937
|
def __init__(__self__,
|
|
939
938
|
resource_name: str,
|
|
940
939
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
941
|
-
algorithm: Optional[pulumi.Input[Union[
|
|
942
|
-
disable_lets_encrypt_dns_records: Optional[pulumi.Input[
|
|
940
|
+
algorithm: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]] = None,
|
|
941
|
+
disable_lets_encrypt_dns_records: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
943
942
|
domains: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerDomainArgs', 'LoadBalancerDomainArgsDict']]]]] = None,
|
|
944
|
-
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
945
|
-
droplet_tag: Optional[pulumi.Input[
|
|
946
|
-
enable_backend_keepalive: Optional[pulumi.Input[
|
|
947
|
-
enable_proxy_protocol: Optional[pulumi.Input[
|
|
943
|
+
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
944
|
+
droplet_tag: Optional[pulumi.Input[_builtins.str]] = None,
|
|
945
|
+
enable_backend_keepalive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
946
|
+
enable_proxy_protocol: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
948
947
|
firewall: Optional[pulumi.Input[Union['LoadBalancerFirewallArgs', 'LoadBalancerFirewallArgsDict']]] = None,
|
|
949
948
|
forwarding_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerForwardingRuleArgs', 'LoadBalancerForwardingRuleArgsDict']]]]] = None,
|
|
950
949
|
glb_settings: Optional[pulumi.Input[Union['LoadBalancerGlbSettingsArgs', 'LoadBalancerGlbSettingsArgsDict']]] = None,
|
|
951
950
|
healthcheck: Optional[pulumi.Input[Union['LoadBalancerHealthcheckArgs', 'LoadBalancerHealthcheckArgsDict']]] = None,
|
|
952
|
-
http_idle_timeout_seconds: Optional[pulumi.Input[
|
|
953
|
-
name: Optional[pulumi.Input[
|
|
954
|
-
network: Optional[pulumi.Input[
|
|
955
|
-
network_stack: Optional[pulumi.Input[
|
|
956
|
-
project_id: Optional[pulumi.Input[
|
|
957
|
-
redirect_http_to_https: Optional[pulumi.Input[
|
|
958
|
-
region: Optional[pulumi.Input[Union[
|
|
959
|
-
size: Optional[pulumi.Input[
|
|
960
|
-
size_unit: Optional[pulumi.Input[
|
|
951
|
+
http_idle_timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
952
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
953
|
+
network: Optional[pulumi.Input[_builtins.str]] = None,
|
|
954
|
+
network_stack: Optional[pulumi.Input[_builtins.str]] = None,
|
|
955
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
956
|
+
redirect_http_to_https: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
957
|
+
region: Optional[pulumi.Input[Union[_builtins.str, 'Region']]] = None,
|
|
958
|
+
size: Optional[pulumi.Input[_builtins.str]] = None,
|
|
959
|
+
size_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
961
960
|
sticky_sessions: Optional[pulumi.Input[Union['LoadBalancerStickySessionsArgs', 'LoadBalancerStickySessionsArgsDict']]] = None,
|
|
962
|
-
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
963
|
-
tls_cipher_policy: Optional[pulumi.Input[
|
|
964
|
-
type: Optional[pulumi.Input[
|
|
965
|
-
vpc_uuid: Optional[pulumi.Input[
|
|
961
|
+
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
962
|
+
tls_cipher_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
963
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
964
|
+
vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
966
965
|
__props__=None):
|
|
967
966
|
"""
|
|
968
967
|
Provides a DigitalOcean Load Balancer resource. This can be used to create,
|
|
@@ -1011,14 +1010,14 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1011
1010
|
|
|
1012
1011
|
:param str resource_name: The name of the resource.
|
|
1013
1012
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1014
|
-
:param pulumi.Input[Union[
|
|
1013
|
+
:param pulumi.Input[Union[_builtins.str, 'Algorithm']] algorithm: **Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
1015
1014
|
or `least_connections`. The default value is `round_robin`.
|
|
1016
|
-
:param pulumi.Input[
|
|
1015
|
+
:param pulumi.Input[_builtins.bool] disable_lets_encrypt_dns_records: A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
1017
1016
|
:param pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerDomainArgs', 'LoadBalancerDomainArgsDict']]]] domains: A list of `domains` required to ingress traffic to a Global Load Balancer. The `domains` block is documented below.
|
|
1018
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1019
|
-
:param pulumi.Input[
|
|
1020
|
-
:param pulumi.Input[
|
|
1021
|
-
:param pulumi.Input[
|
|
1017
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] droplet_ids: A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
1018
|
+
:param pulumi.Input[_builtins.str] droplet_tag: The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
1019
|
+
:param pulumi.Input[_builtins.bool] enable_backend_keepalive: A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
1020
|
+
:param pulumi.Input[_builtins.bool] enable_proxy_protocol: A boolean value indicating whether PROXY
|
|
1022
1021
|
Protocol should be used to pass information from connecting client requests to
|
|
1023
1022
|
the backend service. Default value is `false`.
|
|
1024
1023
|
:param pulumi.Input[Union['LoadBalancerFirewallArgs', 'LoadBalancerFirewallArgsDict']] firewall: A block containing rules for allowing/denying traffic to the Load Balancer. The `firewall` block is documented below. Only 1 firewall is allowed.
|
|
@@ -1027,23 +1026,23 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1027
1026
|
:param pulumi.Input[Union['LoadBalancerGlbSettingsArgs', 'LoadBalancerGlbSettingsArgsDict']] glb_settings: A block containing `glb_settings` required to define target rules for a Global Load Balancer. The `glb_settings` block is documented below.
|
|
1028
1027
|
:param pulumi.Input[Union['LoadBalancerHealthcheckArgs', 'LoadBalancerHealthcheckArgsDict']] healthcheck: A `healthcheck` block to be assigned to the
|
|
1029
1028
|
Load Balancer. The `healthcheck` block is documented below. Only 1 healthcheck is allowed.
|
|
1030
|
-
:param pulumi.Input[
|
|
1031
|
-
:param pulumi.Input[
|
|
1032
|
-
:param pulumi.Input[
|
|
1033
|
-
:param pulumi.Input[
|
|
1034
|
-
:param pulumi.Input[
|
|
1035
|
-
:param pulumi.Input[
|
|
1029
|
+
:param pulumi.Input[_builtins.int] http_idle_timeout_seconds: Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
1030
|
+
:param pulumi.Input[_builtins.str] name: The Load Balancer name
|
|
1031
|
+
:param pulumi.Input[_builtins.str] network: The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
1032
|
+
:param pulumi.Input[_builtins.str] network_stack: The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
1033
|
+
:param pulumi.Input[_builtins.str] project_id: The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
1034
|
+
:param pulumi.Input[_builtins.bool] redirect_http_to_https: A boolean value indicating whether
|
|
1036
1035
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
1037
1036
|
Default value is `false`.
|
|
1038
|
-
:param pulumi.Input[Union[
|
|
1039
|
-
:param pulumi.Input[
|
|
1040
|
-
:param pulumi.Input[
|
|
1037
|
+
:param pulumi.Input[Union[_builtins.str, 'Region']] region: The region to start in
|
|
1038
|
+
:param pulumi.Input[_builtins.str] size: The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
1039
|
+
:param pulumi.Input[_builtins.int] size_unit: The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
1041
1040
|
:param pulumi.Input[Union['LoadBalancerStickySessionsArgs', 'LoadBalancerStickySessionsArgsDict']] sticky_sessions: A `sticky_sessions` block to be assigned to the
|
|
1042
1041
|
Load Balancer. The `sticky_sessions` block is documented below. Only 1 sticky_sessions block is allowed.
|
|
1043
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1044
|
-
:param pulumi.Input[
|
|
1045
|
-
:param pulumi.Input[
|
|
1046
|
-
:param pulumi.Input[
|
|
1042
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] target_load_balancer_ids: A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
1043
|
+
:param pulumi.Input[_builtins.str] tls_cipher_policy: The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
1044
|
+
:param pulumi.Input[_builtins.str] type: The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
1045
|
+
:param pulumi.Input[_builtins.str] vpc_uuid: The ID of the VPC where the load balancer will be located.
|
|
1047
1046
|
"""
|
|
1048
1047
|
...
|
|
1049
1048
|
@overload
|
|
@@ -1111,31 +1110,31 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1111
1110
|
def _internal_init(__self__,
|
|
1112
1111
|
resource_name: str,
|
|
1113
1112
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1114
|
-
algorithm: Optional[pulumi.Input[Union[
|
|
1115
|
-
disable_lets_encrypt_dns_records: Optional[pulumi.Input[
|
|
1113
|
+
algorithm: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]] = None,
|
|
1114
|
+
disable_lets_encrypt_dns_records: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1116
1115
|
domains: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerDomainArgs', 'LoadBalancerDomainArgsDict']]]]] = None,
|
|
1117
|
-
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1118
|
-
droplet_tag: Optional[pulumi.Input[
|
|
1119
|
-
enable_backend_keepalive: Optional[pulumi.Input[
|
|
1120
|
-
enable_proxy_protocol: Optional[pulumi.Input[
|
|
1116
|
+
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
1117
|
+
droplet_tag: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1118
|
+
enable_backend_keepalive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1119
|
+
enable_proxy_protocol: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1121
1120
|
firewall: Optional[pulumi.Input[Union['LoadBalancerFirewallArgs', 'LoadBalancerFirewallArgsDict']]] = None,
|
|
1122
1121
|
forwarding_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerForwardingRuleArgs', 'LoadBalancerForwardingRuleArgsDict']]]]] = None,
|
|
1123
1122
|
glb_settings: Optional[pulumi.Input[Union['LoadBalancerGlbSettingsArgs', 'LoadBalancerGlbSettingsArgsDict']]] = None,
|
|
1124
1123
|
healthcheck: Optional[pulumi.Input[Union['LoadBalancerHealthcheckArgs', 'LoadBalancerHealthcheckArgsDict']]] = None,
|
|
1125
|
-
http_idle_timeout_seconds: Optional[pulumi.Input[
|
|
1126
|
-
name: Optional[pulumi.Input[
|
|
1127
|
-
network: Optional[pulumi.Input[
|
|
1128
|
-
network_stack: Optional[pulumi.Input[
|
|
1129
|
-
project_id: Optional[pulumi.Input[
|
|
1130
|
-
redirect_http_to_https: Optional[pulumi.Input[
|
|
1131
|
-
region: Optional[pulumi.Input[Union[
|
|
1132
|
-
size: Optional[pulumi.Input[
|
|
1133
|
-
size_unit: Optional[pulumi.Input[
|
|
1124
|
+
http_idle_timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1125
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1126
|
+
network: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1127
|
+
network_stack: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1128
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1129
|
+
redirect_http_to_https: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1130
|
+
region: Optional[pulumi.Input[Union[_builtins.str, 'Region']]] = None,
|
|
1131
|
+
size: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1132
|
+
size_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1134
1133
|
sticky_sessions: Optional[pulumi.Input[Union['LoadBalancerStickySessionsArgs', 'LoadBalancerStickySessionsArgsDict']]] = None,
|
|
1135
|
-
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1136
|
-
tls_cipher_policy: Optional[pulumi.Input[
|
|
1137
|
-
type: Optional[pulumi.Input[
|
|
1138
|
-
vpc_uuid: Optional[pulumi.Input[
|
|
1134
|
+
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1135
|
+
tls_cipher_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1136
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1137
|
+
vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1139
1138
|
__props__=None):
|
|
1140
1139
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1141
1140
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1184,35 +1183,35 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1184
1183
|
def get(resource_name: str,
|
|
1185
1184
|
id: pulumi.Input[str],
|
|
1186
1185
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1187
|
-
algorithm: Optional[pulumi.Input[Union[
|
|
1188
|
-
disable_lets_encrypt_dns_records: Optional[pulumi.Input[
|
|
1186
|
+
algorithm: Optional[pulumi.Input[Union[_builtins.str, 'Algorithm']]] = None,
|
|
1187
|
+
disable_lets_encrypt_dns_records: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1189
1188
|
domains: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerDomainArgs', 'LoadBalancerDomainArgsDict']]]]] = None,
|
|
1190
|
-
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1191
|
-
droplet_tag: Optional[pulumi.Input[
|
|
1192
|
-
enable_backend_keepalive: Optional[pulumi.Input[
|
|
1193
|
-
enable_proxy_protocol: Optional[pulumi.Input[
|
|
1189
|
+
droplet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
1190
|
+
droplet_tag: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1191
|
+
enable_backend_keepalive: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1192
|
+
enable_proxy_protocol: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1194
1193
|
firewall: Optional[pulumi.Input[Union['LoadBalancerFirewallArgs', 'LoadBalancerFirewallArgsDict']]] = None,
|
|
1195
1194
|
forwarding_rules: Optional[pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerForwardingRuleArgs', 'LoadBalancerForwardingRuleArgsDict']]]]] = None,
|
|
1196
1195
|
glb_settings: Optional[pulumi.Input[Union['LoadBalancerGlbSettingsArgs', 'LoadBalancerGlbSettingsArgsDict']]] = None,
|
|
1197
1196
|
healthcheck: Optional[pulumi.Input[Union['LoadBalancerHealthcheckArgs', 'LoadBalancerHealthcheckArgsDict']]] = None,
|
|
1198
|
-
http_idle_timeout_seconds: Optional[pulumi.Input[
|
|
1199
|
-
ip: Optional[pulumi.Input[
|
|
1200
|
-
ipv6: Optional[pulumi.Input[
|
|
1201
|
-
load_balancer_urn: Optional[pulumi.Input[
|
|
1202
|
-
name: Optional[pulumi.Input[
|
|
1203
|
-
network: Optional[pulumi.Input[
|
|
1204
|
-
network_stack: Optional[pulumi.Input[
|
|
1205
|
-
project_id: Optional[pulumi.Input[
|
|
1206
|
-
redirect_http_to_https: Optional[pulumi.Input[
|
|
1207
|
-
region: Optional[pulumi.Input[Union[
|
|
1208
|
-
size: Optional[pulumi.Input[
|
|
1209
|
-
size_unit: Optional[pulumi.Input[
|
|
1210
|
-
status: Optional[pulumi.Input[
|
|
1197
|
+
http_idle_timeout_seconds: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1198
|
+
ip: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1199
|
+
ipv6: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1200
|
+
load_balancer_urn: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1201
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1202
|
+
network: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1203
|
+
network_stack: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1204
|
+
project_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1205
|
+
redirect_http_to_https: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1206
|
+
region: Optional[pulumi.Input[Union[_builtins.str, 'Region']]] = None,
|
|
1207
|
+
size: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1208
|
+
size_unit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1209
|
+
status: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1211
1210
|
sticky_sessions: Optional[pulumi.Input[Union['LoadBalancerStickySessionsArgs', 'LoadBalancerStickySessionsArgsDict']]] = None,
|
|
1212
|
-
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1213
|
-
tls_cipher_policy: Optional[pulumi.Input[
|
|
1214
|
-
type: Optional[pulumi.Input[
|
|
1215
|
-
vpc_uuid: Optional[pulumi.Input[
|
|
1211
|
+
target_load_balancer_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1212
|
+
tls_cipher_policy: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1213
|
+
type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1214
|
+
vpc_uuid: Optional[pulumi.Input[_builtins.str]] = None) -> 'LoadBalancer':
|
|
1216
1215
|
"""
|
|
1217
1216
|
Get an existing LoadBalancer resource's state with the given name, id, and optional extra
|
|
1218
1217
|
properties used to qualify the lookup.
|
|
@@ -1220,14 +1219,14 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1220
1219
|
:param str resource_name: The unique name of the resulting resource.
|
|
1221
1220
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1222
1221
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1223
|
-
:param pulumi.Input[Union[
|
|
1222
|
+
:param pulumi.Input[Union[_builtins.str, 'Algorithm']] algorithm: **Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
1224
1223
|
or `least_connections`. The default value is `round_robin`.
|
|
1225
|
-
:param pulumi.Input[
|
|
1224
|
+
:param pulumi.Input[_builtins.bool] disable_lets_encrypt_dns_records: A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
1226
1225
|
:param pulumi.Input[Sequence[pulumi.Input[Union['LoadBalancerDomainArgs', 'LoadBalancerDomainArgsDict']]]] domains: A list of `domains` required to ingress traffic to a Global Load Balancer. The `domains` block is documented below.
|
|
1227
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1228
|
-
:param pulumi.Input[
|
|
1229
|
-
:param pulumi.Input[
|
|
1230
|
-
:param pulumi.Input[
|
|
1226
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] droplet_ids: A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
1227
|
+
:param pulumi.Input[_builtins.str] droplet_tag: The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
1228
|
+
:param pulumi.Input[_builtins.bool] enable_backend_keepalive: A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
1229
|
+
:param pulumi.Input[_builtins.bool] enable_proxy_protocol: A boolean value indicating whether PROXY
|
|
1231
1230
|
Protocol should be used to pass information from connecting client requests to
|
|
1232
1231
|
the backend service. Default value is `false`.
|
|
1233
1232
|
:param pulumi.Input[Union['LoadBalancerFirewallArgs', 'LoadBalancerFirewallArgsDict']] firewall: A block containing rules for allowing/denying traffic to the Load Balancer. The `firewall` block is documented below. Only 1 firewall is allowed.
|
|
@@ -1236,25 +1235,25 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1236
1235
|
:param pulumi.Input[Union['LoadBalancerGlbSettingsArgs', 'LoadBalancerGlbSettingsArgsDict']] glb_settings: A block containing `glb_settings` required to define target rules for a Global Load Balancer. The `glb_settings` block is documented below.
|
|
1237
1236
|
:param pulumi.Input[Union['LoadBalancerHealthcheckArgs', 'LoadBalancerHealthcheckArgsDict']] healthcheck: A `healthcheck` block to be assigned to the
|
|
1238
1237
|
Load Balancer. The `healthcheck` block is documented below. Only 1 healthcheck is allowed.
|
|
1239
|
-
:param pulumi.Input[
|
|
1240
|
-
:param pulumi.Input[
|
|
1241
|
-
:param pulumi.Input[
|
|
1242
|
-
:param pulumi.Input[
|
|
1243
|
-
:param pulumi.Input[
|
|
1244
|
-
:param pulumi.Input[
|
|
1245
|
-
:param pulumi.Input[
|
|
1246
|
-
:param pulumi.Input[
|
|
1238
|
+
:param pulumi.Input[_builtins.int] http_idle_timeout_seconds: Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
1239
|
+
:param pulumi.Input[_builtins.str] ip: The ip of the Load Balancer
|
|
1240
|
+
:param pulumi.Input[_builtins.str] load_balancer_urn: The uniform resource name for the Load Balancer
|
|
1241
|
+
:param pulumi.Input[_builtins.str] name: The Load Balancer name
|
|
1242
|
+
:param pulumi.Input[_builtins.str] network: The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
1243
|
+
:param pulumi.Input[_builtins.str] network_stack: The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
1244
|
+
:param pulumi.Input[_builtins.str] project_id: The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
1245
|
+
:param pulumi.Input[_builtins.bool] redirect_http_to_https: A boolean value indicating whether
|
|
1247
1246
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
1248
1247
|
Default value is `false`.
|
|
1249
|
-
:param pulumi.Input[Union[
|
|
1250
|
-
:param pulumi.Input[
|
|
1251
|
-
:param pulumi.Input[
|
|
1248
|
+
:param pulumi.Input[Union[_builtins.str, 'Region']] region: The region to start in
|
|
1249
|
+
:param pulumi.Input[_builtins.str] size: The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
1250
|
+
:param pulumi.Input[_builtins.int] size_unit: The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
1252
1251
|
:param pulumi.Input[Union['LoadBalancerStickySessionsArgs', 'LoadBalancerStickySessionsArgsDict']] sticky_sessions: A `sticky_sessions` block to be assigned to the
|
|
1253
1252
|
Load Balancer. The `sticky_sessions` block is documented below. Only 1 sticky_sessions block is allowed.
|
|
1254
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1255
|
-
:param pulumi.Input[
|
|
1256
|
-
:param pulumi.Input[
|
|
1257
|
-
:param pulumi.Input[
|
|
1253
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] target_load_balancer_ids: A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
1254
|
+
:param pulumi.Input[_builtins.str] tls_cipher_policy: The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
1255
|
+
:param pulumi.Input[_builtins.str] type: The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
1256
|
+
:param pulumi.Input[_builtins.str] vpc_uuid: The ID of the VPC where the load balancer will be located.
|
|
1258
1257
|
"""
|
|
1259
1258
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1260
1259
|
|
|
@@ -1291,25 +1290,25 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1291
1290
|
__props__.__dict__["vpc_uuid"] = vpc_uuid
|
|
1292
1291
|
return LoadBalancer(resource_name, opts=opts, __props__=__props__)
|
|
1293
1292
|
|
|
1294
|
-
@property
|
|
1293
|
+
@_builtins.property
|
|
1295
1294
|
@pulumi.getter
|
|
1296
1295
|
@_utilities.deprecated("""This field has been deprecated. You can no longer specify an algorithm for load balancers.""")
|
|
1297
|
-
def algorithm(self) -> pulumi.Output[Optional[
|
|
1296
|
+
def algorithm(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1298
1297
|
"""
|
|
1299
1298
|
**Deprecated** This field has been deprecated. You can no longer specify an algorithm for load balancers.
|
|
1300
1299
|
or `least_connections`. The default value is `round_robin`.
|
|
1301
1300
|
"""
|
|
1302
1301
|
return pulumi.get(self, "algorithm")
|
|
1303
1302
|
|
|
1304
|
-
@property
|
|
1303
|
+
@_builtins.property
|
|
1305
1304
|
@pulumi.getter(name="disableLetsEncryptDnsRecords")
|
|
1306
|
-
def disable_lets_encrypt_dns_records(self) -> pulumi.Output[Optional[
|
|
1305
|
+
def disable_lets_encrypt_dns_records(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1307
1306
|
"""
|
|
1308
1307
|
A boolean value indicating whether to disable automatic DNS record creation for Let's Encrypt certificates that are added to the load balancer. Default value is `false`.
|
|
1309
1308
|
"""
|
|
1310
1309
|
return pulumi.get(self, "disable_lets_encrypt_dns_records")
|
|
1311
1310
|
|
|
1312
|
-
@property
|
|
1311
|
+
@_builtins.property
|
|
1313
1312
|
@pulumi.getter
|
|
1314
1313
|
def domains(self) -> pulumi.Output[Sequence['outputs.LoadBalancerDomain']]:
|
|
1315
1314
|
"""
|
|
@@ -1317,33 +1316,33 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1317
1316
|
"""
|
|
1318
1317
|
return pulumi.get(self, "domains")
|
|
1319
1318
|
|
|
1320
|
-
@property
|
|
1319
|
+
@_builtins.property
|
|
1321
1320
|
@pulumi.getter(name="dropletIds")
|
|
1322
|
-
def droplet_ids(self) -> pulumi.Output[Sequence[
|
|
1321
|
+
def droplet_ids(self) -> pulumi.Output[Sequence[_builtins.int]]:
|
|
1323
1322
|
"""
|
|
1324
1323
|
A list of the IDs of each droplet to be attached to the Load Balancer.
|
|
1325
1324
|
"""
|
|
1326
1325
|
return pulumi.get(self, "droplet_ids")
|
|
1327
1326
|
|
|
1328
|
-
@property
|
|
1327
|
+
@_builtins.property
|
|
1329
1328
|
@pulumi.getter(name="dropletTag")
|
|
1330
|
-
def droplet_tag(self) -> pulumi.Output[Optional[
|
|
1329
|
+
def droplet_tag(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1331
1330
|
"""
|
|
1332
1331
|
The name of a Droplet tag corresponding to Droplets to be assigned to the Load Balancer.
|
|
1333
1332
|
"""
|
|
1334
1333
|
return pulumi.get(self, "droplet_tag")
|
|
1335
1334
|
|
|
1336
|
-
@property
|
|
1335
|
+
@_builtins.property
|
|
1337
1336
|
@pulumi.getter(name="enableBackendKeepalive")
|
|
1338
|
-
def enable_backend_keepalive(self) -> pulumi.Output[Optional[
|
|
1337
|
+
def enable_backend_keepalive(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1339
1338
|
"""
|
|
1340
1339
|
A boolean value indicating whether HTTP keepalive connections are maintained to target Droplets. Default value is `false`.
|
|
1341
1340
|
"""
|
|
1342
1341
|
return pulumi.get(self, "enable_backend_keepalive")
|
|
1343
1342
|
|
|
1344
|
-
@property
|
|
1343
|
+
@_builtins.property
|
|
1345
1344
|
@pulumi.getter(name="enableProxyProtocol")
|
|
1346
|
-
def enable_proxy_protocol(self) -> pulumi.Output[Optional[
|
|
1345
|
+
def enable_proxy_protocol(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1347
1346
|
"""
|
|
1348
1347
|
A boolean value indicating whether PROXY
|
|
1349
1348
|
Protocol should be used to pass information from connecting client requests to
|
|
@@ -1351,7 +1350,7 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1351
1350
|
"""
|
|
1352
1351
|
return pulumi.get(self, "enable_proxy_protocol")
|
|
1353
1352
|
|
|
1354
|
-
@property
|
|
1353
|
+
@_builtins.property
|
|
1355
1354
|
@pulumi.getter
|
|
1356
1355
|
def firewall(self) -> pulumi.Output['outputs.LoadBalancerFirewall']:
|
|
1357
1356
|
"""
|
|
@@ -1359,7 +1358,7 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1359
1358
|
"""
|
|
1360
1359
|
return pulumi.get(self, "firewall")
|
|
1361
1360
|
|
|
1362
|
-
@property
|
|
1361
|
+
@_builtins.property
|
|
1363
1362
|
@pulumi.getter(name="forwardingRules")
|
|
1364
1363
|
def forwarding_rules(self) -> pulumi.Output[Optional[Sequence['outputs.LoadBalancerForwardingRule']]]:
|
|
1365
1364
|
"""
|
|
@@ -1368,7 +1367,7 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1368
1367
|
"""
|
|
1369
1368
|
return pulumi.get(self, "forwarding_rules")
|
|
1370
1369
|
|
|
1371
|
-
@property
|
|
1370
|
+
@_builtins.property
|
|
1372
1371
|
@pulumi.getter(name="glbSettings")
|
|
1373
1372
|
def glb_settings(self) -> pulumi.Output['outputs.LoadBalancerGlbSettings']:
|
|
1374
1373
|
"""
|
|
@@ -1376,7 +1375,7 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1376
1375
|
"""
|
|
1377
1376
|
return pulumi.get(self, "glb_settings")
|
|
1378
1377
|
|
|
1379
|
-
@property
|
|
1378
|
+
@_builtins.property
|
|
1380
1379
|
@pulumi.getter
|
|
1381
1380
|
def healthcheck(self) -> pulumi.Output['outputs.LoadBalancerHealthcheck']:
|
|
1382
1381
|
"""
|
|
@@ -1385,70 +1384,70 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1385
1384
|
"""
|
|
1386
1385
|
return pulumi.get(self, "healthcheck")
|
|
1387
1386
|
|
|
1388
|
-
@property
|
|
1387
|
+
@_builtins.property
|
|
1389
1388
|
@pulumi.getter(name="httpIdleTimeoutSeconds")
|
|
1390
|
-
def http_idle_timeout_seconds(self) -> pulumi.Output[
|
|
1389
|
+
def http_idle_timeout_seconds(self) -> pulumi.Output[_builtins.int]:
|
|
1391
1390
|
"""
|
|
1392
1391
|
Specifies the idle timeout for HTTPS connections on the load balancer in seconds.
|
|
1393
1392
|
"""
|
|
1394
1393
|
return pulumi.get(self, "http_idle_timeout_seconds")
|
|
1395
1394
|
|
|
1396
|
-
@property
|
|
1395
|
+
@_builtins.property
|
|
1397
1396
|
@pulumi.getter
|
|
1398
|
-
def ip(self) -> pulumi.Output[
|
|
1397
|
+
def ip(self) -> pulumi.Output[_builtins.str]:
|
|
1399
1398
|
"""
|
|
1400
1399
|
The ip of the Load Balancer
|
|
1401
1400
|
"""
|
|
1402
1401
|
return pulumi.get(self, "ip")
|
|
1403
1402
|
|
|
1404
|
-
@property
|
|
1403
|
+
@_builtins.property
|
|
1405
1404
|
@pulumi.getter
|
|
1406
|
-
def ipv6(self) -> pulumi.Output[
|
|
1405
|
+
def ipv6(self) -> pulumi.Output[_builtins.str]:
|
|
1407
1406
|
return pulumi.get(self, "ipv6")
|
|
1408
1407
|
|
|
1409
|
-
@property
|
|
1408
|
+
@_builtins.property
|
|
1410
1409
|
@pulumi.getter(name="loadBalancerUrn")
|
|
1411
|
-
def load_balancer_urn(self) -> pulumi.Output[
|
|
1410
|
+
def load_balancer_urn(self) -> pulumi.Output[_builtins.str]:
|
|
1412
1411
|
"""
|
|
1413
1412
|
The uniform resource name for the Load Balancer
|
|
1414
1413
|
"""
|
|
1415
1414
|
return pulumi.get(self, "load_balancer_urn")
|
|
1416
1415
|
|
|
1417
|
-
@property
|
|
1416
|
+
@_builtins.property
|
|
1418
1417
|
@pulumi.getter
|
|
1419
|
-
def name(self) -> pulumi.Output[
|
|
1418
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1420
1419
|
"""
|
|
1421
1420
|
The Load Balancer name
|
|
1422
1421
|
"""
|
|
1423
1422
|
return pulumi.get(self, "name")
|
|
1424
1423
|
|
|
1425
|
-
@property
|
|
1424
|
+
@_builtins.property
|
|
1426
1425
|
@pulumi.getter
|
|
1427
|
-
def network(self) -> pulumi.Output[Optional[
|
|
1426
|
+
def network(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1428
1427
|
"""
|
|
1429
1428
|
The type of network the Load Balancer is accessible from. It must be either of `INTERNAL` or `EXTERNAL`. Defaults to `EXTERNAL`.
|
|
1430
1429
|
"""
|
|
1431
1430
|
return pulumi.get(self, "network")
|
|
1432
1431
|
|
|
1433
|
-
@property
|
|
1432
|
+
@_builtins.property
|
|
1434
1433
|
@pulumi.getter(name="networkStack")
|
|
1435
|
-
def network_stack(self) -> pulumi.Output[Optional[
|
|
1434
|
+
def network_stack(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1436
1435
|
"""
|
|
1437
1436
|
The network stack determines the allocation of ipv4/ipv6 addresses to the load balancer. It must be either of `IPV4` or `DUALSTACK`. Defaults to `IPV4`.
|
|
1438
1437
|
"""
|
|
1439
1438
|
return pulumi.get(self, "network_stack")
|
|
1440
1439
|
|
|
1441
|
-
@property
|
|
1440
|
+
@_builtins.property
|
|
1442
1441
|
@pulumi.getter(name="projectId")
|
|
1443
|
-
def project_id(self) -> pulumi.Output[
|
|
1442
|
+
def project_id(self) -> pulumi.Output[_builtins.str]:
|
|
1444
1443
|
"""
|
|
1445
1444
|
The ID of the project that the load balancer is associated with. If no ID is provided at creation, the load balancer associates with the user's default project.
|
|
1446
1445
|
"""
|
|
1447
1446
|
return pulumi.get(self, "project_id")
|
|
1448
1447
|
|
|
1449
|
-
@property
|
|
1448
|
+
@_builtins.property
|
|
1450
1449
|
@pulumi.getter(name="redirectHttpToHttps")
|
|
1451
|
-
def redirect_http_to_https(self) -> pulumi.Output[Optional[
|
|
1450
|
+
def redirect_http_to_https(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1452
1451
|
"""
|
|
1453
1452
|
A boolean value indicating whether
|
|
1454
1453
|
HTTP requests to the Load Balancer on port 80 will be redirected to HTTPS on port 443.
|
|
@@ -1456,36 +1455,36 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1456
1455
|
"""
|
|
1457
1456
|
return pulumi.get(self, "redirect_http_to_https")
|
|
1458
1457
|
|
|
1459
|
-
@property
|
|
1458
|
+
@_builtins.property
|
|
1460
1459
|
@pulumi.getter
|
|
1461
|
-
def region(self) -> pulumi.Output[Optional[
|
|
1460
|
+
def region(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1462
1461
|
"""
|
|
1463
1462
|
The region to start in
|
|
1464
1463
|
"""
|
|
1465
1464
|
return pulumi.get(self, "region")
|
|
1466
1465
|
|
|
1467
|
-
@property
|
|
1466
|
+
@_builtins.property
|
|
1468
1467
|
@pulumi.getter
|
|
1469
|
-
def size(self) -> pulumi.Output[Optional[
|
|
1468
|
+
def size(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1470
1469
|
"""
|
|
1471
1470
|
The size of the Load Balancer. It must be either `lb-small`, `lb-medium`, or `lb-large`. Defaults to `lb-small`. Only one of `size` or `size_unit` may be provided.
|
|
1472
1471
|
"""
|
|
1473
1472
|
return pulumi.get(self, "size")
|
|
1474
1473
|
|
|
1475
|
-
@property
|
|
1474
|
+
@_builtins.property
|
|
1476
1475
|
@pulumi.getter(name="sizeUnit")
|
|
1477
|
-
def size_unit(self) -> pulumi.Output[
|
|
1476
|
+
def size_unit(self) -> pulumi.Output[_builtins.int]:
|
|
1478
1477
|
"""
|
|
1479
1478
|
The size of the Load Balancer. It must be in the range (1, 200). Defaults to `1`. Only one of `size` or `size_unit` may be provided.
|
|
1480
1479
|
"""
|
|
1481
1480
|
return pulumi.get(self, "size_unit")
|
|
1482
1481
|
|
|
1483
|
-
@property
|
|
1482
|
+
@_builtins.property
|
|
1484
1483
|
@pulumi.getter
|
|
1485
|
-
def status(self) -> pulumi.Output[
|
|
1484
|
+
def status(self) -> pulumi.Output[_builtins.str]:
|
|
1486
1485
|
return pulumi.get(self, "status")
|
|
1487
1486
|
|
|
1488
|
-
@property
|
|
1487
|
+
@_builtins.property
|
|
1489
1488
|
@pulumi.getter(name="stickySessions")
|
|
1490
1489
|
def sticky_sessions(self) -> pulumi.Output['outputs.LoadBalancerStickySessions']:
|
|
1491
1490
|
"""
|
|
@@ -1494,33 +1493,33 @@ class LoadBalancer(pulumi.CustomResource):
|
|
|
1494
1493
|
"""
|
|
1495
1494
|
return pulumi.get(self, "sticky_sessions")
|
|
1496
1495
|
|
|
1497
|
-
@property
|
|
1496
|
+
@_builtins.property
|
|
1498
1497
|
@pulumi.getter(name="targetLoadBalancerIds")
|
|
1499
|
-
def target_load_balancer_ids(self) -> pulumi.Output[Sequence[
|
|
1498
|
+
def target_load_balancer_ids(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1500
1499
|
"""
|
|
1501
1500
|
A list of Load Balancer IDs to be attached behind a Global Load Balancer.
|
|
1502
1501
|
"""
|
|
1503
1502
|
return pulumi.get(self, "target_load_balancer_ids")
|
|
1504
1503
|
|
|
1505
|
-
@property
|
|
1504
|
+
@_builtins.property
|
|
1506
1505
|
@pulumi.getter(name="tlsCipherPolicy")
|
|
1507
|
-
def tls_cipher_policy(self) -> pulumi.Output[Optional[
|
|
1506
|
+
def tls_cipher_policy(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1508
1507
|
"""
|
|
1509
1508
|
The tls cipher policy controls the cipher suites to be used by the load balancer. It must be either of `DEFAULT` or `STRONG`. Defaults to `DEFAULT`.
|
|
1510
1509
|
"""
|
|
1511
1510
|
return pulumi.get(self, "tls_cipher_policy")
|
|
1512
1511
|
|
|
1513
|
-
@property
|
|
1512
|
+
@_builtins.property
|
|
1514
1513
|
@pulumi.getter
|
|
1515
|
-
def type(self) -> pulumi.Output[
|
|
1514
|
+
def type(self) -> pulumi.Output[_builtins.str]:
|
|
1516
1515
|
"""
|
|
1517
1516
|
The type of the Load Balancer. It must be either of `REGIONAL`, `REGIONAL_NETWORK`, or `GLOBAL`. Defaults to `REGIONAL`.
|
|
1518
1517
|
"""
|
|
1519
1518
|
return pulumi.get(self, "type")
|
|
1520
1519
|
|
|
1521
|
-
@property
|
|
1520
|
+
@_builtins.property
|
|
1522
1521
|
@pulumi.getter(name="vpcUuid")
|
|
1523
|
-
def vpc_uuid(self) -> pulumi.Output[
|
|
1522
|
+
def vpc_uuid(self) -> pulumi.Output[_builtins.str]:
|
|
1524
1523
|
"""
|
|
1525
1524
|
The ID of the VPC where the load balancer will be located.
|
|
1526
1525
|
"""
|