pulumi-vsphere 4.8.1__py3-none-any.whl → 4.9.0__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_vsphere/__init__.py +10 -0
- pulumi_vsphere/_inputs.py +675 -28
- pulumi_vsphere/compute_cluster.py +155 -7
- pulumi_vsphere/config/__init__.pyi +73 -0
- pulumi_vsphere/get_guest_os_customization.py +173 -0
- pulumi_vsphere/guest_os_customization.py +350 -0
- pulumi_vsphere/outputs.py +952 -84
- {pulumi_vsphere-4.8.1.dist-info → pulumi_vsphere-4.9.0.dist-info}/METADATA +1 -1
- {pulumi_vsphere-4.8.1.dist-info → pulumi_vsphere-4.9.0.dist-info}/RECORD +11 -8
- {pulumi_vsphere-4.8.1.dist-info → pulumi_vsphere-4.9.0.dist-info}/WHEEL +1 -1
- {pulumi_vsphere-4.8.1.dist-info → pulumi_vsphere-4.9.0.dist-info}/top_level.txt +0 -0
pulumi_vsphere/_inputs.py
CHANGED
|
@@ -11,6 +11,9 @@ from . import _utilities
|
|
|
11
11
|
|
|
12
12
|
__all__ = [
|
|
13
13
|
'ComputeClusterVsanDiskGroupArgs',
|
|
14
|
+
'ComputeClusterVsanFaultDomainArgs',
|
|
15
|
+
'ComputeClusterVsanFaultDomainFaultDomainArgs',
|
|
16
|
+
'ComputeClusterVsanStretchedClusterArgs',
|
|
14
17
|
'ContentLibraryPublicationArgs',
|
|
15
18
|
'ContentLibrarySubscriptionArgs',
|
|
16
19
|
'DistributedPortGroupVlanRangeArgs',
|
|
@@ -18,9 +21,14 @@ __all__ = [
|
|
|
18
21
|
'DistributedVirtualSwitchPvlanMappingArgs',
|
|
19
22
|
'DistributedVirtualSwitchVlanRangeArgs',
|
|
20
23
|
'EntityPermissionsPermissionArgs',
|
|
24
|
+
'GuestOsCustomizationSpecArgs',
|
|
25
|
+
'GuestOsCustomizationSpecLinuxOptionsArgs',
|
|
26
|
+
'GuestOsCustomizationSpecNetworkInterfaceArgs',
|
|
27
|
+
'GuestOsCustomizationSpecWindowsOptionsArgs',
|
|
21
28
|
'HostPortGroupPortArgs',
|
|
22
29
|
'VirtualMachineCdromArgs',
|
|
23
30
|
'VirtualMachineCloneArgs',
|
|
31
|
+
'VirtualMachineCloneCustomizationSpecArgs',
|
|
24
32
|
'VirtualMachineCloneCustomizeArgs',
|
|
25
33
|
'VirtualMachineCloneCustomizeLinuxOptionsArgs',
|
|
26
34
|
'VirtualMachineCloneCustomizeNetworkInterfaceArgs',
|
|
@@ -43,6 +51,111 @@ class ComputeClusterVsanDiskGroupArgs:
|
|
|
43
51
|
"""
|
|
44
52
|
:param pulumi.Input[str] cache: The canonical name of the disk to use for vSAN cache.
|
|
45
53
|
:param pulumi.Input[Sequence[pulumi.Input[str]]] storages: An array of disk canonical names for vSAN storage.
|
|
54
|
+
"""
|
|
55
|
+
if cache is not None:
|
|
56
|
+
pulumi.set(__self__, "cache", cache)
|
|
57
|
+
if storages is not None:
|
|
58
|
+
pulumi.set(__self__, "storages", storages)
|
|
59
|
+
|
|
60
|
+
@property
|
|
61
|
+
@pulumi.getter
|
|
62
|
+
def cache(self) -> Optional[pulumi.Input[str]]:
|
|
63
|
+
"""
|
|
64
|
+
The canonical name of the disk to use for vSAN cache.
|
|
65
|
+
"""
|
|
66
|
+
return pulumi.get(self, "cache")
|
|
67
|
+
|
|
68
|
+
@cache.setter
|
|
69
|
+
def cache(self, value: Optional[pulumi.Input[str]]):
|
|
70
|
+
pulumi.set(self, "cache", value)
|
|
71
|
+
|
|
72
|
+
@property
|
|
73
|
+
@pulumi.getter
|
|
74
|
+
def storages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
75
|
+
"""
|
|
76
|
+
An array of disk canonical names for vSAN storage.
|
|
77
|
+
"""
|
|
78
|
+
return pulumi.get(self, "storages")
|
|
79
|
+
|
|
80
|
+
@storages.setter
|
|
81
|
+
def storages(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
82
|
+
pulumi.set(self, "storages", value)
|
|
83
|
+
|
|
84
|
+
|
|
85
|
+
@pulumi.input_type
|
|
86
|
+
class ComputeClusterVsanFaultDomainArgs:
|
|
87
|
+
def __init__(__self__, *,
|
|
88
|
+
fault_domains: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterVsanFaultDomainFaultDomainArgs']]]] = None):
|
|
89
|
+
"""
|
|
90
|
+
:param pulumi.Input[Sequence[pulumi.Input['ComputeClusterVsanFaultDomainFaultDomainArgs']]] fault_domains: The configuration for single fault domain.
|
|
91
|
+
"""
|
|
92
|
+
if fault_domains is not None:
|
|
93
|
+
pulumi.set(__self__, "fault_domains", fault_domains)
|
|
94
|
+
|
|
95
|
+
@property
|
|
96
|
+
@pulumi.getter(name="faultDomains")
|
|
97
|
+
def fault_domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterVsanFaultDomainFaultDomainArgs']]]]:
|
|
98
|
+
"""
|
|
99
|
+
The configuration for single fault domain.
|
|
100
|
+
"""
|
|
101
|
+
return pulumi.get(self, "fault_domains")
|
|
102
|
+
|
|
103
|
+
@fault_domains.setter
|
|
104
|
+
def fault_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterVsanFaultDomainFaultDomainArgs']]]]):
|
|
105
|
+
pulumi.set(self, "fault_domains", value)
|
|
106
|
+
|
|
107
|
+
|
|
108
|
+
@pulumi.input_type
|
|
109
|
+
class ComputeClusterVsanFaultDomainFaultDomainArgs:
|
|
110
|
+
def __init__(__self__, *,
|
|
111
|
+
host_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
112
|
+
name: pulumi.Input[str]):
|
|
113
|
+
"""
|
|
114
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] host_ids: The managed object IDs of the hosts to put in the fault domain.
|
|
115
|
+
:param pulumi.Input[str] name: The name of the cluster.
|
|
116
|
+
"""
|
|
117
|
+
pulumi.set(__self__, "host_ids", host_ids)
|
|
118
|
+
pulumi.set(__self__, "name", name)
|
|
119
|
+
|
|
120
|
+
@property
|
|
121
|
+
@pulumi.getter(name="hostIds")
|
|
122
|
+
def host_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
123
|
+
"""
|
|
124
|
+
The managed object IDs of the hosts to put in the fault domain.
|
|
125
|
+
"""
|
|
126
|
+
return pulumi.get(self, "host_ids")
|
|
127
|
+
|
|
128
|
+
@host_ids.setter
|
|
129
|
+
def host_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
130
|
+
pulumi.set(self, "host_ids", value)
|
|
131
|
+
|
|
132
|
+
@property
|
|
133
|
+
@pulumi.getter
|
|
134
|
+
def name(self) -> pulumi.Input[str]:
|
|
135
|
+
"""
|
|
136
|
+
The name of the cluster.
|
|
137
|
+
"""
|
|
138
|
+
return pulumi.get(self, "name")
|
|
139
|
+
|
|
140
|
+
@name.setter
|
|
141
|
+
def name(self, value: pulumi.Input[str]):
|
|
142
|
+
pulumi.set(self, "name", value)
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
@pulumi.input_type
|
|
146
|
+
class ComputeClusterVsanStretchedClusterArgs:
|
|
147
|
+
def __init__(__self__, *,
|
|
148
|
+
preferred_fault_domain_host_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
149
|
+
secondary_fault_domain_host_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
150
|
+
witness_node: pulumi.Input[str],
|
|
151
|
+
preferred_fault_domain_name: Optional[pulumi.Input[str]] = None,
|
|
152
|
+
secondary_fault_domain_name: Optional[pulumi.Input[str]] = None):
|
|
153
|
+
"""
|
|
154
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_fault_domain_host_ids: The managed object IDs of the hosts to put in the first fault domain.
|
|
155
|
+
:param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_fault_domain_host_ids: The managed object IDs of the hosts to put in the second fault domain.
|
|
156
|
+
:param pulumi.Input[str] witness_node: The managed object IDs of the host selected as witness node when enable stretched cluster.
|
|
157
|
+
:param pulumi.Input[str] preferred_fault_domain_name: The name of first fault domain. Default is `Preferred`.
|
|
158
|
+
:param pulumi.Input[str] secondary_fault_domain_name: The name of second fault domain. Default is `Secondary`.
|
|
46
159
|
|
|
47
160
|
> **NOTE:** You must disable vSphere HA before you enable vSAN on the cluster.
|
|
48
161
|
You can enable or re-enable vSphere HA after vSAN is configured.
|
|
@@ -58,6 +171,7 @@ class ComputeClusterVsanDiskGroupArgs:
|
|
|
58
171
|
drs_automation_level="fullyAutomated",
|
|
59
172
|
ha_enabled=False,
|
|
60
173
|
vsan_enabled=True,
|
|
174
|
+
vsan_esa_enabled=True,
|
|
61
175
|
vsan_dedup_enabled=True,
|
|
62
176
|
vsan_compression_enabled=True,
|
|
63
177
|
vsan_performance_enabled=True,
|
|
@@ -69,31 +183,87 @@ class ComputeClusterVsanDiskGroupArgs:
|
|
|
69
183
|
vsan_disk_groups=[vsphere.ComputeClusterVsanDiskGroupArgs(
|
|
70
184
|
cache=data["vsphere_vmfs_disks"]["cache_disks"],
|
|
71
185
|
storages=data["vsphere_vmfs_disks"]["storage_disks"],
|
|
72
|
-
)]
|
|
186
|
+
)],
|
|
187
|
+
vsan_fault_domains=[vsphere.ComputeClusterVsanFaultDomainArgs(
|
|
188
|
+
fault_domains=[
|
|
189
|
+
vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
|
|
190
|
+
name="fd1",
|
|
191
|
+
host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain1_hosts"]]],
|
|
192
|
+
),
|
|
193
|
+
vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
|
|
194
|
+
name="fd2",
|
|
195
|
+
host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain2_hosts"]]],
|
|
196
|
+
),
|
|
197
|
+
],
|
|
198
|
+
)],
|
|
199
|
+
vsan_stretched_cluster=vsphere.ComputeClusterVsanStretchedClusterArgs(
|
|
200
|
+
preferred_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["preferred_fault_domain_host"]]],
|
|
201
|
+
secondary_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["secondary_fault_domain_host"]]],
|
|
202
|
+
witness_node=data["vsphere_host"]["witness_host"]["id"],
|
|
203
|
+
))
|
|
73
204
|
```
|
|
74
205
|
"""
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
206
|
+
pulumi.set(__self__, "preferred_fault_domain_host_ids", preferred_fault_domain_host_ids)
|
|
207
|
+
pulumi.set(__self__, "secondary_fault_domain_host_ids", secondary_fault_domain_host_ids)
|
|
208
|
+
pulumi.set(__self__, "witness_node", witness_node)
|
|
209
|
+
if preferred_fault_domain_name is not None:
|
|
210
|
+
pulumi.set(__self__, "preferred_fault_domain_name", preferred_fault_domain_name)
|
|
211
|
+
if secondary_fault_domain_name is not None:
|
|
212
|
+
pulumi.set(__self__, "secondary_fault_domain_name", secondary_fault_domain_name)
|
|
79
213
|
|
|
80
214
|
@property
|
|
81
|
-
@pulumi.getter
|
|
82
|
-
def
|
|
215
|
+
@pulumi.getter(name="preferredFaultDomainHostIds")
|
|
216
|
+
def preferred_fault_domain_host_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
83
217
|
"""
|
|
84
|
-
The
|
|
218
|
+
The managed object IDs of the hosts to put in the first fault domain.
|
|
85
219
|
"""
|
|
86
|
-
return pulumi.get(self, "
|
|
220
|
+
return pulumi.get(self, "preferred_fault_domain_host_ids")
|
|
87
221
|
|
|
88
|
-
@
|
|
89
|
-
def
|
|
90
|
-
pulumi.set(self, "
|
|
222
|
+
@preferred_fault_domain_host_ids.setter
|
|
223
|
+
def preferred_fault_domain_host_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
224
|
+
pulumi.set(self, "preferred_fault_domain_host_ids", value)
|
|
91
225
|
|
|
92
226
|
@property
|
|
93
|
-
@pulumi.getter
|
|
94
|
-
def
|
|
227
|
+
@pulumi.getter(name="secondaryFaultDomainHostIds")
|
|
228
|
+
def secondary_fault_domain_host_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
95
229
|
"""
|
|
96
|
-
|
|
230
|
+
The managed object IDs of the hosts to put in the second fault domain.
|
|
231
|
+
"""
|
|
232
|
+
return pulumi.get(self, "secondary_fault_domain_host_ids")
|
|
233
|
+
|
|
234
|
+
@secondary_fault_domain_host_ids.setter
|
|
235
|
+
def secondary_fault_domain_host_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
236
|
+
pulumi.set(self, "secondary_fault_domain_host_ids", value)
|
|
237
|
+
|
|
238
|
+
@property
|
|
239
|
+
@pulumi.getter(name="witnessNode")
|
|
240
|
+
def witness_node(self) -> pulumi.Input[str]:
|
|
241
|
+
"""
|
|
242
|
+
The managed object IDs of the host selected as witness node when enable stretched cluster.
|
|
243
|
+
"""
|
|
244
|
+
return pulumi.get(self, "witness_node")
|
|
245
|
+
|
|
246
|
+
@witness_node.setter
|
|
247
|
+
def witness_node(self, value: pulumi.Input[str]):
|
|
248
|
+
pulumi.set(self, "witness_node", value)
|
|
249
|
+
|
|
250
|
+
@property
|
|
251
|
+
@pulumi.getter(name="preferredFaultDomainName")
|
|
252
|
+
def preferred_fault_domain_name(self) -> Optional[pulumi.Input[str]]:
|
|
253
|
+
"""
|
|
254
|
+
The name of first fault domain. Default is `Preferred`.
|
|
255
|
+
"""
|
|
256
|
+
return pulumi.get(self, "preferred_fault_domain_name")
|
|
257
|
+
|
|
258
|
+
@preferred_fault_domain_name.setter
|
|
259
|
+
def preferred_fault_domain_name(self, value: Optional[pulumi.Input[str]]):
|
|
260
|
+
pulumi.set(self, "preferred_fault_domain_name", value)
|
|
261
|
+
|
|
262
|
+
@property
|
|
263
|
+
@pulumi.getter(name="secondaryFaultDomainName")
|
|
264
|
+
def secondary_fault_domain_name(self) -> Optional[pulumi.Input[str]]:
|
|
265
|
+
"""
|
|
266
|
+
The name of second fault domain. Default is `Secondary`.
|
|
97
267
|
|
|
98
268
|
> **NOTE:** You must disable vSphere HA before you enable vSAN on the cluster.
|
|
99
269
|
You can enable or re-enable vSphere HA after vSAN is configured.
|
|
@@ -109,6 +279,7 @@ class ComputeClusterVsanDiskGroupArgs:
|
|
|
109
279
|
drs_automation_level="fullyAutomated",
|
|
110
280
|
ha_enabled=False,
|
|
111
281
|
vsan_enabled=True,
|
|
282
|
+
vsan_esa_enabled=True,
|
|
112
283
|
vsan_dedup_enabled=True,
|
|
113
284
|
vsan_compression_enabled=True,
|
|
114
285
|
vsan_performance_enabled=True,
|
|
@@ -120,14 +291,31 @@ class ComputeClusterVsanDiskGroupArgs:
|
|
|
120
291
|
vsan_disk_groups=[vsphere.ComputeClusterVsanDiskGroupArgs(
|
|
121
292
|
cache=data["vsphere_vmfs_disks"]["cache_disks"],
|
|
122
293
|
storages=data["vsphere_vmfs_disks"]["storage_disks"],
|
|
123
|
-
)]
|
|
294
|
+
)],
|
|
295
|
+
vsan_fault_domains=[vsphere.ComputeClusterVsanFaultDomainArgs(
|
|
296
|
+
fault_domains=[
|
|
297
|
+
vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
|
|
298
|
+
name="fd1",
|
|
299
|
+
host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain1_hosts"]]],
|
|
300
|
+
),
|
|
301
|
+
vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
|
|
302
|
+
name="fd2",
|
|
303
|
+
host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain2_hosts"]]],
|
|
304
|
+
),
|
|
305
|
+
],
|
|
306
|
+
)],
|
|
307
|
+
vsan_stretched_cluster=vsphere.ComputeClusterVsanStretchedClusterArgs(
|
|
308
|
+
preferred_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["preferred_fault_domain_host"]]],
|
|
309
|
+
secondary_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["secondary_fault_domain_host"]]],
|
|
310
|
+
witness_node=data["vsphere_host"]["witness_host"]["id"],
|
|
311
|
+
))
|
|
124
312
|
```
|
|
125
313
|
"""
|
|
126
|
-
return pulumi.get(self, "
|
|
314
|
+
return pulumi.get(self, "secondary_fault_domain_name")
|
|
127
315
|
|
|
128
|
-
@
|
|
129
|
-
def
|
|
130
|
-
pulumi.set(self, "
|
|
316
|
+
@secondary_fault_domain_name.setter
|
|
317
|
+
def secondary_fault_domain_name(self, value: Optional[pulumi.Input[str]]):
|
|
318
|
+
pulumi.set(self, "secondary_fault_domain_name", value)
|
|
131
319
|
|
|
132
320
|
|
|
133
321
|
@pulumi.input_type
|
|
@@ -541,6 +729,407 @@ class EntityPermissionsPermissionArgs:
|
|
|
541
729
|
pulumi.set(self, "user_or_group", value)
|
|
542
730
|
|
|
543
731
|
|
|
732
|
+
@pulumi.input_type
|
|
733
|
+
class GuestOsCustomizationSpecArgs:
|
|
734
|
+
def __init__(__self__, *,
|
|
735
|
+
dns_server_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
736
|
+
dns_suffix_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
737
|
+
ipv4_gateway: Optional[pulumi.Input[str]] = None,
|
|
738
|
+
ipv6_gateway: Optional[pulumi.Input[str]] = None,
|
|
739
|
+
linux_options: Optional[pulumi.Input['GuestOsCustomizationSpecLinuxOptionsArgs']] = None,
|
|
740
|
+
network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['GuestOsCustomizationSpecNetworkInterfaceArgs']]]] = None,
|
|
741
|
+
windows_options: Optional[pulumi.Input['GuestOsCustomizationSpecWindowsOptionsArgs']] = None,
|
|
742
|
+
windows_sysprep_text: Optional[pulumi.Input[str]] = None):
|
|
743
|
+
if dns_server_lists is not None:
|
|
744
|
+
pulumi.set(__self__, "dns_server_lists", dns_server_lists)
|
|
745
|
+
if dns_suffix_lists is not None:
|
|
746
|
+
pulumi.set(__self__, "dns_suffix_lists", dns_suffix_lists)
|
|
747
|
+
if ipv4_gateway is not None:
|
|
748
|
+
pulumi.set(__self__, "ipv4_gateway", ipv4_gateway)
|
|
749
|
+
if ipv6_gateway is not None:
|
|
750
|
+
pulumi.set(__self__, "ipv6_gateway", ipv6_gateway)
|
|
751
|
+
if linux_options is not None:
|
|
752
|
+
pulumi.set(__self__, "linux_options", linux_options)
|
|
753
|
+
if network_interfaces is not None:
|
|
754
|
+
pulumi.set(__self__, "network_interfaces", network_interfaces)
|
|
755
|
+
if windows_options is not None:
|
|
756
|
+
pulumi.set(__self__, "windows_options", windows_options)
|
|
757
|
+
if windows_sysprep_text is not None:
|
|
758
|
+
pulumi.set(__self__, "windows_sysprep_text", windows_sysprep_text)
|
|
759
|
+
|
|
760
|
+
@property
|
|
761
|
+
@pulumi.getter(name="dnsServerLists")
|
|
762
|
+
def dns_server_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
763
|
+
return pulumi.get(self, "dns_server_lists")
|
|
764
|
+
|
|
765
|
+
@dns_server_lists.setter
|
|
766
|
+
def dns_server_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
767
|
+
pulumi.set(self, "dns_server_lists", value)
|
|
768
|
+
|
|
769
|
+
@property
|
|
770
|
+
@pulumi.getter(name="dnsSuffixLists")
|
|
771
|
+
def dns_suffix_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
772
|
+
return pulumi.get(self, "dns_suffix_lists")
|
|
773
|
+
|
|
774
|
+
@dns_suffix_lists.setter
|
|
775
|
+
def dns_suffix_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
776
|
+
pulumi.set(self, "dns_suffix_lists", value)
|
|
777
|
+
|
|
778
|
+
@property
|
|
779
|
+
@pulumi.getter(name="ipv4Gateway")
|
|
780
|
+
def ipv4_gateway(self) -> Optional[pulumi.Input[str]]:
|
|
781
|
+
return pulumi.get(self, "ipv4_gateway")
|
|
782
|
+
|
|
783
|
+
@ipv4_gateway.setter
|
|
784
|
+
def ipv4_gateway(self, value: Optional[pulumi.Input[str]]):
|
|
785
|
+
pulumi.set(self, "ipv4_gateway", value)
|
|
786
|
+
|
|
787
|
+
@property
|
|
788
|
+
@pulumi.getter(name="ipv6Gateway")
|
|
789
|
+
def ipv6_gateway(self) -> Optional[pulumi.Input[str]]:
|
|
790
|
+
return pulumi.get(self, "ipv6_gateway")
|
|
791
|
+
|
|
792
|
+
@ipv6_gateway.setter
|
|
793
|
+
def ipv6_gateway(self, value: Optional[pulumi.Input[str]]):
|
|
794
|
+
pulumi.set(self, "ipv6_gateway", value)
|
|
795
|
+
|
|
796
|
+
@property
|
|
797
|
+
@pulumi.getter(name="linuxOptions")
|
|
798
|
+
def linux_options(self) -> Optional[pulumi.Input['GuestOsCustomizationSpecLinuxOptionsArgs']]:
|
|
799
|
+
return pulumi.get(self, "linux_options")
|
|
800
|
+
|
|
801
|
+
@linux_options.setter
|
|
802
|
+
def linux_options(self, value: Optional[pulumi.Input['GuestOsCustomizationSpecLinuxOptionsArgs']]):
|
|
803
|
+
pulumi.set(self, "linux_options", value)
|
|
804
|
+
|
|
805
|
+
@property
|
|
806
|
+
@pulumi.getter(name="networkInterfaces")
|
|
807
|
+
def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GuestOsCustomizationSpecNetworkInterfaceArgs']]]]:
|
|
808
|
+
return pulumi.get(self, "network_interfaces")
|
|
809
|
+
|
|
810
|
+
@network_interfaces.setter
|
|
811
|
+
def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GuestOsCustomizationSpecNetworkInterfaceArgs']]]]):
|
|
812
|
+
pulumi.set(self, "network_interfaces", value)
|
|
813
|
+
|
|
814
|
+
@property
|
|
815
|
+
@pulumi.getter(name="windowsOptions")
|
|
816
|
+
def windows_options(self) -> Optional[pulumi.Input['GuestOsCustomizationSpecWindowsOptionsArgs']]:
|
|
817
|
+
return pulumi.get(self, "windows_options")
|
|
818
|
+
|
|
819
|
+
@windows_options.setter
|
|
820
|
+
def windows_options(self, value: Optional[pulumi.Input['GuestOsCustomizationSpecWindowsOptionsArgs']]):
|
|
821
|
+
pulumi.set(self, "windows_options", value)
|
|
822
|
+
|
|
823
|
+
@property
|
|
824
|
+
@pulumi.getter(name="windowsSysprepText")
|
|
825
|
+
def windows_sysprep_text(self) -> Optional[pulumi.Input[str]]:
|
|
826
|
+
return pulumi.get(self, "windows_sysprep_text")
|
|
827
|
+
|
|
828
|
+
@windows_sysprep_text.setter
|
|
829
|
+
def windows_sysprep_text(self, value: Optional[pulumi.Input[str]]):
|
|
830
|
+
pulumi.set(self, "windows_sysprep_text", value)
|
|
831
|
+
|
|
832
|
+
|
|
833
|
+
@pulumi.input_type
|
|
834
|
+
class GuestOsCustomizationSpecLinuxOptionsArgs:
|
|
835
|
+
def __init__(__self__, *,
|
|
836
|
+
domain: pulumi.Input[str],
|
|
837
|
+
host_name: pulumi.Input[str],
|
|
838
|
+
hw_clock_utc: Optional[pulumi.Input[bool]] = None,
|
|
839
|
+
script_text: Optional[pulumi.Input[str]] = None,
|
|
840
|
+
time_zone: Optional[pulumi.Input[str]] = None):
|
|
841
|
+
pulumi.set(__self__, "domain", domain)
|
|
842
|
+
pulumi.set(__self__, "host_name", host_name)
|
|
843
|
+
if hw_clock_utc is not None:
|
|
844
|
+
pulumi.set(__self__, "hw_clock_utc", hw_clock_utc)
|
|
845
|
+
if script_text is not None:
|
|
846
|
+
pulumi.set(__self__, "script_text", script_text)
|
|
847
|
+
if time_zone is not None:
|
|
848
|
+
pulumi.set(__self__, "time_zone", time_zone)
|
|
849
|
+
|
|
850
|
+
@property
|
|
851
|
+
@pulumi.getter
|
|
852
|
+
def domain(self) -> pulumi.Input[str]:
|
|
853
|
+
return pulumi.get(self, "domain")
|
|
854
|
+
|
|
855
|
+
@domain.setter
|
|
856
|
+
def domain(self, value: pulumi.Input[str]):
|
|
857
|
+
pulumi.set(self, "domain", value)
|
|
858
|
+
|
|
859
|
+
@property
|
|
860
|
+
@pulumi.getter(name="hostName")
|
|
861
|
+
def host_name(self) -> pulumi.Input[str]:
|
|
862
|
+
return pulumi.get(self, "host_name")
|
|
863
|
+
|
|
864
|
+
@host_name.setter
|
|
865
|
+
def host_name(self, value: pulumi.Input[str]):
|
|
866
|
+
pulumi.set(self, "host_name", value)
|
|
867
|
+
|
|
868
|
+
@property
|
|
869
|
+
@pulumi.getter(name="hwClockUtc")
|
|
870
|
+
def hw_clock_utc(self) -> Optional[pulumi.Input[bool]]:
|
|
871
|
+
return pulumi.get(self, "hw_clock_utc")
|
|
872
|
+
|
|
873
|
+
@hw_clock_utc.setter
|
|
874
|
+
def hw_clock_utc(self, value: Optional[pulumi.Input[bool]]):
|
|
875
|
+
pulumi.set(self, "hw_clock_utc", value)
|
|
876
|
+
|
|
877
|
+
@property
|
|
878
|
+
@pulumi.getter(name="scriptText")
|
|
879
|
+
def script_text(self) -> Optional[pulumi.Input[str]]:
|
|
880
|
+
return pulumi.get(self, "script_text")
|
|
881
|
+
|
|
882
|
+
@script_text.setter
|
|
883
|
+
def script_text(self, value: Optional[pulumi.Input[str]]):
|
|
884
|
+
pulumi.set(self, "script_text", value)
|
|
885
|
+
|
|
886
|
+
@property
|
|
887
|
+
@pulumi.getter(name="timeZone")
|
|
888
|
+
def time_zone(self) -> Optional[pulumi.Input[str]]:
|
|
889
|
+
return pulumi.get(self, "time_zone")
|
|
890
|
+
|
|
891
|
+
@time_zone.setter
|
|
892
|
+
def time_zone(self, value: Optional[pulumi.Input[str]]):
|
|
893
|
+
pulumi.set(self, "time_zone", value)
|
|
894
|
+
|
|
895
|
+
|
|
896
|
+
@pulumi.input_type
|
|
897
|
+
class GuestOsCustomizationSpecNetworkInterfaceArgs:
|
|
898
|
+
def __init__(__self__, *,
|
|
899
|
+
dns_domain: Optional[pulumi.Input[str]] = None,
|
|
900
|
+
dns_server_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
901
|
+
ipv4_address: Optional[pulumi.Input[str]] = None,
|
|
902
|
+
ipv4_netmask: Optional[pulumi.Input[int]] = None,
|
|
903
|
+
ipv6_address: Optional[pulumi.Input[str]] = None,
|
|
904
|
+
ipv6_netmask: Optional[pulumi.Input[int]] = None):
|
|
905
|
+
if dns_domain is not None:
|
|
906
|
+
pulumi.set(__self__, "dns_domain", dns_domain)
|
|
907
|
+
if dns_server_lists is not None:
|
|
908
|
+
pulumi.set(__self__, "dns_server_lists", dns_server_lists)
|
|
909
|
+
if ipv4_address is not None:
|
|
910
|
+
pulumi.set(__self__, "ipv4_address", ipv4_address)
|
|
911
|
+
if ipv4_netmask is not None:
|
|
912
|
+
pulumi.set(__self__, "ipv4_netmask", ipv4_netmask)
|
|
913
|
+
if ipv6_address is not None:
|
|
914
|
+
pulumi.set(__self__, "ipv6_address", ipv6_address)
|
|
915
|
+
if ipv6_netmask is not None:
|
|
916
|
+
pulumi.set(__self__, "ipv6_netmask", ipv6_netmask)
|
|
917
|
+
|
|
918
|
+
@property
|
|
919
|
+
@pulumi.getter(name="dnsDomain")
|
|
920
|
+
def dns_domain(self) -> Optional[pulumi.Input[str]]:
|
|
921
|
+
return pulumi.get(self, "dns_domain")
|
|
922
|
+
|
|
923
|
+
@dns_domain.setter
|
|
924
|
+
def dns_domain(self, value: Optional[pulumi.Input[str]]):
|
|
925
|
+
pulumi.set(self, "dns_domain", value)
|
|
926
|
+
|
|
927
|
+
@property
|
|
928
|
+
@pulumi.getter(name="dnsServerLists")
|
|
929
|
+
def dns_server_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
930
|
+
return pulumi.get(self, "dns_server_lists")
|
|
931
|
+
|
|
932
|
+
@dns_server_lists.setter
|
|
933
|
+
def dns_server_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
934
|
+
pulumi.set(self, "dns_server_lists", value)
|
|
935
|
+
|
|
936
|
+
@property
|
|
937
|
+
@pulumi.getter(name="ipv4Address")
|
|
938
|
+
def ipv4_address(self) -> Optional[pulumi.Input[str]]:
|
|
939
|
+
return pulumi.get(self, "ipv4_address")
|
|
940
|
+
|
|
941
|
+
@ipv4_address.setter
|
|
942
|
+
def ipv4_address(self, value: Optional[pulumi.Input[str]]):
|
|
943
|
+
pulumi.set(self, "ipv4_address", value)
|
|
944
|
+
|
|
945
|
+
@property
|
|
946
|
+
@pulumi.getter(name="ipv4Netmask")
|
|
947
|
+
def ipv4_netmask(self) -> Optional[pulumi.Input[int]]:
|
|
948
|
+
return pulumi.get(self, "ipv4_netmask")
|
|
949
|
+
|
|
950
|
+
@ipv4_netmask.setter
|
|
951
|
+
def ipv4_netmask(self, value: Optional[pulumi.Input[int]]):
|
|
952
|
+
pulumi.set(self, "ipv4_netmask", value)
|
|
953
|
+
|
|
954
|
+
@property
|
|
955
|
+
@pulumi.getter(name="ipv6Address")
|
|
956
|
+
def ipv6_address(self) -> Optional[pulumi.Input[str]]:
|
|
957
|
+
return pulumi.get(self, "ipv6_address")
|
|
958
|
+
|
|
959
|
+
@ipv6_address.setter
|
|
960
|
+
def ipv6_address(self, value: Optional[pulumi.Input[str]]):
|
|
961
|
+
pulumi.set(self, "ipv6_address", value)
|
|
962
|
+
|
|
963
|
+
@property
|
|
964
|
+
@pulumi.getter(name="ipv6Netmask")
|
|
965
|
+
def ipv6_netmask(self) -> Optional[pulumi.Input[int]]:
|
|
966
|
+
return pulumi.get(self, "ipv6_netmask")
|
|
967
|
+
|
|
968
|
+
@ipv6_netmask.setter
|
|
969
|
+
def ipv6_netmask(self, value: Optional[pulumi.Input[int]]):
|
|
970
|
+
pulumi.set(self, "ipv6_netmask", value)
|
|
971
|
+
|
|
972
|
+
|
|
973
|
+
@pulumi.input_type
|
|
974
|
+
class GuestOsCustomizationSpecWindowsOptionsArgs:
|
|
975
|
+
def __init__(__self__, *,
|
|
976
|
+
computer_name: pulumi.Input[str],
|
|
977
|
+
admin_password: Optional[pulumi.Input[str]] = None,
|
|
978
|
+
auto_logon: Optional[pulumi.Input[bool]] = None,
|
|
979
|
+
auto_logon_count: Optional[pulumi.Input[int]] = None,
|
|
980
|
+
domain_admin_password: Optional[pulumi.Input[str]] = None,
|
|
981
|
+
domain_admin_user: Optional[pulumi.Input[str]] = None,
|
|
982
|
+
full_name: Optional[pulumi.Input[str]] = None,
|
|
983
|
+
join_domain: Optional[pulumi.Input[str]] = None,
|
|
984
|
+
organization_name: Optional[pulumi.Input[str]] = None,
|
|
985
|
+
product_key: Optional[pulumi.Input[str]] = None,
|
|
986
|
+
run_once_command_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
987
|
+
time_zone: Optional[pulumi.Input[int]] = None,
|
|
988
|
+
workgroup: Optional[pulumi.Input[str]] = None):
|
|
989
|
+
pulumi.set(__self__, "computer_name", computer_name)
|
|
990
|
+
if admin_password is not None:
|
|
991
|
+
pulumi.set(__self__, "admin_password", admin_password)
|
|
992
|
+
if auto_logon is not None:
|
|
993
|
+
pulumi.set(__self__, "auto_logon", auto_logon)
|
|
994
|
+
if auto_logon_count is not None:
|
|
995
|
+
pulumi.set(__self__, "auto_logon_count", auto_logon_count)
|
|
996
|
+
if domain_admin_password is not None:
|
|
997
|
+
pulumi.set(__self__, "domain_admin_password", domain_admin_password)
|
|
998
|
+
if domain_admin_user is not None:
|
|
999
|
+
pulumi.set(__self__, "domain_admin_user", domain_admin_user)
|
|
1000
|
+
if full_name is not None:
|
|
1001
|
+
pulumi.set(__self__, "full_name", full_name)
|
|
1002
|
+
if join_domain is not None:
|
|
1003
|
+
pulumi.set(__self__, "join_domain", join_domain)
|
|
1004
|
+
if organization_name is not None:
|
|
1005
|
+
pulumi.set(__self__, "organization_name", organization_name)
|
|
1006
|
+
if product_key is not None:
|
|
1007
|
+
pulumi.set(__self__, "product_key", product_key)
|
|
1008
|
+
if run_once_command_lists is not None:
|
|
1009
|
+
pulumi.set(__self__, "run_once_command_lists", run_once_command_lists)
|
|
1010
|
+
if time_zone is not None:
|
|
1011
|
+
pulumi.set(__self__, "time_zone", time_zone)
|
|
1012
|
+
if workgroup is not None:
|
|
1013
|
+
pulumi.set(__self__, "workgroup", workgroup)
|
|
1014
|
+
|
|
1015
|
+
@property
|
|
1016
|
+
@pulumi.getter(name="computerName")
|
|
1017
|
+
def computer_name(self) -> pulumi.Input[str]:
|
|
1018
|
+
return pulumi.get(self, "computer_name")
|
|
1019
|
+
|
|
1020
|
+
@computer_name.setter
|
|
1021
|
+
def computer_name(self, value: pulumi.Input[str]):
|
|
1022
|
+
pulumi.set(self, "computer_name", value)
|
|
1023
|
+
|
|
1024
|
+
@property
|
|
1025
|
+
@pulumi.getter(name="adminPassword")
|
|
1026
|
+
def admin_password(self) -> Optional[pulumi.Input[str]]:
|
|
1027
|
+
return pulumi.get(self, "admin_password")
|
|
1028
|
+
|
|
1029
|
+
@admin_password.setter
|
|
1030
|
+
def admin_password(self, value: Optional[pulumi.Input[str]]):
|
|
1031
|
+
pulumi.set(self, "admin_password", value)
|
|
1032
|
+
|
|
1033
|
+
@property
|
|
1034
|
+
@pulumi.getter(name="autoLogon")
|
|
1035
|
+
def auto_logon(self) -> Optional[pulumi.Input[bool]]:
|
|
1036
|
+
return pulumi.get(self, "auto_logon")
|
|
1037
|
+
|
|
1038
|
+
@auto_logon.setter
|
|
1039
|
+
def auto_logon(self, value: Optional[pulumi.Input[bool]]):
|
|
1040
|
+
pulumi.set(self, "auto_logon", value)
|
|
1041
|
+
|
|
1042
|
+
@property
|
|
1043
|
+
@pulumi.getter(name="autoLogonCount")
|
|
1044
|
+
def auto_logon_count(self) -> Optional[pulumi.Input[int]]:
|
|
1045
|
+
return pulumi.get(self, "auto_logon_count")
|
|
1046
|
+
|
|
1047
|
+
@auto_logon_count.setter
|
|
1048
|
+
def auto_logon_count(self, value: Optional[pulumi.Input[int]]):
|
|
1049
|
+
pulumi.set(self, "auto_logon_count", value)
|
|
1050
|
+
|
|
1051
|
+
@property
|
|
1052
|
+
@pulumi.getter(name="domainAdminPassword")
|
|
1053
|
+
def domain_admin_password(self) -> Optional[pulumi.Input[str]]:
|
|
1054
|
+
return pulumi.get(self, "domain_admin_password")
|
|
1055
|
+
|
|
1056
|
+
@domain_admin_password.setter
|
|
1057
|
+
def domain_admin_password(self, value: Optional[pulumi.Input[str]]):
|
|
1058
|
+
pulumi.set(self, "domain_admin_password", value)
|
|
1059
|
+
|
|
1060
|
+
@property
|
|
1061
|
+
@pulumi.getter(name="domainAdminUser")
|
|
1062
|
+
def domain_admin_user(self) -> Optional[pulumi.Input[str]]:
|
|
1063
|
+
return pulumi.get(self, "domain_admin_user")
|
|
1064
|
+
|
|
1065
|
+
@domain_admin_user.setter
|
|
1066
|
+
def domain_admin_user(self, value: Optional[pulumi.Input[str]]):
|
|
1067
|
+
pulumi.set(self, "domain_admin_user", value)
|
|
1068
|
+
|
|
1069
|
+
@property
|
|
1070
|
+
@pulumi.getter(name="fullName")
|
|
1071
|
+
def full_name(self) -> Optional[pulumi.Input[str]]:
|
|
1072
|
+
return pulumi.get(self, "full_name")
|
|
1073
|
+
|
|
1074
|
+
@full_name.setter
|
|
1075
|
+
def full_name(self, value: Optional[pulumi.Input[str]]):
|
|
1076
|
+
pulumi.set(self, "full_name", value)
|
|
1077
|
+
|
|
1078
|
+
@property
|
|
1079
|
+
@pulumi.getter(name="joinDomain")
|
|
1080
|
+
def join_domain(self) -> Optional[pulumi.Input[str]]:
|
|
1081
|
+
return pulumi.get(self, "join_domain")
|
|
1082
|
+
|
|
1083
|
+
@join_domain.setter
|
|
1084
|
+
def join_domain(self, value: Optional[pulumi.Input[str]]):
|
|
1085
|
+
pulumi.set(self, "join_domain", value)
|
|
1086
|
+
|
|
1087
|
+
@property
|
|
1088
|
+
@pulumi.getter(name="organizationName")
|
|
1089
|
+
def organization_name(self) -> Optional[pulumi.Input[str]]:
|
|
1090
|
+
return pulumi.get(self, "organization_name")
|
|
1091
|
+
|
|
1092
|
+
@organization_name.setter
|
|
1093
|
+
def organization_name(self, value: Optional[pulumi.Input[str]]):
|
|
1094
|
+
pulumi.set(self, "organization_name", value)
|
|
1095
|
+
|
|
1096
|
+
@property
|
|
1097
|
+
@pulumi.getter(name="productKey")
|
|
1098
|
+
def product_key(self) -> Optional[pulumi.Input[str]]:
|
|
1099
|
+
return pulumi.get(self, "product_key")
|
|
1100
|
+
|
|
1101
|
+
@product_key.setter
|
|
1102
|
+
def product_key(self, value: Optional[pulumi.Input[str]]):
|
|
1103
|
+
pulumi.set(self, "product_key", value)
|
|
1104
|
+
|
|
1105
|
+
@property
|
|
1106
|
+
@pulumi.getter(name="runOnceCommandLists")
|
|
1107
|
+
def run_once_command_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
1108
|
+
return pulumi.get(self, "run_once_command_lists")
|
|
1109
|
+
|
|
1110
|
+
@run_once_command_lists.setter
|
|
1111
|
+
def run_once_command_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
1112
|
+
pulumi.set(self, "run_once_command_lists", value)
|
|
1113
|
+
|
|
1114
|
+
@property
|
|
1115
|
+
@pulumi.getter(name="timeZone")
|
|
1116
|
+
def time_zone(self) -> Optional[pulumi.Input[int]]:
|
|
1117
|
+
return pulumi.get(self, "time_zone")
|
|
1118
|
+
|
|
1119
|
+
@time_zone.setter
|
|
1120
|
+
def time_zone(self, value: Optional[pulumi.Input[int]]):
|
|
1121
|
+
pulumi.set(self, "time_zone", value)
|
|
1122
|
+
|
|
1123
|
+
@property
|
|
1124
|
+
@pulumi.getter
|
|
1125
|
+
def workgroup(self) -> Optional[pulumi.Input[str]]:
|
|
1126
|
+
return pulumi.get(self, "workgroup")
|
|
1127
|
+
|
|
1128
|
+
@workgroup.setter
|
|
1129
|
+
def workgroup(self, value: Optional[pulumi.Input[str]]):
|
|
1130
|
+
pulumi.set(self, "workgroup", value)
|
|
1131
|
+
|
|
1132
|
+
|
|
544
1133
|
@pulumi.input_type
|
|
545
1134
|
class HostPortGroupPortArgs:
|
|
546
1135
|
def __init__(__self__, *,
|
|
@@ -683,12 +1272,15 @@ class VirtualMachineCdromArgs:
|
|
|
683
1272
|
class VirtualMachineCloneArgs:
|
|
684
1273
|
def __init__(__self__, *,
|
|
685
1274
|
template_uuid: pulumi.Input[str],
|
|
1275
|
+
customization_spec: Optional[pulumi.Input['VirtualMachineCloneCustomizationSpecArgs']] = None,
|
|
686
1276
|
customize: Optional[pulumi.Input['VirtualMachineCloneCustomizeArgs']] = None,
|
|
687
1277
|
linked_clone: Optional[pulumi.Input[bool]] = None,
|
|
688
1278
|
ovf_network_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
689
1279
|
ovf_storage_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
690
1280
|
timeout: Optional[pulumi.Input[int]] = None):
|
|
691
1281
|
pulumi.set(__self__, "template_uuid", template_uuid)
|
|
1282
|
+
if customization_spec is not None:
|
|
1283
|
+
pulumi.set(__self__, "customization_spec", customization_spec)
|
|
692
1284
|
if customize is not None:
|
|
693
1285
|
pulumi.set(__self__, "customize", customize)
|
|
694
1286
|
if linked_clone is not None:
|
|
@@ -709,6 +1301,15 @@ class VirtualMachineCloneArgs:
|
|
|
709
1301
|
def template_uuid(self, value: pulumi.Input[str]):
|
|
710
1302
|
pulumi.set(self, "template_uuid", value)
|
|
711
1303
|
|
|
1304
|
+
@property
|
|
1305
|
+
@pulumi.getter(name="customizationSpec")
|
|
1306
|
+
def customization_spec(self) -> Optional[pulumi.Input['VirtualMachineCloneCustomizationSpecArgs']]:
|
|
1307
|
+
return pulumi.get(self, "customization_spec")
|
|
1308
|
+
|
|
1309
|
+
@customization_spec.setter
|
|
1310
|
+
def customization_spec(self, value: Optional[pulumi.Input['VirtualMachineCloneCustomizationSpecArgs']]):
|
|
1311
|
+
pulumi.set(self, "customization_spec", value)
|
|
1312
|
+
|
|
712
1313
|
@property
|
|
713
1314
|
@pulumi.getter
|
|
714
1315
|
def customize(self) -> Optional[pulumi.Input['VirtualMachineCloneCustomizeArgs']]:
|
|
@@ -755,6 +1356,40 @@ class VirtualMachineCloneArgs:
|
|
|
755
1356
|
pulumi.set(self, "timeout", value)
|
|
756
1357
|
|
|
757
1358
|
|
|
1359
|
+
@pulumi.input_type
|
|
1360
|
+
class VirtualMachineCloneCustomizationSpecArgs:
|
|
1361
|
+
def __init__(__self__, *,
|
|
1362
|
+
id: pulumi.Input[str],
|
|
1363
|
+
timeout: Optional[pulumi.Input[int]] = None):
|
|
1364
|
+
"""
|
|
1365
|
+
:param pulumi.Input[str] id: The UUID of the virtual machine.
|
|
1366
|
+
"""
|
|
1367
|
+
pulumi.set(__self__, "id", id)
|
|
1368
|
+
if timeout is not None:
|
|
1369
|
+
pulumi.set(__self__, "timeout", timeout)
|
|
1370
|
+
|
|
1371
|
+
@property
|
|
1372
|
+
@pulumi.getter
|
|
1373
|
+
def id(self) -> pulumi.Input[str]:
|
|
1374
|
+
"""
|
|
1375
|
+
The UUID of the virtual machine.
|
|
1376
|
+
"""
|
|
1377
|
+
return pulumi.get(self, "id")
|
|
1378
|
+
|
|
1379
|
+
@id.setter
|
|
1380
|
+
def id(self, value: pulumi.Input[str]):
|
|
1381
|
+
pulumi.set(self, "id", value)
|
|
1382
|
+
|
|
1383
|
+
@property
|
|
1384
|
+
@pulumi.getter
|
|
1385
|
+
def timeout(self) -> Optional[pulumi.Input[int]]:
|
|
1386
|
+
return pulumi.get(self, "timeout")
|
|
1387
|
+
|
|
1388
|
+
@timeout.setter
|
|
1389
|
+
def timeout(self, value: Optional[pulumi.Input[int]]):
|
|
1390
|
+
pulumi.set(self, "timeout", value)
|
|
1391
|
+
|
|
1392
|
+
|
|
758
1393
|
@pulumi.input_type
|
|
759
1394
|
class VirtualMachineCloneCustomizeArgs:
|
|
760
1395
|
def __init__(__self__, *,
|
|
@@ -1541,14 +2176,15 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1541
2176
|
key: Optional[pulumi.Input[int]] = None,
|
|
1542
2177
|
mac_address: Optional[pulumi.Input[str]] = None,
|
|
1543
2178
|
ovf_mapping: Optional[pulumi.Input[str]] = None,
|
|
2179
|
+
physical_function: Optional[pulumi.Input[str]] = None,
|
|
1544
2180
|
use_static_mac: Optional[pulumi.Input[bool]] = None):
|
|
1545
2181
|
"""
|
|
1546
2182
|
:param pulumi.Input[str] network_id: The [managed object reference ID][docs-about-morefs] of the network on which to connect the virtual machine network interface.
|
|
1547
|
-
:param pulumi.Input[str] adapter_type: The network interface type. One of `e1000`, `e1000e`, or `vmxnet3`. Default: `vmxnet3`.
|
|
1548
|
-
:param pulumi.Input[int] bandwidth_limit: The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit.
|
|
2183
|
+
:param pulumi.Input[str] adapter_type: The network interface type. One of `e1000`, `e1000e`, `sriov`, or `vmxnet3`. Default: `vmxnet3`.
|
|
2184
|
+
:param pulumi.Input[int] bandwidth_limit: The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit. Ignored if `adapter_type` is set to `sriov`.
|
|
1549
2185
|
:param pulumi.Input[int] bandwidth_reservation: The bandwidth reservation of the network interface, in Mbits/sec. The default is no reservation.
|
|
1550
|
-
:param pulumi.Input[int] bandwidth_share_count: The share count for the network interface when the share level is `custom`.
|
|
1551
|
-
:param pulumi.Input[str] bandwidth_share_level: The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`.
|
|
2186
|
+
:param pulumi.Input[int] bandwidth_share_count: The share count for the network interface when the share level is `custom`. Ignored if `adapter_type` is set to `sriov`.
|
|
2187
|
+
:param pulumi.Input[str] bandwidth_share_level: The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`. Ignored if `adapter_type` is set to `sriov`.
|
|
1552
2188
|
:param pulumi.Input[int] key: The ID of the device within the virtual machine.
|
|
1553
2189
|
:param pulumi.Input[str] mac_address: The MAC address of the network interface. Can only be manually set if `use_static_mac` is `true`. Otherwise, the value is computed and presents the assigned MAC address for the interface.
|
|
1554
2190
|
:param pulumi.Input[str] ovf_mapping: Specifies which NIC in an OVF/OVA the `network_interface` should be associated. Only applies at creation when deploying from an OVF/OVA.
|
|
@@ -1573,6 +2209,8 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1573
2209
|
pulumi.set(__self__, "mac_address", mac_address)
|
|
1574
2210
|
if ovf_mapping is not None:
|
|
1575
2211
|
pulumi.set(__self__, "ovf_mapping", ovf_mapping)
|
|
2212
|
+
if physical_function is not None:
|
|
2213
|
+
pulumi.set(__self__, "physical_function", physical_function)
|
|
1576
2214
|
if use_static_mac is not None:
|
|
1577
2215
|
pulumi.set(__self__, "use_static_mac", use_static_mac)
|
|
1578
2216
|
|
|
@@ -1592,7 +2230,7 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1592
2230
|
@pulumi.getter(name="adapterType")
|
|
1593
2231
|
def adapter_type(self) -> Optional[pulumi.Input[str]]:
|
|
1594
2232
|
"""
|
|
1595
|
-
The network interface type. One of `e1000`, `e1000e`, or `vmxnet3`. Default: `vmxnet3`.
|
|
2233
|
+
The network interface type. One of `e1000`, `e1000e`, `sriov`, or `vmxnet3`. Default: `vmxnet3`.
|
|
1596
2234
|
"""
|
|
1597
2235
|
return pulumi.get(self, "adapter_type")
|
|
1598
2236
|
|
|
@@ -1604,7 +2242,7 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1604
2242
|
@pulumi.getter(name="bandwidthLimit")
|
|
1605
2243
|
def bandwidth_limit(self) -> Optional[pulumi.Input[int]]:
|
|
1606
2244
|
"""
|
|
1607
|
-
The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit.
|
|
2245
|
+
The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit. Ignored if `adapter_type` is set to `sriov`.
|
|
1608
2246
|
"""
|
|
1609
2247
|
return pulumi.get(self, "bandwidth_limit")
|
|
1610
2248
|
|
|
@@ -1628,7 +2266,7 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1628
2266
|
@pulumi.getter(name="bandwidthShareCount")
|
|
1629
2267
|
def bandwidth_share_count(self) -> Optional[pulumi.Input[int]]:
|
|
1630
2268
|
"""
|
|
1631
|
-
The share count for the network interface when the share level is `custom`.
|
|
2269
|
+
The share count for the network interface when the share level is `custom`. Ignored if `adapter_type` is set to `sriov`.
|
|
1632
2270
|
"""
|
|
1633
2271
|
return pulumi.get(self, "bandwidth_share_count")
|
|
1634
2272
|
|
|
@@ -1640,7 +2278,7 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1640
2278
|
@pulumi.getter(name="bandwidthShareLevel")
|
|
1641
2279
|
def bandwidth_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
1642
2280
|
"""
|
|
1643
|
-
The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`.
|
|
2281
|
+
The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`. Ignored if `adapter_type` is set to `sriov`.
|
|
1644
2282
|
"""
|
|
1645
2283
|
return pulumi.get(self, "bandwidth_share_level")
|
|
1646
2284
|
|
|
@@ -1693,6 +2331,15 @@ class VirtualMachineNetworkInterfaceArgs:
|
|
|
1693
2331
|
def ovf_mapping(self, value: Optional[pulumi.Input[str]]):
|
|
1694
2332
|
pulumi.set(self, "ovf_mapping", value)
|
|
1695
2333
|
|
|
2334
|
+
@property
|
|
2335
|
+
@pulumi.getter(name="physicalFunction")
|
|
2336
|
+
def physical_function(self) -> Optional[pulumi.Input[str]]:
|
|
2337
|
+
return pulumi.get(self, "physical_function")
|
|
2338
|
+
|
|
2339
|
+
@physical_function.setter
|
|
2340
|
+
def physical_function(self, value: Optional[pulumi.Input[str]]):
|
|
2341
|
+
pulumi.set(self, "physical_function", value)
|
|
2342
|
+
|
|
1696
2343
|
@property
|
|
1697
2344
|
@pulumi.getter(name="useStaticMac")
|
|
1698
2345
|
def use_static_mac(self) -> Optional[pulumi.Input[bool]]:
|