pulumi-hcloud 1.24.0a1753336797__py3-none-any.whl → 1.24.0a1753760751__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.
- pulumi_hcloud/__init__.py +1 -1
- pulumi_hcloud/_inputs.py +281 -282
- pulumi_hcloud/certificate.py +95 -96
- pulumi_hcloud/config/__init__.py +1 -1
- pulumi_hcloud/config/__init__.pyi +1 -2
- pulumi_hcloud/config/vars.py +5 -6
- pulumi_hcloud/firewall.py +41 -42
- pulumi_hcloud/firewall_attachment.py +52 -53
- pulumi_hcloud/floating_ip.py +138 -139
- pulumi_hcloud/floating_ip_assignment.py +35 -36
- pulumi_hcloud/get_certificate.py +35 -36
- pulumi_hcloud/get_certificates.py +10 -11
- pulumi_hcloud/get_datacenter.py +21 -22
- pulumi_hcloud/get_datacenters.py +10 -11
- pulumi_hcloud/get_firewall.py +33 -34
- pulumi_hcloud/get_firewalls.py +16 -17
- pulumi_hcloud/get_floating_ip.py +43 -44
- pulumi_hcloud/get_floating_ips.py +10 -11
- pulumi_hcloud/get_image.py +65 -66
- pulumi_hcloud/get_images.py +34 -35
- pulumi_hcloud/get_load_balancer.py +40 -41
- pulumi_hcloud/get_load_balancer_type.py +23 -24
- pulumi_hcloud/get_load_balancer_types.py +4 -5
- pulumi_hcloud/get_load_balancers.py +10 -11
- pulumi_hcloud/get_location.py +25 -26
- pulumi_hcloud/get_locations.py +10 -11
- pulumi_hcloud/get_network.py +37 -38
- pulumi_hcloud/get_networks.py +10 -11
- pulumi_hcloud/get_placement_group.py +39 -40
- pulumi_hcloud/get_placement_groups.py +16 -17
- pulumi_hcloud/get_primary_ip.py +45 -46
- pulumi_hcloud/get_primary_ips.py +10 -11
- pulumi_hcloud/get_server.py +70 -71
- pulumi_hcloud/get_server_type.py +35 -36
- pulumi_hcloud/get_server_types.py +10 -11
- pulumi_hcloud/get_servers.py +16 -17
- pulumi_hcloud/get_ssh_key.py +38 -39
- pulumi_hcloud/get_ssh_keys.py +15 -16
- pulumi_hcloud/get_volume.py +49 -50
- pulumi_hcloud/get_volumes.py +16 -17
- pulumi_hcloud/load_balancer.py +145 -146
- pulumi_hcloud/load_balancer_network.py +86 -87
- pulumi_hcloud/load_balancer_service.py +92 -93
- pulumi_hcloud/load_balancer_target.py +103 -104
- pulumi_hcloud/managed_certificate.py +104 -105
- pulumi_hcloud/network.py +86 -87
- pulumi_hcloud/network_route.py +52 -53
- pulumi_hcloud/network_subnet.py +93 -94
- pulumi_hcloud/outputs.py +848 -849
- pulumi_hcloud/placement_group.py +59 -60
- pulumi_hcloud/primary_ip.py +155 -156
- pulumi_hcloud/provider.py +42 -43
- pulumi_hcloud/pulumi-plugin.json +1 -1
- pulumi_hcloud/rdns.py +103 -104
- pulumi_hcloud/server.py +380 -381
- pulumi_hcloud/server_network.py +93 -94
- pulumi_hcloud/snapshot.py +52 -53
- pulumi_hcloud/ssh_key.py +92 -65
- pulumi_hcloud/uploaded_certificate.py +121 -122
- pulumi_hcloud/volume.py +146 -147
- pulumi_hcloud/volume_attachment.py +52 -53
- {pulumi_hcloud-1.24.0a1753336797.dist-info → pulumi_hcloud-1.24.0a1753760751.dist-info}/METADATA +1 -1
- pulumi_hcloud-1.24.0a1753760751.dist-info/RECORD +67 -0
- pulumi_hcloud-1.24.0a1753336797.dist-info/RECORD +0 -67
- {pulumi_hcloud-1.24.0a1753336797.dist-info → pulumi_hcloud-1.24.0a1753760751.dist-info}/WHEEL +0 -0
- {pulumi_hcloud-1.24.0a1753336797.dist-info → pulumi_hcloud-1.24.0a1753760751.dist-info}/top_level.txt +0 -0
pulumi_hcloud/_inputs.py
CHANGED
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -46,12 +45,12 @@ MYPY = False
|
|
|
46
45
|
|
|
47
46
|
if not MYPY:
|
|
48
47
|
class FirewallApplyToArgsDict(TypedDict):
|
|
49
|
-
label_selector: NotRequired[pulumi.Input[
|
|
48
|
+
label_selector: NotRequired[pulumi.Input[_builtins.str]]
|
|
50
49
|
"""
|
|
51
50
|
Label Selector to select servers the firewall should be applied to (only one
|
|
52
51
|
of `server` and `label_selector`can be applied in one block)
|
|
53
52
|
"""
|
|
54
|
-
server: NotRequired[pulumi.Input[
|
|
53
|
+
server: NotRequired[pulumi.Input[_builtins.int]]
|
|
55
54
|
"""
|
|
56
55
|
ID of the server you want to apply the firewall to (only one of `server`
|
|
57
56
|
and `label_selector`can be applied in one block)
|
|
@@ -62,12 +61,12 @@ elif False:
|
|
|
62
61
|
@pulumi.input_type
|
|
63
62
|
class FirewallApplyToArgs:
|
|
64
63
|
def __init__(__self__, *,
|
|
65
|
-
label_selector: Optional[pulumi.Input[
|
|
66
|
-
server: Optional[pulumi.Input[
|
|
64
|
+
label_selector: Optional[pulumi.Input[_builtins.str]] = None,
|
|
65
|
+
server: Optional[pulumi.Input[_builtins.int]] = None):
|
|
67
66
|
"""
|
|
68
|
-
:param pulumi.Input[
|
|
67
|
+
:param pulumi.Input[_builtins.str] label_selector: Label Selector to select servers the firewall should be applied to (only one
|
|
69
68
|
of `server` and `label_selector`can be applied in one block)
|
|
70
|
-
:param pulumi.Input[
|
|
69
|
+
:param pulumi.Input[_builtins.int] server: ID of the server you want to apply the firewall to (only one of `server`
|
|
71
70
|
and `label_selector`can be applied in one block)
|
|
72
71
|
"""
|
|
73
72
|
if label_selector is not None:
|
|
@@ -75,9 +74,9 @@ class FirewallApplyToArgs:
|
|
|
75
74
|
if server is not None:
|
|
76
75
|
pulumi.set(__self__, "server", server)
|
|
77
76
|
|
|
78
|
-
@property
|
|
77
|
+
@_builtins.property
|
|
79
78
|
@pulumi.getter(name="labelSelector")
|
|
80
|
-
def label_selector(self) -> Optional[pulumi.Input[
|
|
79
|
+
def label_selector(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
81
80
|
"""
|
|
82
81
|
Label Selector to select servers the firewall should be applied to (only one
|
|
83
82
|
of `server` and `label_selector`can be applied in one block)
|
|
@@ -85,12 +84,12 @@ class FirewallApplyToArgs:
|
|
|
85
84
|
return pulumi.get(self, "label_selector")
|
|
86
85
|
|
|
87
86
|
@label_selector.setter
|
|
88
|
-
def label_selector(self, value: Optional[pulumi.Input[
|
|
87
|
+
def label_selector(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
89
88
|
pulumi.set(self, "label_selector", value)
|
|
90
89
|
|
|
91
|
-
@property
|
|
90
|
+
@_builtins.property
|
|
92
91
|
@pulumi.getter
|
|
93
|
-
def server(self) -> Optional[pulumi.Input[
|
|
92
|
+
def server(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
94
93
|
"""
|
|
95
94
|
ID of the server you want to apply the firewall to (only one of `server`
|
|
96
95
|
and `label_selector`can be applied in one block)
|
|
@@ -98,35 +97,35 @@ class FirewallApplyToArgs:
|
|
|
98
97
|
return pulumi.get(self, "server")
|
|
99
98
|
|
|
100
99
|
@server.setter
|
|
101
|
-
def server(self, value: Optional[pulumi.Input[
|
|
100
|
+
def server(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
102
101
|
pulumi.set(self, "server", value)
|
|
103
102
|
|
|
104
103
|
|
|
105
104
|
if not MYPY:
|
|
106
105
|
class FirewallRuleArgsDict(TypedDict):
|
|
107
|
-
direction: pulumi.Input[
|
|
106
|
+
direction: pulumi.Input[_builtins.str]
|
|
108
107
|
"""
|
|
109
108
|
Direction of the Firewall Rule. `in`
|
|
110
109
|
"""
|
|
111
|
-
protocol: pulumi.Input[
|
|
110
|
+
protocol: pulumi.Input[_builtins.str]
|
|
112
111
|
"""
|
|
113
112
|
Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
114
113
|
"""
|
|
115
|
-
description: NotRequired[pulumi.Input[
|
|
114
|
+
description: NotRequired[pulumi.Input[_builtins.str]]
|
|
116
115
|
"""
|
|
117
116
|
Description of the firewall rule
|
|
118
117
|
"""
|
|
119
|
-
destination_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
118
|
+
destination_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
120
119
|
"""
|
|
121
120
|
List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
122
121
|
is `out`)
|
|
123
122
|
"""
|
|
124
|
-
port: NotRequired[pulumi.Input[
|
|
123
|
+
port: NotRequired[pulumi.Input[_builtins.str]]
|
|
125
124
|
"""
|
|
126
125
|
Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
|
|
127
126
|
to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
|
|
128
127
|
"""
|
|
129
|
-
source_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
128
|
+
source_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
130
129
|
"""
|
|
131
130
|
List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
132
131
|
is `in`)
|
|
@@ -137,21 +136,21 @@ elif False:
|
|
|
137
136
|
@pulumi.input_type
|
|
138
137
|
class FirewallRuleArgs:
|
|
139
138
|
def __init__(__self__, *,
|
|
140
|
-
direction: pulumi.Input[
|
|
141
|
-
protocol: pulumi.Input[
|
|
142
|
-
description: Optional[pulumi.Input[
|
|
143
|
-
destination_ips: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
144
|
-
port: Optional[pulumi.Input[
|
|
145
|
-
source_ips: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
146
|
-
"""
|
|
147
|
-
:param pulumi.Input[
|
|
148
|
-
:param pulumi.Input[
|
|
149
|
-
:param pulumi.Input[
|
|
150
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
139
|
+
direction: pulumi.Input[_builtins.str],
|
|
140
|
+
protocol: pulumi.Input[_builtins.str],
|
|
141
|
+
description: Optional[pulumi.Input[_builtins.str]] = None,
|
|
142
|
+
destination_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
143
|
+
port: Optional[pulumi.Input[_builtins.str]] = None,
|
|
144
|
+
source_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
145
|
+
"""
|
|
146
|
+
:param pulumi.Input[_builtins.str] direction: Direction of the Firewall Rule. `in`
|
|
147
|
+
:param pulumi.Input[_builtins.str] protocol: Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
148
|
+
:param pulumi.Input[_builtins.str] description: Description of the firewall rule
|
|
149
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] destination_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
151
150
|
is `out`)
|
|
152
|
-
:param pulumi.Input[
|
|
151
|
+
:param pulumi.Input[_builtins.str] port: Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
|
|
153
152
|
to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
|
|
154
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
153
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] source_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
155
154
|
is `in`)
|
|
156
155
|
"""
|
|
157
156
|
pulumi.set(__self__, "direction", direction)
|
|
@@ -165,45 +164,45 @@ class FirewallRuleArgs:
|
|
|
165
164
|
if source_ips is not None:
|
|
166
165
|
pulumi.set(__self__, "source_ips", source_ips)
|
|
167
166
|
|
|
168
|
-
@property
|
|
167
|
+
@_builtins.property
|
|
169
168
|
@pulumi.getter
|
|
170
|
-
def direction(self) -> pulumi.Input[
|
|
169
|
+
def direction(self) -> pulumi.Input[_builtins.str]:
|
|
171
170
|
"""
|
|
172
171
|
Direction of the Firewall Rule. `in`
|
|
173
172
|
"""
|
|
174
173
|
return pulumi.get(self, "direction")
|
|
175
174
|
|
|
176
175
|
@direction.setter
|
|
177
|
-
def direction(self, value: pulumi.Input[
|
|
176
|
+
def direction(self, value: pulumi.Input[_builtins.str]):
|
|
178
177
|
pulumi.set(self, "direction", value)
|
|
179
178
|
|
|
180
|
-
@property
|
|
179
|
+
@_builtins.property
|
|
181
180
|
@pulumi.getter
|
|
182
|
-
def protocol(self) -> pulumi.Input[
|
|
181
|
+
def protocol(self) -> pulumi.Input[_builtins.str]:
|
|
183
182
|
"""
|
|
184
183
|
Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
185
184
|
"""
|
|
186
185
|
return pulumi.get(self, "protocol")
|
|
187
186
|
|
|
188
187
|
@protocol.setter
|
|
189
|
-
def protocol(self, value: pulumi.Input[
|
|
188
|
+
def protocol(self, value: pulumi.Input[_builtins.str]):
|
|
190
189
|
pulumi.set(self, "protocol", value)
|
|
191
190
|
|
|
192
|
-
@property
|
|
191
|
+
@_builtins.property
|
|
193
192
|
@pulumi.getter
|
|
194
|
-
def description(self) -> Optional[pulumi.Input[
|
|
193
|
+
def description(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
195
194
|
"""
|
|
196
195
|
Description of the firewall rule
|
|
197
196
|
"""
|
|
198
197
|
return pulumi.get(self, "description")
|
|
199
198
|
|
|
200
199
|
@description.setter
|
|
201
|
-
def description(self, value: Optional[pulumi.Input[
|
|
200
|
+
def description(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
202
201
|
pulumi.set(self, "description", value)
|
|
203
202
|
|
|
204
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
205
204
|
@pulumi.getter(name="destinationIps")
|
|
206
|
-
def destination_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
205
|
+
def destination_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
207
206
|
"""
|
|
208
207
|
List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
209
208
|
is `out`)
|
|
@@ -211,12 +210,12 @@ class FirewallRuleArgs:
|
|
|
211
210
|
return pulumi.get(self, "destination_ips")
|
|
212
211
|
|
|
213
212
|
@destination_ips.setter
|
|
214
|
-
def destination_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
213
|
+
def destination_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
215
214
|
pulumi.set(self, "destination_ips", value)
|
|
216
215
|
|
|
217
|
-
@property
|
|
216
|
+
@_builtins.property
|
|
218
217
|
@pulumi.getter
|
|
219
|
-
def port(self) -> Optional[pulumi.Input[
|
|
218
|
+
def port(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
220
219
|
"""
|
|
221
220
|
Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
|
|
222
221
|
to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
|
|
@@ -224,12 +223,12 @@ class FirewallRuleArgs:
|
|
|
224
223
|
return pulumi.get(self, "port")
|
|
225
224
|
|
|
226
225
|
@port.setter
|
|
227
|
-
def port(self, value: Optional[pulumi.Input[
|
|
226
|
+
def port(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
228
227
|
pulumi.set(self, "port", value)
|
|
229
228
|
|
|
230
|
-
@property
|
|
229
|
+
@_builtins.property
|
|
231
230
|
@pulumi.getter(name="sourceIps")
|
|
232
|
-
def source_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
231
|
+
def source_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
233
232
|
"""
|
|
234
233
|
List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
|
|
235
234
|
is `in`)
|
|
@@ -237,13 +236,13 @@ class FirewallRuleArgs:
|
|
|
237
236
|
return pulumi.get(self, "source_ips")
|
|
238
237
|
|
|
239
238
|
@source_ips.setter
|
|
240
|
-
def source_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
239
|
+
def source_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
241
240
|
pulumi.set(self, "source_ips", value)
|
|
242
241
|
|
|
243
242
|
|
|
244
243
|
if not MYPY:
|
|
245
244
|
class LoadBalancerAlgorithmArgsDict(TypedDict):
|
|
246
|
-
type: NotRequired[pulumi.Input[
|
|
245
|
+
type: NotRequired[pulumi.Input[_builtins.str]]
|
|
247
246
|
"""
|
|
248
247
|
Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
249
248
|
"""
|
|
@@ -253,41 +252,41 @@ elif False:
|
|
|
253
252
|
@pulumi.input_type
|
|
254
253
|
class LoadBalancerAlgorithmArgs:
|
|
255
254
|
def __init__(__self__, *,
|
|
256
|
-
type: Optional[pulumi.Input[
|
|
255
|
+
type: Optional[pulumi.Input[_builtins.str]] = None):
|
|
257
256
|
"""
|
|
258
|
-
:param pulumi.Input[
|
|
257
|
+
:param pulumi.Input[_builtins.str] type: Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
259
258
|
"""
|
|
260
259
|
if type is not None:
|
|
261
260
|
pulumi.set(__self__, "type", type)
|
|
262
261
|
|
|
263
|
-
@property
|
|
262
|
+
@_builtins.property
|
|
264
263
|
@pulumi.getter
|
|
265
|
-
def type(self) -> Optional[pulumi.Input[
|
|
264
|
+
def type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
266
265
|
"""
|
|
267
266
|
Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
268
267
|
"""
|
|
269
268
|
return pulumi.get(self, "type")
|
|
270
269
|
|
|
271
270
|
@type.setter
|
|
272
|
-
def type(self, value: Optional[pulumi.Input[
|
|
271
|
+
def type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
273
272
|
pulumi.set(self, "type", value)
|
|
274
273
|
|
|
275
274
|
|
|
276
275
|
if not MYPY:
|
|
277
276
|
class LoadBalancerServiceHealthCheckArgsDict(TypedDict):
|
|
278
|
-
interval: pulumi.Input[
|
|
277
|
+
interval: pulumi.Input[_builtins.int]
|
|
279
278
|
"""
|
|
280
279
|
Interval how often the health check will be performed, in seconds.
|
|
281
280
|
"""
|
|
282
|
-
port: pulumi.Input[
|
|
281
|
+
port: pulumi.Input[_builtins.int]
|
|
283
282
|
"""
|
|
284
283
|
Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
|
|
285
284
|
"""
|
|
286
|
-
protocol: pulumi.Input[
|
|
285
|
+
protocol: pulumi.Input[_builtins.str]
|
|
287
286
|
"""
|
|
288
287
|
Protocol the health check uses. `http` or `tcp`
|
|
289
288
|
"""
|
|
290
|
-
timeout: pulumi.Input[
|
|
289
|
+
timeout: pulumi.Input[_builtins.int]
|
|
291
290
|
"""
|
|
292
291
|
Timeout when a health check try will be canceled if there is no response, in seconds.
|
|
293
292
|
"""
|
|
@@ -295,7 +294,7 @@ if not MYPY:
|
|
|
295
294
|
"""
|
|
296
295
|
HTTP configuration. Required if `protocol` is `http`.
|
|
297
296
|
"""
|
|
298
|
-
retries: NotRequired[pulumi.Input[
|
|
297
|
+
retries: NotRequired[pulumi.Input[_builtins.int]]
|
|
299
298
|
"""
|
|
300
299
|
Number of tries a health check will be performed until a target will be listed as `unhealthy`.
|
|
301
300
|
"""
|
|
@@ -305,19 +304,19 @@ elif False:
|
|
|
305
304
|
@pulumi.input_type
|
|
306
305
|
class LoadBalancerServiceHealthCheckArgs:
|
|
307
306
|
def __init__(__self__, *,
|
|
308
|
-
interval: pulumi.Input[
|
|
309
|
-
port: pulumi.Input[
|
|
310
|
-
protocol: pulumi.Input[
|
|
311
|
-
timeout: pulumi.Input[
|
|
307
|
+
interval: pulumi.Input[_builtins.int],
|
|
308
|
+
port: pulumi.Input[_builtins.int],
|
|
309
|
+
protocol: pulumi.Input[_builtins.str],
|
|
310
|
+
timeout: pulumi.Input[_builtins.int],
|
|
312
311
|
http: Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']] = None,
|
|
313
|
-
retries: Optional[pulumi.Input[
|
|
312
|
+
retries: Optional[pulumi.Input[_builtins.int]] = None):
|
|
314
313
|
"""
|
|
315
|
-
:param pulumi.Input[
|
|
316
|
-
:param pulumi.Input[
|
|
317
|
-
:param pulumi.Input[
|
|
318
|
-
:param pulumi.Input[
|
|
314
|
+
:param pulumi.Input[_builtins.int] interval: Interval how often the health check will be performed, in seconds.
|
|
315
|
+
:param pulumi.Input[_builtins.int] port: Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
|
|
316
|
+
:param pulumi.Input[_builtins.str] protocol: Protocol the health check uses. `http` or `tcp`
|
|
317
|
+
:param pulumi.Input[_builtins.int] timeout: Timeout when a health check try will be canceled if there is no response, in seconds.
|
|
319
318
|
:param pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs'] http: HTTP configuration. Required if `protocol` is `http`.
|
|
320
|
-
:param pulumi.Input[
|
|
319
|
+
:param pulumi.Input[_builtins.int] retries: Number of tries a health check will be performed until a target will be listed as `unhealthy`.
|
|
321
320
|
"""
|
|
322
321
|
pulumi.set(__self__, "interval", interval)
|
|
323
322
|
pulumi.set(__self__, "port", port)
|
|
@@ -328,55 +327,55 @@ class LoadBalancerServiceHealthCheckArgs:
|
|
|
328
327
|
if retries is not None:
|
|
329
328
|
pulumi.set(__self__, "retries", retries)
|
|
330
329
|
|
|
331
|
-
@property
|
|
330
|
+
@_builtins.property
|
|
332
331
|
@pulumi.getter
|
|
333
|
-
def interval(self) -> pulumi.Input[
|
|
332
|
+
def interval(self) -> pulumi.Input[_builtins.int]:
|
|
334
333
|
"""
|
|
335
334
|
Interval how often the health check will be performed, in seconds.
|
|
336
335
|
"""
|
|
337
336
|
return pulumi.get(self, "interval")
|
|
338
337
|
|
|
339
338
|
@interval.setter
|
|
340
|
-
def interval(self, value: pulumi.Input[
|
|
339
|
+
def interval(self, value: pulumi.Input[_builtins.int]):
|
|
341
340
|
pulumi.set(self, "interval", value)
|
|
342
341
|
|
|
343
|
-
@property
|
|
342
|
+
@_builtins.property
|
|
344
343
|
@pulumi.getter
|
|
345
|
-
def port(self) -> pulumi.Input[
|
|
344
|
+
def port(self) -> pulumi.Input[_builtins.int]:
|
|
346
345
|
"""
|
|
347
346
|
Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
|
|
348
347
|
"""
|
|
349
348
|
return pulumi.get(self, "port")
|
|
350
349
|
|
|
351
350
|
@port.setter
|
|
352
|
-
def port(self, value: pulumi.Input[
|
|
351
|
+
def port(self, value: pulumi.Input[_builtins.int]):
|
|
353
352
|
pulumi.set(self, "port", value)
|
|
354
353
|
|
|
355
|
-
@property
|
|
354
|
+
@_builtins.property
|
|
356
355
|
@pulumi.getter
|
|
357
|
-
def protocol(self) -> pulumi.Input[
|
|
356
|
+
def protocol(self) -> pulumi.Input[_builtins.str]:
|
|
358
357
|
"""
|
|
359
358
|
Protocol the health check uses. `http` or `tcp`
|
|
360
359
|
"""
|
|
361
360
|
return pulumi.get(self, "protocol")
|
|
362
361
|
|
|
363
362
|
@protocol.setter
|
|
364
|
-
def protocol(self, value: pulumi.Input[
|
|
363
|
+
def protocol(self, value: pulumi.Input[_builtins.str]):
|
|
365
364
|
pulumi.set(self, "protocol", value)
|
|
366
365
|
|
|
367
|
-
@property
|
|
366
|
+
@_builtins.property
|
|
368
367
|
@pulumi.getter
|
|
369
|
-
def timeout(self) -> pulumi.Input[
|
|
368
|
+
def timeout(self) -> pulumi.Input[_builtins.int]:
|
|
370
369
|
"""
|
|
371
370
|
Timeout when a health check try will be canceled if there is no response, in seconds.
|
|
372
371
|
"""
|
|
373
372
|
return pulumi.get(self, "timeout")
|
|
374
373
|
|
|
375
374
|
@timeout.setter
|
|
376
|
-
def timeout(self, value: pulumi.Input[
|
|
375
|
+
def timeout(self, value: pulumi.Input[_builtins.int]):
|
|
377
376
|
pulumi.set(self, "timeout", value)
|
|
378
377
|
|
|
379
|
-
@property
|
|
378
|
+
@_builtins.property
|
|
380
379
|
@pulumi.getter
|
|
381
380
|
def http(self) -> Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']]:
|
|
382
381
|
"""
|
|
@@ -388,38 +387,38 @@ class LoadBalancerServiceHealthCheckArgs:
|
|
|
388
387
|
def http(self, value: Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']]):
|
|
389
388
|
pulumi.set(self, "http", value)
|
|
390
389
|
|
|
391
|
-
@property
|
|
390
|
+
@_builtins.property
|
|
392
391
|
@pulumi.getter
|
|
393
|
-
def retries(self) -> Optional[pulumi.Input[
|
|
392
|
+
def retries(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
394
393
|
"""
|
|
395
394
|
Number of tries a health check will be performed until a target will be listed as `unhealthy`.
|
|
396
395
|
"""
|
|
397
396
|
return pulumi.get(self, "retries")
|
|
398
397
|
|
|
399
398
|
@retries.setter
|
|
400
|
-
def retries(self, value: Optional[pulumi.Input[
|
|
399
|
+
def retries(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
401
400
|
pulumi.set(self, "retries", value)
|
|
402
401
|
|
|
403
402
|
|
|
404
403
|
if not MYPY:
|
|
405
404
|
class LoadBalancerServiceHealthCheckHttpArgsDict(TypedDict):
|
|
406
|
-
domain: NotRequired[pulumi.Input[
|
|
405
|
+
domain: NotRequired[pulumi.Input[_builtins.str]]
|
|
407
406
|
"""
|
|
408
407
|
Domain we try to access when performing the Health Check.
|
|
409
408
|
"""
|
|
410
|
-
path: NotRequired[pulumi.Input[
|
|
409
|
+
path: NotRequired[pulumi.Input[_builtins.str]]
|
|
411
410
|
"""
|
|
412
411
|
Path we try to access when performing the Health Check.
|
|
413
412
|
"""
|
|
414
|
-
response: NotRequired[pulumi.Input[
|
|
413
|
+
response: NotRequired[pulumi.Input[_builtins.str]]
|
|
415
414
|
"""
|
|
416
415
|
Response we expect to be included in the Target response when a Health Check was performed.
|
|
417
416
|
"""
|
|
418
|
-
status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
417
|
+
status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
419
418
|
"""
|
|
420
419
|
We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
|
|
421
420
|
"""
|
|
422
|
-
tls: NotRequired[pulumi.Input[
|
|
421
|
+
tls: NotRequired[pulumi.Input[_builtins.bool]]
|
|
423
422
|
"""
|
|
424
423
|
Enable TLS certificate checking.
|
|
425
424
|
"""
|
|
@@ -429,17 +428,17 @@ elif False:
|
|
|
429
428
|
@pulumi.input_type
|
|
430
429
|
class LoadBalancerServiceHealthCheckHttpArgs:
|
|
431
430
|
def __init__(__self__, *,
|
|
432
|
-
domain: Optional[pulumi.Input[
|
|
433
|
-
path: Optional[pulumi.Input[
|
|
434
|
-
response: Optional[pulumi.Input[
|
|
435
|
-
status_codes: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
436
|
-
tls: Optional[pulumi.Input[
|
|
437
|
-
"""
|
|
438
|
-
:param pulumi.Input[
|
|
439
|
-
:param pulumi.Input[
|
|
440
|
-
:param pulumi.Input[
|
|
441
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
442
|
-
:param pulumi.Input[
|
|
431
|
+
domain: Optional[pulumi.Input[_builtins.str]] = None,
|
|
432
|
+
path: Optional[pulumi.Input[_builtins.str]] = None,
|
|
433
|
+
response: Optional[pulumi.Input[_builtins.str]] = None,
|
|
434
|
+
status_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
435
|
+
tls: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
436
|
+
"""
|
|
437
|
+
:param pulumi.Input[_builtins.str] domain: Domain we try to access when performing the Health Check.
|
|
438
|
+
:param pulumi.Input[_builtins.str] path: Path we try to access when performing the Health Check.
|
|
439
|
+
:param pulumi.Input[_builtins.str] response: Response we expect to be included in the Target response when a Health Check was performed.
|
|
440
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] status_codes: We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
|
|
441
|
+
:param pulumi.Input[_builtins.bool] tls: Enable TLS certificate checking.
|
|
443
442
|
"""
|
|
444
443
|
if domain is not None:
|
|
445
444
|
pulumi.set(__self__, "domain", domain)
|
|
@@ -452,86 +451,86 @@ class LoadBalancerServiceHealthCheckHttpArgs:
|
|
|
452
451
|
if tls is not None:
|
|
453
452
|
pulumi.set(__self__, "tls", tls)
|
|
454
453
|
|
|
455
|
-
@property
|
|
454
|
+
@_builtins.property
|
|
456
455
|
@pulumi.getter
|
|
457
|
-
def domain(self) -> Optional[pulumi.Input[
|
|
456
|
+
def domain(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
458
457
|
"""
|
|
459
458
|
Domain we try to access when performing the Health Check.
|
|
460
459
|
"""
|
|
461
460
|
return pulumi.get(self, "domain")
|
|
462
461
|
|
|
463
462
|
@domain.setter
|
|
464
|
-
def domain(self, value: Optional[pulumi.Input[
|
|
463
|
+
def domain(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
465
464
|
pulumi.set(self, "domain", value)
|
|
466
465
|
|
|
467
|
-
@property
|
|
466
|
+
@_builtins.property
|
|
468
467
|
@pulumi.getter
|
|
469
|
-
def path(self) -> Optional[pulumi.Input[
|
|
468
|
+
def path(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
470
469
|
"""
|
|
471
470
|
Path we try to access when performing the Health Check.
|
|
472
471
|
"""
|
|
473
472
|
return pulumi.get(self, "path")
|
|
474
473
|
|
|
475
474
|
@path.setter
|
|
476
|
-
def path(self, value: Optional[pulumi.Input[
|
|
475
|
+
def path(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
477
476
|
pulumi.set(self, "path", value)
|
|
478
477
|
|
|
479
|
-
@property
|
|
478
|
+
@_builtins.property
|
|
480
479
|
@pulumi.getter
|
|
481
|
-
def response(self) -> Optional[pulumi.Input[
|
|
480
|
+
def response(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
482
481
|
"""
|
|
483
482
|
Response we expect to be included in the Target response when a Health Check was performed.
|
|
484
483
|
"""
|
|
485
484
|
return pulumi.get(self, "response")
|
|
486
485
|
|
|
487
486
|
@response.setter
|
|
488
|
-
def response(self, value: Optional[pulumi.Input[
|
|
487
|
+
def response(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
489
488
|
pulumi.set(self, "response", value)
|
|
490
489
|
|
|
491
|
-
@property
|
|
490
|
+
@_builtins.property
|
|
492
491
|
@pulumi.getter(name="statusCodes")
|
|
493
|
-
def status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
492
|
+
def status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
494
493
|
"""
|
|
495
494
|
We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
|
|
496
495
|
"""
|
|
497
496
|
return pulumi.get(self, "status_codes")
|
|
498
497
|
|
|
499
498
|
@status_codes.setter
|
|
500
|
-
def status_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
499
|
+
def status_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
501
500
|
pulumi.set(self, "status_codes", value)
|
|
502
501
|
|
|
503
|
-
@property
|
|
502
|
+
@_builtins.property
|
|
504
503
|
@pulumi.getter
|
|
505
|
-
def tls(self) -> Optional[pulumi.Input[
|
|
504
|
+
def tls(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
506
505
|
"""
|
|
507
506
|
Enable TLS certificate checking.
|
|
508
507
|
"""
|
|
509
508
|
return pulumi.get(self, "tls")
|
|
510
509
|
|
|
511
510
|
@tls.setter
|
|
512
|
-
def tls(self, value: Optional[pulumi.Input[
|
|
511
|
+
def tls(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
513
512
|
pulumi.set(self, "tls", value)
|
|
514
513
|
|
|
515
514
|
|
|
516
515
|
if not MYPY:
|
|
517
516
|
class LoadBalancerServiceHttpArgsDict(TypedDict):
|
|
518
|
-
certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
517
|
+
certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
|
|
519
518
|
"""
|
|
520
519
|
List of IDs from certificates which the Load Balancer has.
|
|
521
520
|
"""
|
|
522
|
-
cookie_lifetime: NotRequired[pulumi.Input[
|
|
521
|
+
cookie_lifetime: NotRequired[pulumi.Input[_builtins.int]]
|
|
523
522
|
"""
|
|
524
523
|
Lifetime of the cookie for sticky session (in seconds). Default: `300`
|
|
525
524
|
"""
|
|
526
|
-
cookie_name: NotRequired[pulumi.Input[
|
|
525
|
+
cookie_name: NotRequired[pulumi.Input[_builtins.str]]
|
|
527
526
|
"""
|
|
528
527
|
Name of the cookie for sticky session. Default: `HCLBSTICKY`
|
|
529
528
|
"""
|
|
530
|
-
redirect_http: NotRequired[pulumi.Input[
|
|
529
|
+
redirect_http: NotRequired[pulumi.Input[_builtins.bool]]
|
|
531
530
|
"""
|
|
532
531
|
Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
|
|
533
532
|
"""
|
|
534
|
-
sticky_sessions: NotRequired[pulumi.Input[
|
|
533
|
+
sticky_sessions: NotRequired[pulumi.Input[_builtins.bool]]
|
|
535
534
|
"""
|
|
536
535
|
Enable sticky sessions
|
|
537
536
|
"""
|
|
@@ -541,17 +540,17 @@ elif False:
|
|
|
541
540
|
@pulumi.input_type
|
|
542
541
|
class LoadBalancerServiceHttpArgs:
|
|
543
542
|
def __init__(__self__, *,
|
|
544
|
-
certificates: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
545
|
-
cookie_lifetime: Optional[pulumi.Input[
|
|
546
|
-
cookie_name: Optional[pulumi.Input[
|
|
547
|
-
redirect_http: Optional[pulumi.Input[
|
|
548
|
-
sticky_sessions: Optional[pulumi.Input[
|
|
549
|
-
"""
|
|
550
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
551
|
-
:param pulumi.Input[
|
|
552
|
-
:param pulumi.Input[
|
|
553
|
-
:param pulumi.Input[
|
|
554
|
-
:param pulumi.Input[
|
|
543
|
+
certificates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
|
|
544
|
+
cookie_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
|
|
545
|
+
cookie_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
546
|
+
redirect_http: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
547
|
+
sticky_sessions: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
548
|
+
"""
|
|
549
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] certificates: List of IDs from certificates which the Load Balancer has.
|
|
550
|
+
:param pulumi.Input[_builtins.int] cookie_lifetime: Lifetime of the cookie for sticky session (in seconds). Default: `300`
|
|
551
|
+
:param pulumi.Input[_builtins.str] cookie_name: Name of the cookie for sticky session. Default: `HCLBSTICKY`
|
|
552
|
+
:param pulumi.Input[_builtins.bool] redirect_http: Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
|
|
553
|
+
:param pulumi.Input[_builtins.bool] sticky_sessions: Enable sticky sessions
|
|
555
554
|
"""
|
|
556
555
|
if certificates is not None:
|
|
557
556
|
pulumi.set(__self__, "certificates", certificates)
|
|
@@ -564,86 +563,86 @@ class LoadBalancerServiceHttpArgs:
|
|
|
564
563
|
if sticky_sessions is not None:
|
|
565
564
|
pulumi.set(__self__, "sticky_sessions", sticky_sessions)
|
|
566
565
|
|
|
567
|
-
@property
|
|
566
|
+
@_builtins.property
|
|
568
567
|
@pulumi.getter
|
|
569
|
-
def certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
568
|
+
def certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
|
|
570
569
|
"""
|
|
571
570
|
List of IDs from certificates which the Load Balancer has.
|
|
572
571
|
"""
|
|
573
572
|
return pulumi.get(self, "certificates")
|
|
574
573
|
|
|
575
574
|
@certificates.setter
|
|
576
|
-
def certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
575
|
+
def certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
|
|
577
576
|
pulumi.set(self, "certificates", value)
|
|
578
577
|
|
|
579
|
-
@property
|
|
578
|
+
@_builtins.property
|
|
580
579
|
@pulumi.getter(name="cookieLifetime")
|
|
581
|
-
def cookie_lifetime(self) -> Optional[pulumi.Input[
|
|
580
|
+
def cookie_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
582
581
|
"""
|
|
583
582
|
Lifetime of the cookie for sticky session (in seconds). Default: `300`
|
|
584
583
|
"""
|
|
585
584
|
return pulumi.get(self, "cookie_lifetime")
|
|
586
585
|
|
|
587
586
|
@cookie_lifetime.setter
|
|
588
|
-
def cookie_lifetime(self, value: Optional[pulumi.Input[
|
|
587
|
+
def cookie_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
589
588
|
pulumi.set(self, "cookie_lifetime", value)
|
|
590
589
|
|
|
591
|
-
@property
|
|
590
|
+
@_builtins.property
|
|
592
591
|
@pulumi.getter(name="cookieName")
|
|
593
|
-
def cookie_name(self) -> Optional[pulumi.Input[
|
|
592
|
+
def cookie_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
594
593
|
"""
|
|
595
594
|
Name of the cookie for sticky session. Default: `HCLBSTICKY`
|
|
596
595
|
"""
|
|
597
596
|
return pulumi.get(self, "cookie_name")
|
|
598
597
|
|
|
599
598
|
@cookie_name.setter
|
|
600
|
-
def cookie_name(self, value: Optional[pulumi.Input[
|
|
599
|
+
def cookie_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
601
600
|
pulumi.set(self, "cookie_name", value)
|
|
602
601
|
|
|
603
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
604
603
|
@pulumi.getter(name="redirectHttp")
|
|
605
|
-
def redirect_http(self) -> Optional[pulumi.Input[
|
|
604
|
+
def redirect_http(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
606
605
|
"""
|
|
607
606
|
Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
|
|
608
607
|
"""
|
|
609
608
|
return pulumi.get(self, "redirect_http")
|
|
610
609
|
|
|
611
610
|
@redirect_http.setter
|
|
612
|
-
def redirect_http(self, value: Optional[pulumi.Input[
|
|
611
|
+
def redirect_http(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
613
612
|
pulumi.set(self, "redirect_http", value)
|
|
614
613
|
|
|
615
|
-
@property
|
|
614
|
+
@_builtins.property
|
|
616
615
|
@pulumi.getter(name="stickySessions")
|
|
617
|
-
def sticky_sessions(self) -> Optional[pulumi.Input[
|
|
616
|
+
def sticky_sessions(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
618
617
|
"""
|
|
619
618
|
Enable sticky sessions
|
|
620
619
|
"""
|
|
621
620
|
return pulumi.get(self, "sticky_sessions")
|
|
622
621
|
|
|
623
622
|
@sticky_sessions.setter
|
|
624
|
-
def sticky_sessions(self, value: Optional[pulumi.Input[
|
|
623
|
+
def sticky_sessions(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
625
624
|
pulumi.set(self, "sticky_sessions", value)
|
|
626
625
|
|
|
627
626
|
|
|
628
627
|
if not MYPY:
|
|
629
628
|
class LoadBalancerTargetArgsDict(TypedDict):
|
|
630
|
-
type: pulumi.Input[
|
|
629
|
+
type: pulumi.Input[_builtins.str]
|
|
631
630
|
"""
|
|
632
631
|
(string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
633
632
|
"""
|
|
634
|
-
server_id: NotRequired[pulumi.Input[
|
|
635
|
-
use_private_ip: NotRequired[pulumi.Input[
|
|
633
|
+
server_id: NotRequired[pulumi.Input[_builtins.int]]
|
|
634
|
+
use_private_ip: NotRequired[pulumi.Input[_builtins.bool]]
|
|
636
635
|
elif False:
|
|
637
636
|
LoadBalancerTargetArgsDict: TypeAlias = Mapping[str, Any]
|
|
638
637
|
|
|
639
638
|
@pulumi.input_type
|
|
640
639
|
class LoadBalancerTargetArgs:
|
|
641
640
|
def __init__(__self__, *,
|
|
642
|
-
type: pulumi.Input[
|
|
643
|
-
server_id: Optional[pulumi.Input[
|
|
644
|
-
use_private_ip: Optional[pulumi.Input[
|
|
641
|
+
type: pulumi.Input[_builtins.str],
|
|
642
|
+
server_id: Optional[pulumi.Input[_builtins.int]] = None,
|
|
643
|
+
use_private_ip: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
645
644
|
"""
|
|
646
|
-
:param pulumi.Input[
|
|
645
|
+
:param pulumi.Input[_builtins.str] type: (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
647
646
|
"""
|
|
648
647
|
pulumi.set(__self__, "type", type)
|
|
649
648
|
if server_id is not None:
|
|
@@ -654,50 +653,50 @@ class LoadBalancerTargetArgs:
|
|
|
654
653
|
if use_private_ip is not None:
|
|
655
654
|
pulumi.set(__self__, "use_private_ip", use_private_ip)
|
|
656
655
|
|
|
657
|
-
@property
|
|
656
|
+
@_builtins.property
|
|
658
657
|
@pulumi.getter
|
|
659
|
-
def type(self) -> pulumi.Input[
|
|
658
|
+
def type(self) -> pulumi.Input[_builtins.str]:
|
|
660
659
|
"""
|
|
661
660
|
(string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
|
|
662
661
|
"""
|
|
663
662
|
return pulumi.get(self, "type")
|
|
664
663
|
|
|
665
664
|
@type.setter
|
|
666
|
-
def type(self, value: pulumi.Input[
|
|
665
|
+
def type(self, value: pulumi.Input[_builtins.str]):
|
|
667
666
|
pulumi.set(self, "type", value)
|
|
668
667
|
|
|
669
|
-
@property
|
|
668
|
+
@_builtins.property
|
|
670
669
|
@pulumi.getter(name="serverId")
|
|
671
|
-
def server_id(self) -> Optional[pulumi.Input[
|
|
670
|
+
def server_id(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
672
671
|
return pulumi.get(self, "server_id")
|
|
673
672
|
|
|
674
673
|
@server_id.setter
|
|
675
|
-
def server_id(self, value: Optional[pulumi.Input[
|
|
674
|
+
def server_id(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
676
675
|
pulumi.set(self, "server_id", value)
|
|
677
676
|
|
|
678
|
-
@property
|
|
677
|
+
@_builtins.property
|
|
679
678
|
@pulumi.getter(name="usePrivateIp")
|
|
680
679
|
@_utilities.deprecated("""Does not work. Use the LoadBalancerTarget resource instead.""")
|
|
681
|
-
def use_private_ip(self) -> Optional[pulumi.Input[
|
|
680
|
+
def use_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
682
681
|
return pulumi.get(self, "use_private_ip")
|
|
683
682
|
|
|
684
683
|
@use_private_ip.setter
|
|
685
|
-
def use_private_ip(self, value: Optional[pulumi.Input[
|
|
684
|
+
def use_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
686
685
|
pulumi.set(self, "use_private_ip", value)
|
|
687
686
|
|
|
688
687
|
|
|
689
688
|
if not MYPY:
|
|
690
689
|
class ServerNetworkArgsDict(TypedDict):
|
|
691
|
-
network_id: pulumi.Input[
|
|
690
|
+
network_id: pulumi.Input[_builtins.int]
|
|
692
691
|
"""
|
|
693
692
|
ID of the network
|
|
694
693
|
"""
|
|
695
|
-
alias_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[
|
|
696
|
-
ip: NotRequired[pulumi.Input[
|
|
694
|
+
alias_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
|
|
695
|
+
ip: NotRequired[pulumi.Input[_builtins.str]]
|
|
697
696
|
"""
|
|
698
697
|
Specify the IP the server should get in the network
|
|
699
698
|
"""
|
|
700
|
-
mac_address: NotRequired[pulumi.Input[
|
|
699
|
+
mac_address: NotRequired[pulumi.Input[_builtins.str]]
|
|
701
700
|
"""
|
|
702
701
|
(Optional, string) The MAC address the private interface of the server has
|
|
703
702
|
"""
|
|
@@ -707,14 +706,14 @@ elif False:
|
|
|
707
706
|
@pulumi.input_type
|
|
708
707
|
class ServerNetworkArgs:
|
|
709
708
|
def __init__(__self__, *,
|
|
710
|
-
network_id: pulumi.Input[
|
|
711
|
-
alias_ips: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
712
|
-
ip: Optional[pulumi.Input[
|
|
713
|
-
mac_address: Optional[pulumi.Input[
|
|
709
|
+
network_id: pulumi.Input[_builtins.int],
|
|
710
|
+
alias_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
711
|
+
ip: Optional[pulumi.Input[_builtins.str]] = None,
|
|
712
|
+
mac_address: Optional[pulumi.Input[_builtins.str]] = None):
|
|
714
713
|
"""
|
|
715
|
-
:param pulumi.Input[
|
|
716
|
-
:param pulumi.Input[
|
|
717
|
-
:param pulumi.Input[
|
|
714
|
+
:param pulumi.Input[_builtins.int] network_id: ID of the network
|
|
715
|
+
:param pulumi.Input[_builtins.str] ip: Specify the IP the server should get in the network
|
|
716
|
+
:param pulumi.Input[_builtins.str] mac_address: (Optional, string) The MAC address the private interface of the server has
|
|
718
717
|
"""
|
|
719
718
|
pulumi.set(__self__, "network_id", network_id)
|
|
720
719
|
if alias_ips is not None:
|
|
@@ -724,68 +723,68 @@ class ServerNetworkArgs:
|
|
|
724
723
|
if mac_address is not None:
|
|
725
724
|
pulumi.set(__self__, "mac_address", mac_address)
|
|
726
725
|
|
|
727
|
-
@property
|
|
726
|
+
@_builtins.property
|
|
728
727
|
@pulumi.getter(name="networkId")
|
|
729
|
-
def network_id(self) -> pulumi.Input[
|
|
728
|
+
def network_id(self) -> pulumi.Input[_builtins.int]:
|
|
730
729
|
"""
|
|
731
730
|
ID of the network
|
|
732
731
|
"""
|
|
733
732
|
return pulumi.get(self, "network_id")
|
|
734
733
|
|
|
735
734
|
@network_id.setter
|
|
736
|
-
def network_id(self, value: pulumi.Input[
|
|
735
|
+
def network_id(self, value: pulumi.Input[_builtins.int]):
|
|
737
736
|
pulumi.set(self, "network_id", value)
|
|
738
737
|
|
|
739
|
-
@property
|
|
738
|
+
@_builtins.property
|
|
740
739
|
@pulumi.getter(name="aliasIps")
|
|
741
|
-
def alias_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
740
|
+
def alias_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
742
741
|
return pulumi.get(self, "alias_ips")
|
|
743
742
|
|
|
744
743
|
@alias_ips.setter
|
|
745
|
-
def alias_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
744
|
+
def alias_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
746
745
|
pulumi.set(self, "alias_ips", value)
|
|
747
746
|
|
|
748
|
-
@property
|
|
747
|
+
@_builtins.property
|
|
749
748
|
@pulumi.getter
|
|
750
|
-
def ip(self) -> Optional[pulumi.Input[
|
|
749
|
+
def ip(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
751
750
|
"""
|
|
752
751
|
Specify the IP the server should get in the network
|
|
753
752
|
"""
|
|
754
753
|
return pulumi.get(self, "ip")
|
|
755
754
|
|
|
756
755
|
@ip.setter
|
|
757
|
-
def ip(self, value: Optional[pulumi.Input[
|
|
756
|
+
def ip(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
758
757
|
pulumi.set(self, "ip", value)
|
|
759
758
|
|
|
760
|
-
@property
|
|
759
|
+
@_builtins.property
|
|
761
760
|
@pulumi.getter(name="macAddress")
|
|
762
|
-
def mac_address(self) -> Optional[pulumi.Input[
|
|
761
|
+
def mac_address(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
763
762
|
"""
|
|
764
763
|
(Optional, string) The MAC address the private interface of the server has
|
|
765
764
|
"""
|
|
766
765
|
return pulumi.get(self, "mac_address")
|
|
767
766
|
|
|
768
767
|
@mac_address.setter
|
|
769
|
-
def mac_address(self, value: Optional[pulumi.Input[
|
|
768
|
+
def mac_address(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
770
769
|
pulumi.set(self, "mac_address", value)
|
|
771
770
|
|
|
772
771
|
|
|
773
772
|
if not MYPY:
|
|
774
773
|
class ServerPublicNetArgsDict(TypedDict):
|
|
775
|
-
ipv4: NotRequired[pulumi.Input[
|
|
776
|
-
ipv4_enabled: NotRequired[pulumi.Input[
|
|
777
|
-
ipv6: NotRequired[pulumi.Input[
|
|
778
|
-
ipv6_enabled: NotRequired[pulumi.Input[
|
|
774
|
+
ipv4: NotRequired[pulumi.Input[_builtins.int]]
|
|
775
|
+
ipv4_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
776
|
+
ipv6: NotRequired[pulumi.Input[_builtins.int]]
|
|
777
|
+
ipv6_enabled: NotRequired[pulumi.Input[_builtins.bool]]
|
|
779
778
|
elif False:
|
|
780
779
|
ServerPublicNetArgsDict: TypeAlias = Mapping[str, Any]
|
|
781
780
|
|
|
782
781
|
@pulumi.input_type
|
|
783
782
|
class ServerPublicNetArgs:
|
|
784
783
|
def __init__(__self__, *,
|
|
785
|
-
ipv4: Optional[pulumi.Input[
|
|
786
|
-
ipv4_enabled: Optional[pulumi.Input[
|
|
787
|
-
ipv6: Optional[pulumi.Input[
|
|
788
|
-
ipv6_enabled: Optional[pulumi.Input[
|
|
784
|
+
ipv4: Optional[pulumi.Input[_builtins.int]] = None,
|
|
785
|
+
ipv4_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
786
|
+
ipv6: Optional[pulumi.Input[_builtins.int]] = None,
|
|
787
|
+
ipv6_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
789
788
|
if ipv4 is not None:
|
|
790
789
|
pulumi.set(__self__, "ipv4", ipv4)
|
|
791
790
|
if ipv4_enabled is not None:
|
|
@@ -795,51 +794,51 @@ class ServerPublicNetArgs:
|
|
|
795
794
|
if ipv6_enabled is not None:
|
|
796
795
|
pulumi.set(__self__, "ipv6_enabled", ipv6_enabled)
|
|
797
796
|
|
|
798
|
-
@property
|
|
797
|
+
@_builtins.property
|
|
799
798
|
@pulumi.getter
|
|
800
|
-
def ipv4(self) -> Optional[pulumi.Input[
|
|
799
|
+
def ipv4(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
801
800
|
return pulumi.get(self, "ipv4")
|
|
802
801
|
|
|
803
802
|
@ipv4.setter
|
|
804
|
-
def ipv4(self, value: Optional[pulumi.Input[
|
|
803
|
+
def ipv4(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
805
804
|
pulumi.set(self, "ipv4", value)
|
|
806
805
|
|
|
807
|
-
@property
|
|
806
|
+
@_builtins.property
|
|
808
807
|
@pulumi.getter(name="ipv4Enabled")
|
|
809
|
-
def ipv4_enabled(self) -> Optional[pulumi.Input[
|
|
808
|
+
def ipv4_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
810
809
|
return pulumi.get(self, "ipv4_enabled")
|
|
811
810
|
|
|
812
811
|
@ipv4_enabled.setter
|
|
813
|
-
def ipv4_enabled(self, value: Optional[pulumi.Input[
|
|
812
|
+
def ipv4_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
814
813
|
pulumi.set(self, "ipv4_enabled", value)
|
|
815
814
|
|
|
816
|
-
@property
|
|
815
|
+
@_builtins.property
|
|
817
816
|
@pulumi.getter
|
|
818
|
-
def ipv6(self) -> Optional[pulumi.Input[
|
|
817
|
+
def ipv6(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
819
818
|
return pulumi.get(self, "ipv6")
|
|
820
819
|
|
|
821
820
|
@ipv6.setter
|
|
822
|
-
def ipv6(self, value: Optional[pulumi.Input[
|
|
821
|
+
def ipv6(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
823
822
|
pulumi.set(self, "ipv6", value)
|
|
824
823
|
|
|
825
|
-
@property
|
|
824
|
+
@_builtins.property
|
|
826
825
|
@pulumi.getter(name="ipv6Enabled")
|
|
827
|
-
def ipv6_enabled(self) -> Optional[pulumi.Input[
|
|
826
|
+
def ipv6_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
828
827
|
return pulumi.get(self, "ipv6_enabled")
|
|
829
828
|
|
|
830
829
|
@ipv6_enabled.setter
|
|
831
|
-
def ipv6_enabled(self, value: Optional[pulumi.Input[
|
|
830
|
+
def ipv6_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
832
831
|
pulumi.set(self, "ipv6_enabled", value)
|
|
833
832
|
|
|
834
833
|
|
|
835
834
|
if not MYPY:
|
|
836
835
|
class GetFirewallApplyToArgsDict(TypedDict):
|
|
837
|
-
label_selector:
|
|
836
|
+
label_selector: _builtins.str
|
|
838
837
|
"""
|
|
839
838
|
(string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
|
|
840
839
|
referenced
|
|
841
840
|
"""
|
|
842
|
-
server:
|
|
841
|
+
server: _builtins.int
|
|
843
842
|
"""
|
|
844
843
|
(int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
|
|
845
844
|
"""
|
|
@@ -849,19 +848,19 @@ elif False:
|
|
|
849
848
|
@pulumi.input_type
|
|
850
849
|
class GetFirewallApplyToArgs:
|
|
851
850
|
def __init__(__self__, *,
|
|
852
|
-
label_selector:
|
|
853
|
-
server:
|
|
851
|
+
label_selector: _builtins.str,
|
|
852
|
+
server: _builtins.int):
|
|
854
853
|
"""
|
|
855
|
-
:param
|
|
854
|
+
:param _builtins.str label_selector: (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
|
|
856
855
|
referenced
|
|
857
|
-
:param
|
|
856
|
+
:param _builtins.int server: (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
|
|
858
857
|
"""
|
|
859
858
|
pulumi.set(__self__, "label_selector", label_selector)
|
|
860
859
|
pulumi.set(__self__, "server", server)
|
|
861
860
|
|
|
862
|
-
@property
|
|
861
|
+
@_builtins.property
|
|
863
862
|
@pulumi.getter(name="labelSelector")
|
|
864
|
-
def label_selector(self) ->
|
|
863
|
+
def label_selector(self) -> _builtins.str:
|
|
865
864
|
"""
|
|
866
865
|
(string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
|
|
867
866
|
referenced
|
|
@@ -869,45 +868,45 @@ class GetFirewallApplyToArgs:
|
|
|
869
868
|
return pulumi.get(self, "label_selector")
|
|
870
869
|
|
|
871
870
|
@label_selector.setter
|
|
872
|
-
def label_selector(self, value:
|
|
871
|
+
def label_selector(self, value: _builtins.str):
|
|
873
872
|
pulumi.set(self, "label_selector", value)
|
|
874
873
|
|
|
875
|
-
@property
|
|
874
|
+
@_builtins.property
|
|
876
875
|
@pulumi.getter
|
|
877
|
-
def server(self) ->
|
|
876
|
+
def server(self) -> _builtins.int:
|
|
878
877
|
"""
|
|
879
878
|
(int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
|
|
880
879
|
"""
|
|
881
880
|
return pulumi.get(self, "server")
|
|
882
881
|
|
|
883
882
|
@server.setter
|
|
884
|
-
def server(self, value:
|
|
883
|
+
def server(self, value: _builtins.int):
|
|
885
884
|
pulumi.set(self, "server", value)
|
|
886
885
|
|
|
887
886
|
|
|
888
887
|
if not MYPY:
|
|
889
888
|
class GetFirewallRuleArgsDict(TypedDict):
|
|
890
|
-
direction:
|
|
889
|
+
direction: _builtins.str
|
|
891
890
|
"""
|
|
892
891
|
(Required, string) Direction of the Firewall Rule. `in`, `out`
|
|
893
892
|
"""
|
|
894
|
-
description: NotRequired[
|
|
893
|
+
description: NotRequired[_builtins.str]
|
|
895
894
|
"""
|
|
896
895
|
(Optional, string) Description of the firewall rule
|
|
897
896
|
"""
|
|
898
|
-
destination_ips: NotRequired[Sequence[
|
|
897
|
+
destination_ips: NotRequired[Sequence[_builtins.str]]
|
|
899
898
|
"""
|
|
900
899
|
(Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
|
|
901
900
|
"""
|
|
902
|
-
port: NotRequired[
|
|
901
|
+
port: NotRequired[_builtins.str]
|
|
903
902
|
"""
|
|
904
903
|
(Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
|
|
905
904
|
"""
|
|
906
|
-
protocol: NotRequired[
|
|
905
|
+
protocol: NotRequired[_builtins.str]
|
|
907
906
|
"""
|
|
908
907
|
(Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
909
908
|
"""
|
|
910
|
-
source_ips: NotRequired[Sequence[
|
|
909
|
+
source_ips: NotRequired[Sequence[_builtins.str]]
|
|
911
910
|
"""
|
|
912
911
|
(Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
|
|
913
912
|
"""
|
|
@@ -917,19 +916,19 @@ elif False:
|
|
|
917
916
|
@pulumi.input_type
|
|
918
917
|
class GetFirewallRuleArgs:
|
|
919
918
|
def __init__(__self__, *,
|
|
920
|
-
direction:
|
|
921
|
-
description: Optional[
|
|
922
|
-
destination_ips: Optional[Sequence[
|
|
923
|
-
port: Optional[
|
|
924
|
-
protocol: Optional[
|
|
925
|
-
source_ips: Optional[Sequence[
|
|
926
|
-
"""
|
|
927
|
-
:param
|
|
928
|
-
:param
|
|
929
|
-
:param Sequence[
|
|
930
|
-
:param
|
|
931
|
-
:param
|
|
932
|
-
:param Sequence[
|
|
919
|
+
direction: _builtins.str,
|
|
920
|
+
description: Optional[_builtins.str] = None,
|
|
921
|
+
destination_ips: Optional[Sequence[_builtins.str]] = None,
|
|
922
|
+
port: Optional[_builtins.str] = None,
|
|
923
|
+
protocol: Optional[_builtins.str] = None,
|
|
924
|
+
source_ips: Optional[Sequence[_builtins.str]] = None):
|
|
925
|
+
"""
|
|
926
|
+
:param _builtins.str direction: (Required, string) Direction of the Firewall Rule. `in`, `out`
|
|
927
|
+
:param _builtins.str description: (Optional, string) Description of the firewall rule
|
|
928
|
+
:param Sequence[_builtins.str] destination_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
|
|
929
|
+
:param _builtins.str port: (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
|
|
930
|
+
:param _builtins.str protocol: (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
931
|
+
:param Sequence[_builtins.str] source_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
|
|
933
932
|
"""
|
|
934
933
|
pulumi.set(__self__, "direction", direction)
|
|
935
934
|
if description is not None:
|
|
@@ -943,94 +942,94 @@ class GetFirewallRuleArgs:
|
|
|
943
942
|
if source_ips is not None:
|
|
944
943
|
pulumi.set(__self__, "source_ips", source_ips)
|
|
945
944
|
|
|
946
|
-
@property
|
|
945
|
+
@_builtins.property
|
|
947
946
|
@pulumi.getter
|
|
948
|
-
def direction(self) ->
|
|
947
|
+
def direction(self) -> _builtins.str:
|
|
949
948
|
"""
|
|
950
949
|
(Required, string) Direction of the Firewall Rule. `in`, `out`
|
|
951
950
|
"""
|
|
952
951
|
return pulumi.get(self, "direction")
|
|
953
952
|
|
|
954
953
|
@direction.setter
|
|
955
|
-
def direction(self, value:
|
|
954
|
+
def direction(self, value: _builtins.str):
|
|
956
955
|
pulumi.set(self, "direction", value)
|
|
957
956
|
|
|
958
|
-
@property
|
|
957
|
+
@_builtins.property
|
|
959
958
|
@pulumi.getter
|
|
960
|
-
def description(self) -> Optional[
|
|
959
|
+
def description(self) -> Optional[_builtins.str]:
|
|
961
960
|
"""
|
|
962
961
|
(Optional, string) Description of the firewall rule
|
|
963
962
|
"""
|
|
964
963
|
return pulumi.get(self, "description")
|
|
965
964
|
|
|
966
965
|
@description.setter
|
|
967
|
-
def description(self, value: Optional[
|
|
966
|
+
def description(self, value: Optional[_builtins.str]):
|
|
968
967
|
pulumi.set(self, "description", value)
|
|
969
968
|
|
|
970
|
-
@property
|
|
969
|
+
@_builtins.property
|
|
971
970
|
@pulumi.getter(name="destinationIps")
|
|
972
|
-
def destination_ips(self) -> Optional[Sequence[
|
|
971
|
+
def destination_ips(self) -> Optional[Sequence[_builtins.str]]:
|
|
973
972
|
"""
|
|
974
973
|
(Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
|
|
975
974
|
"""
|
|
976
975
|
return pulumi.get(self, "destination_ips")
|
|
977
976
|
|
|
978
977
|
@destination_ips.setter
|
|
979
|
-
def destination_ips(self, value: Optional[Sequence[
|
|
978
|
+
def destination_ips(self, value: Optional[Sequence[_builtins.str]]):
|
|
980
979
|
pulumi.set(self, "destination_ips", value)
|
|
981
980
|
|
|
982
|
-
@property
|
|
981
|
+
@_builtins.property
|
|
983
982
|
@pulumi.getter
|
|
984
|
-
def port(self) -> Optional[
|
|
983
|
+
def port(self) -> Optional[_builtins.str]:
|
|
985
984
|
"""
|
|
986
985
|
(Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
|
|
987
986
|
"""
|
|
988
987
|
return pulumi.get(self, "port")
|
|
989
988
|
|
|
990
989
|
@port.setter
|
|
991
|
-
def port(self, value: Optional[
|
|
990
|
+
def port(self, value: Optional[_builtins.str]):
|
|
992
991
|
pulumi.set(self, "port", value)
|
|
993
992
|
|
|
994
|
-
@property
|
|
993
|
+
@_builtins.property
|
|
995
994
|
@pulumi.getter
|
|
996
|
-
def protocol(self) -> Optional[
|
|
995
|
+
def protocol(self) -> Optional[_builtins.str]:
|
|
997
996
|
"""
|
|
998
997
|
(Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
|
|
999
998
|
"""
|
|
1000
999
|
return pulumi.get(self, "protocol")
|
|
1001
1000
|
|
|
1002
1001
|
@protocol.setter
|
|
1003
|
-
def protocol(self, value: Optional[
|
|
1002
|
+
def protocol(self, value: Optional[_builtins.str]):
|
|
1004
1003
|
pulumi.set(self, "protocol", value)
|
|
1005
1004
|
|
|
1006
|
-
@property
|
|
1005
|
+
@_builtins.property
|
|
1007
1006
|
@pulumi.getter(name="sourceIps")
|
|
1008
|
-
def source_ips(self) -> Optional[Sequence[
|
|
1007
|
+
def source_ips(self) -> Optional[Sequence[_builtins.str]]:
|
|
1009
1008
|
"""
|
|
1010
1009
|
(Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
|
|
1011
1010
|
"""
|
|
1012
1011
|
return pulumi.get(self, "source_ips")
|
|
1013
1012
|
|
|
1014
1013
|
@source_ips.setter
|
|
1015
|
-
def source_ips(self, value: Optional[Sequence[
|
|
1014
|
+
def source_ips(self, value: Optional[Sequence[_builtins.str]]):
|
|
1016
1015
|
pulumi.set(self, "source_ips", value)
|
|
1017
1016
|
|
|
1018
1017
|
|
|
1019
1018
|
if not MYPY:
|
|
1020
1019
|
class GetServerNetworkArgsDict(TypedDict):
|
|
1021
|
-
alias_ips: Sequence[
|
|
1020
|
+
alias_ips: Sequence[_builtins.str]
|
|
1022
1021
|
"""
|
|
1023
1022
|
(list) A list of alias IP addresses assigned to the server in the network.
|
|
1024
1023
|
"""
|
|
1025
|
-
ip:
|
|
1024
|
+
ip: _builtins.str
|
|
1026
1025
|
"""
|
|
1027
1026
|
(string) The server's IP address within the network.
|
|
1028
1027
|
"""
|
|
1029
|
-
mac_address:
|
|
1028
|
+
mac_address: _builtins.str
|
|
1030
1029
|
"""
|
|
1031
1030
|
(string) The MAC address associated with the server's private network interface.
|
|
1032
1031
|
"""
|
|
1033
|
-
network_id:
|
|
1032
|
+
network_id: _builtins.int
|
|
1034
1033
|
"""
|
|
1035
1034
|
(int) The unique identifier for the network.
|
|
1036
1035
|
"""
|
|
@@ -1040,67 +1039,67 @@ elif False:
|
|
|
1040
1039
|
@pulumi.input_type
|
|
1041
1040
|
class GetServerNetworkArgs:
|
|
1042
1041
|
def __init__(__self__, *,
|
|
1043
|
-
alias_ips: Sequence[
|
|
1044
|
-
ip:
|
|
1045
|
-
mac_address:
|
|
1046
|
-
network_id:
|
|
1042
|
+
alias_ips: Sequence[_builtins.str],
|
|
1043
|
+
ip: _builtins.str,
|
|
1044
|
+
mac_address: _builtins.str,
|
|
1045
|
+
network_id: _builtins.int):
|
|
1047
1046
|
"""
|
|
1048
|
-
:param Sequence[
|
|
1049
|
-
:param
|
|
1050
|
-
:param
|
|
1051
|
-
:param
|
|
1047
|
+
:param Sequence[_builtins.str] alias_ips: (list) A list of alias IP addresses assigned to the server in the network.
|
|
1048
|
+
:param _builtins.str ip: (string) The server's IP address within the network.
|
|
1049
|
+
:param _builtins.str mac_address: (string) The MAC address associated with the server's private network interface.
|
|
1050
|
+
:param _builtins.int network_id: (int) The unique identifier for the network.
|
|
1052
1051
|
"""
|
|
1053
1052
|
pulumi.set(__self__, "alias_ips", alias_ips)
|
|
1054
1053
|
pulumi.set(__self__, "ip", ip)
|
|
1055
1054
|
pulumi.set(__self__, "mac_address", mac_address)
|
|
1056
1055
|
pulumi.set(__self__, "network_id", network_id)
|
|
1057
1056
|
|
|
1058
|
-
@property
|
|
1057
|
+
@_builtins.property
|
|
1059
1058
|
@pulumi.getter(name="aliasIps")
|
|
1060
|
-
def alias_ips(self) -> Sequence[
|
|
1059
|
+
def alias_ips(self) -> Sequence[_builtins.str]:
|
|
1061
1060
|
"""
|
|
1062
1061
|
(list) A list of alias IP addresses assigned to the server in the network.
|
|
1063
1062
|
"""
|
|
1064
1063
|
return pulumi.get(self, "alias_ips")
|
|
1065
1064
|
|
|
1066
1065
|
@alias_ips.setter
|
|
1067
|
-
def alias_ips(self, value: Sequence[
|
|
1066
|
+
def alias_ips(self, value: Sequence[_builtins.str]):
|
|
1068
1067
|
pulumi.set(self, "alias_ips", value)
|
|
1069
1068
|
|
|
1070
|
-
@property
|
|
1069
|
+
@_builtins.property
|
|
1071
1070
|
@pulumi.getter
|
|
1072
|
-
def ip(self) ->
|
|
1071
|
+
def ip(self) -> _builtins.str:
|
|
1073
1072
|
"""
|
|
1074
1073
|
(string) The server's IP address within the network.
|
|
1075
1074
|
"""
|
|
1076
1075
|
return pulumi.get(self, "ip")
|
|
1077
1076
|
|
|
1078
1077
|
@ip.setter
|
|
1079
|
-
def ip(self, value:
|
|
1078
|
+
def ip(self, value: _builtins.str):
|
|
1080
1079
|
pulumi.set(self, "ip", value)
|
|
1081
1080
|
|
|
1082
|
-
@property
|
|
1081
|
+
@_builtins.property
|
|
1083
1082
|
@pulumi.getter(name="macAddress")
|
|
1084
|
-
def mac_address(self) ->
|
|
1083
|
+
def mac_address(self) -> _builtins.str:
|
|
1085
1084
|
"""
|
|
1086
1085
|
(string) The MAC address associated with the server's private network interface.
|
|
1087
1086
|
"""
|
|
1088
1087
|
return pulumi.get(self, "mac_address")
|
|
1089
1088
|
|
|
1090
1089
|
@mac_address.setter
|
|
1091
|
-
def mac_address(self, value:
|
|
1090
|
+
def mac_address(self, value: _builtins.str):
|
|
1092
1091
|
pulumi.set(self, "mac_address", value)
|
|
1093
1092
|
|
|
1094
|
-
@property
|
|
1093
|
+
@_builtins.property
|
|
1095
1094
|
@pulumi.getter(name="networkId")
|
|
1096
|
-
def network_id(self) ->
|
|
1095
|
+
def network_id(self) -> _builtins.int:
|
|
1097
1096
|
"""
|
|
1098
1097
|
(int) The unique identifier for the network.
|
|
1099
1098
|
"""
|
|
1100
1099
|
return pulumi.get(self, "network_id")
|
|
1101
1100
|
|
|
1102
1101
|
@network_id.setter
|
|
1103
|
-
def network_id(self, value:
|
|
1102
|
+
def network_id(self, value: _builtins.int):
|
|
1104
1103
|
pulumi.set(self, "network_id", value)
|
|
1105
1104
|
|
|
1106
1105
|
|