pulumi-vsphere 4.10.0a1709017641__py3-none-any.whl → 4.17.0a1763710194__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-vsphere might be problematic. Click here for more details.
- pulumi_vsphere/__init__.py +51 -1
- pulumi_vsphere/_inputs.py +2568 -1025
- pulumi_vsphere/_utilities.py +50 -10
- pulumi_vsphere/compute_cluster.py +1564 -2373
- pulumi_vsphere/compute_cluster_host_group.py +191 -55
- pulumi_vsphere/compute_cluster_vm_affinity_rule.py +157 -113
- pulumi_vsphere/compute_cluster_vm_anti_affinity_rule.py +133 -89
- pulumi_vsphere/compute_cluster_vm_dependency_rule.py +314 -106
- pulumi_vsphere/compute_cluster_vm_group.py +256 -55
- pulumi_vsphere/compute_cluster_vm_host_rule.py +323 -123
- pulumi_vsphere/config/__init__.py +2 -1
- pulumi_vsphere/config/__init__.pyi +7 -2
- pulumi_vsphere/config/vars.py +20 -15
- pulumi_vsphere/configuration_profile.py +286 -0
- pulumi_vsphere/content_library.py +177 -71
- pulumi_vsphere/content_library_item.py +252 -106
- pulumi_vsphere/custom_attribute.py +118 -38
- pulumi_vsphere/datacenter.py +128 -107
- pulumi_vsphere/datastore_cluster.py +636 -731
- pulumi_vsphere/datastore_cluster_vm_anti_affinity_rule.py +251 -89
- pulumi_vsphere/distributed_port_group.py +1129 -967
- pulumi_vsphere/distributed_virtual_switch.py +1971 -2239
- pulumi_vsphere/distributed_virtual_switch_pvlan_mapping.py +294 -0
- pulumi_vsphere/dpm_host_override.py +222 -72
- pulumi_vsphere/drs_vm_override.py +236 -72
- pulumi_vsphere/entity_permissions.py +96 -69
- pulumi_vsphere/file.py +173 -178
- pulumi_vsphere/folder.py +236 -113
- pulumi_vsphere/get_compute_cluster.py +34 -23
- pulumi_vsphere/get_compute_cluster_host_group.py +52 -41
- pulumi_vsphere/get_configuration_profile.py +145 -0
- pulumi_vsphere/get_content_library.py +33 -21
- pulumi_vsphere/get_content_library_item.py +47 -31
- pulumi_vsphere/get_custom_attribute.py +26 -17
- pulumi_vsphere/get_datacenter.py +40 -18
- pulumi_vsphere/get_datastore.py +60 -24
- pulumi_vsphere/get_datastore_cluster.py +47 -22
- pulumi_vsphere/get_datastore_stats.py +204 -0
- pulumi_vsphere/get_distributed_virtual_switch.py +36 -23
- pulumi_vsphere/get_dynamic.py +55 -45
- pulumi_vsphere/get_folder.py +163 -25
- pulumi_vsphere/get_guest_os_customization.py +68 -37
- pulumi_vsphere/get_host.py +34 -23
- pulumi_vsphere/get_host_base_images.py +104 -0
- pulumi_vsphere/get_host_pci_device.py +78 -35
- pulumi_vsphere/get_host_thumbprint.py +58 -38
- pulumi_vsphere/get_host_vgpu_profile.py +195 -0
- pulumi_vsphere/get_license.py +44 -28
- pulumi_vsphere/get_network.py +157 -46
- pulumi_vsphere/get_ovf_vm_template.py +184 -301
- pulumi_vsphere/get_policy.py +23 -15
- pulumi_vsphere/get_resource_pool.py +107 -40
- pulumi_vsphere/get_role.py +49 -35
- pulumi_vsphere/get_tag.py +34 -23
- pulumi_vsphere/get_tag_category.py +32 -21
- pulumi_vsphere/get_vapp_container.py +31 -21
- pulumi_vsphere/get_virtual_machine.py +499 -287
- pulumi_vsphere/get_vmfs_disks.py +42 -29
- pulumi_vsphere/guest_os_customization.py +135 -79
- pulumi_vsphere/ha_vm_override.py +470 -577
- pulumi_vsphere/host.py +515 -262
- pulumi_vsphere/host_port_group.py +352 -355
- pulumi_vsphere/host_virtual_switch.py +580 -580
- pulumi_vsphere/license.py +110 -92
- pulumi_vsphere/nas_datastore.py +398 -270
- pulumi_vsphere/offline_software_depot.py +190 -0
- pulumi_vsphere/outputs.py +1582 -1027
- pulumi_vsphere/provider.py +172 -152
- pulumi_vsphere/pulumi-plugin.json +2 -1
- pulumi_vsphere/resource_pool.py +357 -273
- pulumi_vsphere/role.py +79 -47
- pulumi_vsphere/storage_drs_vm_override.py +225 -89
- pulumi_vsphere/supervisor.py +1064 -0
- pulumi_vsphere/tag.py +217 -55
- pulumi_vsphere/tag_category.py +158 -72
- pulumi_vsphere/vapp_container.py +425 -259
- pulumi_vsphere/vapp_entity.py +324 -174
- pulumi_vsphere/virtual_disk.py +245 -153
- pulumi_vsphere/virtual_machine.py +1696 -1836
- pulumi_vsphere/virtual_machine_class.py +448 -0
- pulumi_vsphere/virtual_machine_snapshot.py +137 -131
- pulumi_vsphere/vm_storage_policy.py +160 -154
- pulumi_vsphere/vmfs_datastore.py +460 -186
- pulumi_vsphere/vnic.py +249 -231
- {pulumi_vsphere-4.10.0a1709017641.dist-info → pulumi_vsphere-4.17.0a1763710194.dist-info}/METADATA +7 -6
- pulumi_vsphere-4.17.0a1763710194.dist-info/RECORD +89 -0
- {pulumi_vsphere-4.10.0a1709017641.dist-info → pulumi_vsphere-4.17.0a1763710194.dist-info}/WHEEL +1 -1
- pulumi_vsphere-4.10.0a1709017641.dist-info/RECORD +0 -80
- {pulumi_vsphere-4.10.0a1709017641.dist-info → pulumi_vsphere-4.17.0a1763710194.dist-info}/top_level.txt +0 -0
pulumi_vsphere/vapp_container.py
CHANGED
|
@@ -1,12 +1,17 @@
|
|
|
1
1
|
# coding=utf-8
|
|
2
|
-
# *** WARNING: this file was generated by
|
|
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
|
|
5
|
+
import builtins as _builtins
|
|
6
6
|
import warnings
|
|
7
|
+
import sys
|
|
7
8
|
import pulumi
|
|
8
9
|
import pulumi.runtime
|
|
9
10
|
from typing import Any, Mapping, Optional, Sequence, Union, overload
|
|
11
|
+
if sys.version_info >= (3, 11):
|
|
12
|
+
from typing import NotRequired, TypedDict, TypeAlias
|
|
13
|
+
else:
|
|
14
|
+
from typing_extensions import NotRequired, TypedDict, TypeAlias
|
|
10
15
|
from . import _utilities
|
|
11
16
|
|
|
12
17
|
__all__ = ['VappContainerArgs', 'VappContainer']
|
|
@@ -14,66 +19,66 @@ __all__ = ['VappContainerArgs', 'VappContainer']
|
|
|
14
19
|
@pulumi.input_type
|
|
15
20
|
class VappContainerArgs:
|
|
16
21
|
def __init__(__self__, *,
|
|
17
|
-
parent_resource_pool_id: pulumi.Input[str],
|
|
18
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
19
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
20
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
21
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
22
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
23
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
24
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
25
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
26
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
27
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
28
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
29
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
30
|
-
parent_folder_id: Optional[pulumi.Input[str]] = None,
|
|
31
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
22
|
+
parent_resource_pool_id: pulumi.Input[_builtins.str],
|
|
23
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
24
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
25
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
26
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
28
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
29
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
30
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
31
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
32
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
33
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
34
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
35
|
+
parent_folder_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
32
37
|
"""
|
|
33
38
|
The set of arguments for constructing a VappContainer resource.
|
|
34
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
39
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
35
40
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
36
41
|
or standalone host, or a resource pool itself. When moving a vApp container
|
|
37
42
|
from one parent resource pool to another, both must share a common root
|
|
38
43
|
resource pool or the move will fail.
|
|
39
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a vApp
|
|
44
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a vApp
|
|
40
45
|
container can grow beyond the specified value if the parent resource pool has
|
|
41
46
|
unreserved resources. Default: `true`
|
|
42
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a vApp container will not
|
|
47
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a vApp container will not
|
|
43
48
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
44
49
|
unlimited.
|
|
45
50
|
Default: `-1`
|
|
46
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
51
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
47
52
|
available to the vApp container. Default: `0`
|
|
48
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
53
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
49
54
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
50
55
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
51
56
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
52
57
|
ignored. Default: `normal`
|
|
53
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
58
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
54
59
|
determine resource allocation in case of resource contention. If this is set,
|
|
55
60
|
`cpu_share_level` must be `custom`.
|
|
56
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
57
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a vApp
|
|
61
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
62
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a vApp
|
|
58
63
|
container can grow beyond the specified value if the parent resource pool has
|
|
59
64
|
unreserved resources. Default: `true`
|
|
60
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a vApp container will not
|
|
65
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a vApp container will not
|
|
61
66
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
62
67
|
unlimited. Default: `-1`
|
|
63
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
68
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
64
69
|
available to the vApp container. Default: `0`
|
|
65
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
70
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
66
71
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
67
72
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
68
73
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
69
74
|
ignored. Default: `normal`
|
|
70
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
75
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
71
76
|
determine resource allocation in case of resource contention. If this is set,
|
|
72
77
|
`memory_share_level` must be `custom`.
|
|
73
|
-
:param pulumi.Input[str] name: The name of the vApp container.
|
|
74
|
-
:param pulumi.Input[str] parent_folder_id: The managed object ID of
|
|
78
|
+
:param pulumi.Input[_builtins.str] name: The name of the vApp container.
|
|
79
|
+
:param pulumi.Input[_builtins.str] parent_folder_id: The managed object ID of
|
|
75
80
|
the vApp container's parent folder.
|
|
76
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
81
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
77
82
|
"""
|
|
78
83
|
pulumi.set(__self__, "parent_resource_pool_id", parent_resource_pool_id)
|
|
79
84
|
if cpu_expandable is not None:
|
|
@@ -105,9 +110,9 @@ class VappContainerArgs:
|
|
|
105
110
|
if tags is not None:
|
|
106
111
|
pulumi.set(__self__, "tags", tags)
|
|
107
112
|
|
|
108
|
-
@property
|
|
113
|
+
@_builtins.property
|
|
109
114
|
@pulumi.getter(name="parentResourcePoolId")
|
|
110
|
-
def parent_resource_pool_id(self) -> pulumi.Input[str]:
|
|
115
|
+
def parent_resource_pool_id(self) -> pulumi.Input[_builtins.str]:
|
|
111
116
|
"""
|
|
112
117
|
The managed object ID
|
|
113
118
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -118,12 +123,12 @@ class VappContainerArgs:
|
|
|
118
123
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
119
124
|
|
|
120
125
|
@parent_resource_pool_id.setter
|
|
121
|
-
def parent_resource_pool_id(self, value: pulumi.Input[str]):
|
|
126
|
+
def parent_resource_pool_id(self, value: pulumi.Input[_builtins.str]):
|
|
122
127
|
pulumi.set(self, "parent_resource_pool_id", value)
|
|
123
128
|
|
|
124
|
-
@property
|
|
129
|
+
@_builtins.property
|
|
125
130
|
@pulumi.getter(name="cpuExpandable")
|
|
126
|
-
def cpu_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
131
|
+
def cpu_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
127
132
|
"""
|
|
128
133
|
Determines if the reservation on a vApp
|
|
129
134
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -132,12 +137,12 @@ class VappContainerArgs:
|
|
|
132
137
|
return pulumi.get(self, "cpu_expandable")
|
|
133
138
|
|
|
134
139
|
@cpu_expandable.setter
|
|
135
|
-
def cpu_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
140
|
+
def cpu_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
136
141
|
pulumi.set(self, "cpu_expandable", value)
|
|
137
142
|
|
|
138
|
-
@property
|
|
143
|
+
@_builtins.property
|
|
139
144
|
@pulumi.getter(name="cpuLimit")
|
|
140
|
-
def cpu_limit(self) -> Optional[pulumi.Input[int]]:
|
|
145
|
+
def cpu_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
141
146
|
"""
|
|
142
147
|
The CPU utilization of a vApp container will not
|
|
143
148
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -147,12 +152,12 @@ class VappContainerArgs:
|
|
|
147
152
|
return pulumi.get(self, "cpu_limit")
|
|
148
153
|
|
|
149
154
|
@cpu_limit.setter
|
|
150
|
-
def cpu_limit(self, value: Optional[pulumi.Input[int]]):
|
|
155
|
+
def cpu_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
151
156
|
pulumi.set(self, "cpu_limit", value)
|
|
152
157
|
|
|
153
|
-
@property
|
|
158
|
+
@_builtins.property
|
|
154
159
|
@pulumi.getter(name="cpuReservation")
|
|
155
|
-
def cpu_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
160
|
+
def cpu_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
156
161
|
"""
|
|
157
162
|
Amount of CPU (MHz) that is guaranteed
|
|
158
163
|
available to the vApp container. Default: `0`
|
|
@@ -160,12 +165,12 @@ class VappContainerArgs:
|
|
|
160
165
|
return pulumi.get(self, "cpu_reservation")
|
|
161
166
|
|
|
162
167
|
@cpu_reservation.setter
|
|
163
|
-
def cpu_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
168
|
+
def cpu_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
164
169
|
pulumi.set(self, "cpu_reservation", value)
|
|
165
170
|
|
|
166
|
-
@property
|
|
171
|
+
@_builtins.property
|
|
167
172
|
@pulumi.getter(name="cpuShareLevel")
|
|
168
|
-
def cpu_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
173
|
+
def cpu_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
169
174
|
"""
|
|
170
175
|
The CPU allocation level. The level is a
|
|
171
176
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -176,12 +181,12 @@ class VappContainerArgs:
|
|
|
176
181
|
return pulumi.get(self, "cpu_share_level")
|
|
177
182
|
|
|
178
183
|
@cpu_share_level.setter
|
|
179
|
-
def cpu_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
184
|
+
def cpu_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
180
185
|
pulumi.set(self, "cpu_share_level", value)
|
|
181
186
|
|
|
182
|
-
@property
|
|
187
|
+
@_builtins.property
|
|
183
188
|
@pulumi.getter(name="cpuShares")
|
|
184
|
-
def cpu_shares(self) -> Optional[pulumi.Input[int]]:
|
|
189
|
+
def cpu_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
185
190
|
"""
|
|
186
191
|
The number of shares allocated for CPU. Used to
|
|
187
192
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -190,24 +195,24 @@ class VappContainerArgs:
|
|
|
190
195
|
return pulumi.get(self, "cpu_shares")
|
|
191
196
|
|
|
192
197
|
@cpu_shares.setter
|
|
193
|
-
def cpu_shares(self, value: Optional[pulumi.Input[int]]):
|
|
198
|
+
def cpu_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
194
199
|
pulumi.set(self, "cpu_shares", value)
|
|
195
200
|
|
|
196
|
-
@property
|
|
201
|
+
@_builtins.property
|
|
197
202
|
@pulumi.getter(name="customAttributes")
|
|
198
|
-
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
203
|
+
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
199
204
|
"""
|
|
200
205
|
A list of custom attributes to set on this resource.
|
|
201
206
|
"""
|
|
202
207
|
return pulumi.get(self, "custom_attributes")
|
|
203
208
|
|
|
204
209
|
@custom_attributes.setter
|
|
205
|
-
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
210
|
+
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
206
211
|
pulumi.set(self, "custom_attributes", value)
|
|
207
212
|
|
|
208
|
-
@property
|
|
213
|
+
@_builtins.property
|
|
209
214
|
@pulumi.getter(name="memoryExpandable")
|
|
210
|
-
def memory_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
215
|
+
def memory_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
211
216
|
"""
|
|
212
217
|
Determines if the reservation on a vApp
|
|
213
218
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -216,12 +221,12 @@ class VappContainerArgs:
|
|
|
216
221
|
return pulumi.get(self, "memory_expandable")
|
|
217
222
|
|
|
218
223
|
@memory_expandable.setter
|
|
219
|
-
def memory_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
224
|
+
def memory_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
220
225
|
pulumi.set(self, "memory_expandable", value)
|
|
221
226
|
|
|
222
|
-
@property
|
|
227
|
+
@_builtins.property
|
|
223
228
|
@pulumi.getter(name="memoryLimit")
|
|
224
|
-
def memory_limit(self) -> Optional[pulumi.Input[int]]:
|
|
229
|
+
def memory_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
225
230
|
"""
|
|
226
231
|
The CPU utilization of a vApp container will not
|
|
227
232
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -230,12 +235,12 @@ class VappContainerArgs:
|
|
|
230
235
|
return pulumi.get(self, "memory_limit")
|
|
231
236
|
|
|
232
237
|
@memory_limit.setter
|
|
233
|
-
def memory_limit(self, value: Optional[pulumi.Input[int]]):
|
|
238
|
+
def memory_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
234
239
|
pulumi.set(self, "memory_limit", value)
|
|
235
240
|
|
|
236
|
-
@property
|
|
241
|
+
@_builtins.property
|
|
237
242
|
@pulumi.getter(name="memoryReservation")
|
|
238
|
-
def memory_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
243
|
+
def memory_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
239
244
|
"""
|
|
240
245
|
Amount of CPU (MHz) that is guaranteed
|
|
241
246
|
available to the vApp container. Default: `0`
|
|
@@ -243,12 +248,12 @@ class VappContainerArgs:
|
|
|
243
248
|
return pulumi.get(self, "memory_reservation")
|
|
244
249
|
|
|
245
250
|
@memory_reservation.setter
|
|
246
|
-
def memory_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
251
|
+
def memory_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
247
252
|
pulumi.set(self, "memory_reservation", value)
|
|
248
253
|
|
|
249
|
-
@property
|
|
254
|
+
@_builtins.property
|
|
250
255
|
@pulumi.getter(name="memoryShareLevel")
|
|
251
|
-
def memory_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
256
|
+
def memory_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
252
257
|
"""
|
|
253
258
|
The CPU allocation level. The level is a
|
|
254
259
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -259,12 +264,12 @@ class VappContainerArgs:
|
|
|
259
264
|
return pulumi.get(self, "memory_share_level")
|
|
260
265
|
|
|
261
266
|
@memory_share_level.setter
|
|
262
|
-
def memory_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
267
|
+
def memory_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
263
268
|
pulumi.set(self, "memory_share_level", value)
|
|
264
269
|
|
|
265
|
-
@property
|
|
270
|
+
@_builtins.property
|
|
266
271
|
@pulumi.getter(name="memoryShares")
|
|
267
|
-
def memory_shares(self) -> Optional[pulumi.Input[int]]:
|
|
272
|
+
def memory_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
268
273
|
"""
|
|
269
274
|
The number of shares allocated for CPU. Used to
|
|
270
275
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -273,24 +278,24 @@ class VappContainerArgs:
|
|
|
273
278
|
return pulumi.get(self, "memory_shares")
|
|
274
279
|
|
|
275
280
|
@memory_shares.setter
|
|
276
|
-
def memory_shares(self, value: Optional[pulumi.Input[int]]):
|
|
281
|
+
def memory_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
277
282
|
pulumi.set(self, "memory_shares", value)
|
|
278
283
|
|
|
279
|
-
@property
|
|
284
|
+
@_builtins.property
|
|
280
285
|
@pulumi.getter
|
|
281
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
286
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
282
287
|
"""
|
|
283
288
|
The name of the vApp container.
|
|
284
289
|
"""
|
|
285
290
|
return pulumi.get(self, "name")
|
|
286
291
|
|
|
287
292
|
@name.setter
|
|
288
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
293
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
289
294
|
pulumi.set(self, "name", value)
|
|
290
295
|
|
|
291
|
-
@property
|
|
296
|
+
@_builtins.property
|
|
292
297
|
@pulumi.getter(name="parentFolderId")
|
|
293
|
-
def parent_folder_id(self) -> Optional[pulumi.Input[str]]:
|
|
298
|
+
def parent_folder_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
294
299
|
"""
|
|
295
300
|
The managed object ID of
|
|
296
301
|
the vApp container's parent folder.
|
|
@@ -298,85 +303,85 @@ class VappContainerArgs:
|
|
|
298
303
|
return pulumi.get(self, "parent_folder_id")
|
|
299
304
|
|
|
300
305
|
@parent_folder_id.setter
|
|
301
|
-
def parent_folder_id(self, value: Optional[pulumi.Input[str]]):
|
|
306
|
+
def parent_folder_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
302
307
|
pulumi.set(self, "parent_folder_id", value)
|
|
303
308
|
|
|
304
|
-
@property
|
|
309
|
+
@_builtins.property
|
|
305
310
|
@pulumi.getter
|
|
306
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
311
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
307
312
|
"""
|
|
308
313
|
The IDs of any tags to attach to this resource.
|
|
309
314
|
"""
|
|
310
315
|
return pulumi.get(self, "tags")
|
|
311
316
|
|
|
312
317
|
@tags.setter
|
|
313
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
318
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
314
319
|
pulumi.set(self, "tags", value)
|
|
315
320
|
|
|
316
321
|
|
|
317
322
|
@pulumi.input_type
|
|
318
323
|
class _VappContainerState:
|
|
319
324
|
def __init__(__self__, *,
|
|
320
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
321
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
322
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
323
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
324
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
325
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
326
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
327
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
328
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
329
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
330
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
331
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
332
|
-
parent_folder_id: Optional[pulumi.Input[str]] = None,
|
|
333
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
334
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
325
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
326
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
327
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
328
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
329
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
330
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
331
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
332
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
333
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
334
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
335
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
336
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
parent_folder_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
338
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
339
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
335
340
|
"""
|
|
336
341
|
Input properties used for looking up and filtering VappContainer resources.
|
|
337
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a vApp
|
|
342
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a vApp
|
|
338
343
|
container can grow beyond the specified value if the parent resource pool has
|
|
339
344
|
unreserved resources. Default: `true`
|
|
340
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a vApp container will not
|
|
345
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a vApp container will not
|
|
341
346
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
342
347
|
unlimited.
|
|
343
348
|
Default: `-1`
|
|
344
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
349
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
345
350
|
available to the vApp container. Default: `0`
|
|
346
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
351
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
347
352
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
348
353
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
349
354
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
350
355
|
ignored. Default: `normal`
|
|
351
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
356
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
352
357
|
determine resource allocation in case of resource contention. If this is set,
|
|
353
358
|
`cpu_share_level` must be `custom`.
|
|
354
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
355
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a vApp
|
|
359
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
360
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a vApp
|
|
356
361
|
container can grow beyond the specified value if the parent resource pool has
|
|
357
362
|
unreserved resources. Default: `true`
|
|
358
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a vApp container will not
|
|
363
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a vApp container will not
|
|
359
364
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
360
365
|
unlimited. Default: `-1`
|
|
361
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
366
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
362
367
|
available to the vApp container. Default: `0`
|
|
363
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
368
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
364
369
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
365
370
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
366
371
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
367
372
|
ignored. Default: `normal`
|
|
368
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
373
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
369
374
|
determine resource allocation in case of resource contention. If this is set,
|
|
370
375
|
`memory_share_level` must be `custom`.
|
|
371
|
-
:param pulumi.Input[str] name: The name of the vApp container.
|
|
372
|
-
:param pulumi.Input[str] parent_folder_id: The managed object ID of
|
|
376
|
+
:param pulumi.Input[_builtins.str] name: The name of the vApp container.
|
|
377
|
+
:param pulumi.Input[_builtins.str] parent_folder_id: The managed object ID of
|
|
373
378
|
the vApp container's parent folder.
|
|
374
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
379
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
375
380
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
376
381
|
or standalone host, or a resource pool itself. When moving a vApp container
|
|
377
382
|
from one parent resource pool to another, both must share a common root
|
|
378
383
|
resource pool or the move will fail.
|
|
379
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
384
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
380
385
|
"""
|
|
381
386
|
if cpu_expandable is not None:
|
|
382
387
|
pulumi.set(__self__, "cpu_expandable", cpu_expandable)
|
|
@@ -409,9 +414,9 @@ class _VappContainerState:
|
|
|
409
414
|
if tags is not None:
|
|
410
415
|
pulumi.set(__self__, "tags", tags)
|
|
411
416
|
|
|
412
|
-
@property
|
|
417
|
+
@_builtins.property
|
|
413
418
|
@pulumi.getter(name="cpuExpandable")
|
|
414
|
-
def cpu_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
419
|
+
def cpu_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
415
420
|
"""
|
|
416
421
|
Determines if the reservation on a vApp
|
|
417
422
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -420,12 +425,12 @@ class _VappContainerState:
|
|
|
420
425
|
return pulumi.get(self, "cpu_expandable")
|
|
421
426
|
|
|
422
427
|
@cpu_expandable.setter
|
|
423
|
-
def cpu_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
428
|
+
def cpu_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
424
429
|
pulumi.set(self, "cpu_expandable", value)
|
|
425
430
|
|
|
426
|
-
@property
|
|
431
|
+
@_builtins.property
|
|
427
432
|
@pulumi.getter(name="cpuLimit")
|
|
428
|
-
def cpu_limit(self) -> Optional[pulumi.Input[int]]:
|
|
433
|
+
def cpu_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
429
434
|
"""
|
|
430
435
|
The CPU utilization of a vApp container will not
|
|
431
436
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -435,12 +440,12 @@ class _VappContainerState:
|
|
|
435
440
|
return pulumi.get(self, "cpu_limit")
|
|
436
441
|
|
|
437
442
|
@cpu_limit.setter
|
|
438
|
-
def cpu_limit(self, value: Optional[pulumi.Input[int]]):
|
|
443
|
+
def cpu_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
439
444
|
pulumi.set(self, "cpu_limit", value)
|
|
440
445
|
|
|
441
|
-
@property
|
|
446
|
+
@_builtins.property
|
|
442
447
|
@pulumi.getter(name="cpuReservation")
|
|
443
|
-
def cpu_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
448
|
+
def cpu_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
444
449
|
"""
|
|
445
450
|
Amount of CPU (MHz) that is guaranteed
|
|
446
451
|
available to the vApp container. Default: `0`
|
|
@@ -448,12 +453,12 @@ class _VappContainerState:
|
|
|
448
453
|
return pulumi.get(self, "cpu_reservation")
|
|
449
454
|
|
|
450
455
|
@cpu_reservation.setter
|
|
451
|
-
def cpu_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
456
|
+
def cpu_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
452
457
|
pulumi.set(self, "cpu_reservation", value)
|
|
453
458
|
|
|
454
|
-
@property
|
|
459
|
+
@_builtins.property
|
|
455
460
|
@pulumi.getter(name="cpuShareLevel")
|
|
456
|
-
def cpu_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
461
|
+
def cpu_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
457
462
|
"""
|
|
458
463
|
The CPU allocation level. The level is a
|
|
459
464
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -464,12 +469,12 @@ class _VappContainerState:
|
|
|
464
469
|
return pulumi.get(self, "cpu_share_level")
|
|
465
470
|
|
|
466
471
|
@cpu_share_level.setter
|
|
467
|
-
def cpu_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
472
|
+
def cpu_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
468
473
|
pulumi.set(self, "cpu_share_level", value)
|
|
469
474
|
|
|
470
|
-
@property
|
|
475
|
+
@_builtins.property
|
|
471
476
|
@pulumi.getter(name="cpuShares")
|
|
472
|
-
def cpu_shares(self) -> Optional[pulumi.Input[int]]:
|
|
477
|
+
def cpu_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
473
478
|
"""
|
|
474
479
|
The number of shares allocated for CPU. Used to
|
|
475
480
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -478,24 +483,24 @@ class _VappContainerState:
|
|
|
478
483
|
return pulumi.get(self, "cpu_shares")
|
|
479
484
|
|
|
480
485
|
@cpu_shares.setter
|
|
481
|
-
def cpu_shares(self, value: Optional[pulumi.Input[int]]):
|
|
486
|
+
def cpu_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
482
487
|
pulumi.set(self, "cpu_shares", value)
|
|
483
488
|
|
|
484
|
-
@property
|
|
489
|
+
@_builtins.property
|
|
485
490
|
@pulumi.getter(name="customAttributes")
|
|
486
|
-
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
491
|
+
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
487
492
|
"""
|
|
488
493
|
A list of custom attributes to set on this resource.
|
|
489
494
|
"""
|
|
490
495
|
return pulumi.get(self, "custom_attributes")
|
|
491
496
|
|
|
492
497
|
@custom_attributes.setter
|
|
493
|
-
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
498
|
+
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
494
499
|
pulumi.set(self, "custom_attributes", value)
|
|
495
500
|
|
|
496
|
-
@property
|
|
501
|
+
@_builtins.property
|
|
497
502
|
@pulumi.getter(name="memoryExpandable")
|
|
498
|
-
def memory_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
503
|
+
def memory_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
499
504
|
"""
|
|
500
505
|
Determines if the reservation on a vApp
|
|
501
506
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -504,12 +509,12 @@ class _VappContainerState:
|
|
|
504
509
|
return pulumi.get(self, "memory_expandable")
|
|
505
510
|
|
|
506
511
|
@memory_expandable.setter
|
|
507
|
-
def memory_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
512
|
+
def memory_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
508
513
|
pulumi.set(self, "memory_expandable", value)
|
|
509
514
|
|
|
510
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
511
516
|
@pulumi.getter(name="memoryLimit")
|
|
512
|
-
def memory_limit(self) -> Optional[pulumi.Input[int]]:
|
|
517
|
+
def memory_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
513
518
|
"""
|
|
514
519
|
The CPU utilization of a vApp container will not
|
|
515
520
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -518,12 +523,12 @@ class _VappContainerState:
|
|
|
518
523
|
return pulumi.get(self, "memory_limit")
|
|
519
524
|
|
|
520
525
|
@memory_limit.setter
|
|
521
|
-
def memory_limit(self, value: Optional[pulumi.Input[int]]):
|
|
526
|
+
def memory_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
522
527
|
pulumi.set(self, "memory_limit", value)
|
|
523
528
|
|
|
524
|
-
@property
|
|
529
|
+
@_builtins.property
|
|
525
530
|
@pulumi.getter(name="memoryReservation")
|
|
526
|
-
def memory_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
531
|
+
def memory_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
527
532
|
"""
|
|
528
533
|
Amount of CPU (MHz) that is guaranteed
|
|
529
534
|
available to the vApp container. Default: `0`
|
|
@@ -531,12 +536,12 @@ class _VappContainerState:
|
|
|
531
536
|
return pulumi.get(self, "memory_reservation")
|
|
532
537
|
|
|
533
538
|
@memory_reservation.setter
|
|
534
|
-
def memory_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
539
|
+
def memory_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
535
540
|
pulumi.set(self, "memory_reservation", value)
|
|
536
541
|
|
|
537
|
-
@property
|
|
542
|
+
@_builtins.property
|
|
538
543
|
@pulumi.getter(name="memoryShareLevel")
|
|
539
|
-
def memory_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
544
|
+
def memory_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
540
545
|
"""
|
|
541
546
|
The CPU allocation level. The level is a
|
|
542
547
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -547,12 +552,12 @@ class _VappContainerState:
|
|
|
547
552
|
return pulumi.get(self, "memory_share_level")
|
|
548
553
|
|
|
549
554
|
@memory_share_level.setter
|
|
550
|
-
def memory_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
555
|
+
def memory_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
551
556
|
pulumi.set(self, "memory_share_level", value)
|
|
552
557
|
|
|
553
|
-
@property
|
|
558
|
+
@_builtins.property
|
|
554
559
|
@pulumi.getter(name="memoryShares")
|
|
555
|
-
def memory_shares(self) -> Optional[pulumi.Input[int]]:
|
|
560
|
+
def memory_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
556
561
|
"""
|
|
557
562
|
The number of shares allocated for CPU. Used to
|
|
558
563
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -561,24 +566,24 @@ class _VappContainerState:
|
|
|
561
566
|
return pulumi.get(self, "memory_shares")
|
|
562
567
|
|
|
563
568
|
@memory_shares.setter
|
|
564
|
-
def memory_shares(self, value: Optional[pulumi.Input[int]]):
|
|
569
|
+
def memory_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
565
570
|
pulumi.set(self, "memory_shares", value)
|
|
566
571
|
|
|
567
|
-
@property
|
|
572
|
+
@_builtins.property
|
|
568
573
|
@pulumi.getter
|
|
569
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
574
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
570
575
|
"""
|
|
571
576
|
The name of the vApp container.
|
|
572
577
|
"""
|
|
573
578
|
return pulumi.get(self, "name")
|
|
574
579
|
|
|
575
580
|
@name.setter
|
|
576
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
581
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
577
582
|
pulumi.set(self, "name", value)
|
|
578
583
|
|
|
579
|
-
@property
|
|
584
|
+
@_builtins.property
|
|
580
585
|
@pulumi.getter(name="parentFolderId")
|
|
581
|
-
def parent_folder_id(self) -> Optional[pulumi.Input[str]]:
|
|
586
|
+
def parent_folder_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
582
587
|
"""
|
|
583
588
|
The managed object ID of
|
|
584
589
|
the vApp container's parent folder.
|
|
@@ -586,12 +591,12 @@ class _VappContainerState:
|
|
|
586
591
|
return pulumi.get(self, "parent_folder_id")
|
|
587
592
|
|
|
588
593
|
@parent_folder_id.setter
|
|
589
|
-
def parent_folder_id(self, value: Optional[pulumi.Input[str]]):
|
|
594
|
+
def parent_folder_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
590
595
|
pulumi.set(self, "parent_folder_id", value)
|
|
591
596
|
|
|
592
|
-
@property
|
|
597
|
+
@_builtins.property
|
|
593
598
|
@pulumi.getter(name="parentResourcePoolId")
|
|
594
|
-
def parent_resource_pool_id(self) -> Optional[pulumi.Input[str]]:
|
|
599
|
+
def parent_resource_pool_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
595
600
|
"""
|
|
596
601
|
The managed object ID
|
|
597
602
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -602,90 +607,171 @@ class _VappContainerState:
|
|
|
602
607
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
603
608
|
|
|
604
609
|
@parent_resource_pool_id.setter
|
|
605
|
-
def parent_resource_pool_id(self, value: Optional[pulumi.Input[str]]):
|
|
610
|
+
def parent_resource_pool_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
606
611
|
pulumi.set(self, "parent_resource_pool_id", value)
|
|
607
612
|
|
|
608
|
-
@property
|
|
613
|
+
@_builtins.property
|
|
609
614
|
@pulumi.getter
|
|
610
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
615
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
611
616
|
"""
|
|
612
617
|
The IDs of any tags to attach to this resource.
|
|
613
618
|
"""
|
|
614
619
|
return pulumi.get(self, "tags")
|
|
615
620
|
|
|
616
621
|
@tags.setter
|
|
617
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
622
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
618
623
|
pulumi.set(self, "tags", value)
|
|
619
624
|
|
|
620
625
|
|
|
626
|
+
@pulumi.type_token("vsphere:index/vappContainer:VappContainer")
|
|
621
627
|
class VappContainer(pulumi.CustomResource):
|
|
622
628
|
@overload
|
|
623
629
|
def __init__(__self__,
|
|
624
630
|
resource_name: str,
|
|
625
631
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
626
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
627
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
628
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
629
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
630
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
631
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
632
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
633
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
634
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
635
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
636
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
637
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
638
|
-
parent_folder_id: Optional[pulumi.Input[str]] = None,
|
|
639
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
640
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
632
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
633
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
634
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
635
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
636
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
637
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
638
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
639
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
640
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
641
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
642
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
643
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
644
|
+
parent_folder_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
645
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
646
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
641
647
|
__props__=None):
|
|
642
648
|
"""
|
|
643
|
-
|
|
649
|
+
The `VappContainer` resource can be used to create and manage
|
|
650
|
+
vApps.
|
|
651
|
+
|
|
652
|
+
For more information on vSphere vApps, see the VMware vSphere [product documentation][ref-vsphere-vapp].
|
|
653
|
+
|
|
654
|
+
[ref-vsphere-vapp]: https://techdocs.broadcom.com/us/en/vmware-cis/vsphere/vsphere/8-0/vsphere-virtual-machine-administration-guide-8-0/managing-multi-tiered-applications-with-vsphere-vapp-in-the-vsphere-web-clientvsphere-vm-admin.html
|
|
655
|
+
|
|
656
|
+
## Basic Example
|
|
657
|
+
|
|
658
|
+
The example below sets up a vSphere vApp container in a compute cluster which uses
|
|
659
|
+
the default settings for CPU and memory reservations, shares, and limits. The compute cluster
|
|
660
|
+
needs to already exist in vSphere.
|
|
661
|
+
|
|
662
|
+
```python
|
|
663
|
+
import pulumi
|
|
664
|
+
import pulumi_vsphere as vsphere
|
|
665
|
+
|
|
666
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
667
|
+
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
668
|
+
datacenter_id=datacenter.id)
|
|
669
|
+
vapp_container = vsphere.VappContainer("vapp_container",
|
|
670
|
+
name="vapp-01",
|
|
671
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
672
|
+
```
|
|
673
|
+
|
|
674
|
+
### Example with a Virtual Machine
|
|
675
|
+
|
|
676
|
+
The example below builds off the basic example, but includes a virtual machine
|
|
677
|
+
in the new vApp container. To accomplish this, the `resource_pool_id` of the
|
|
678
|
+
virtual machine is set to the `id` of the vApp container.
|
|
679
|
+
|
|
680
|
+
```python
|
|
681
|
+
import pulumi
|
|
682
|
+
import pulumi_vsphere as vsphere
|
|
683
|
+
|
|
684
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
685
|
+
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
686
|
+
datacenter_id=datacenter.id)
|
|
687
|
+
datastore = vsphere.get_datastore(name="datastore-01",
|
|
688
|
+
datacenter_id=datacenter.id)
|
|
689
|
+
network = vsphere.get_network(name="VM Network",
|
|
690
|
+
datacenter_id=datacenter.id)
|
|
691
|
+
vapp_container = vsphere.VappContainer("vapp_container",
|
|
692
|
+
name="vapp-01",
|
|
693
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
694
|
+
vm = vsphere.VirtualMachine("vm",
|
|
695
|
+
name="foo",
|
|
696
|
+
resource_pool_id=vapp_container_vsphere_vapp_container["id"],
|
|
697
|
+
datastore_id=datastore.id,
|
|
698
|
+
num_cpus=1,
|
|
699
|
+
memory=1024,
|
|
700
|
+
guest_id="ubuntu64Guest",
|
|
701
|
+
network_interfaces=[{
|
|
702
|
+
"network_id": network.id,
|
|
703
|
+
}],
|
|
704
|
+
disks=[{
|
|
705
|
+
"label": "disk0",
|
|
706
|
+
"size": 20,
|
|
707
|
+
}])
|
|
708
|
+
```
|
|
709
|
+
|
|
710
|
+
## Import
|
|
711
|
+
|
|
712
|
+
An existing vApp container can be imported into this resource via
|
|
713
|
+
|
|
714
|
+
the path to the vApp container, using the following command:
|
|
715
|
+
|
|
716
|
+
[docs-import]: https://developer.hashicorp.com/terraform/cli/import
|
|
717
|
+
|
|
718
|
+
Example:
|
|
719
|
+
|
|
720
|
+
```sh
|
|
721
|
+
$ pulumi import vsphere:index/vappContainer:VappContainer vapp_container /dc-01/host/cluster-01/Resources/resource-pool-01/vapp-01
|
|
722
|
+
```
|
|
723
|
+
|
|
724
|
+
The example above would import the vApp container named `vapp-01` that is
|
|
725
|
+
|
|
726
|
+
located in the resource pool `resource-pool-01` that is part of the host cluster
|
|
727
|
+
|
|
728
|
+
`cluster-01` in the `dc-01` datacenter.
|
|
729
|
+
|
|
644
730
|
:param str resource_name: The name of the resource.
|
|
645
731
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
646
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a vApp
|
|
732
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a vApp
|
|
647
733
|
container can grow beyond the specified value if the parent resource pool has
|
|
648
734
|
unreserved resources. Default: `true`
|
|
649
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a vApp container will not
|
|
735
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a vApp container will not
|
|
650
736
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
651
737
|
unlimited.
|
|
652
738
|
Default: `-1`
|
|
653
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
739
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
654
740
|
available to the vApp container. Default: `0`
|
|
655
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
741
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
656
742
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
657
743
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
658
744
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
659
745
|
ignored. Default: `normal`
|
|
660
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
746
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
661
747
|
determine resource allocation in case of resource contention. If this is set,
|
|
662
748
|
`cpu_share_level` must be `custom`.
|
|
663
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
664
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a vApp
|
|
749
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
750
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a vApp
|
|
665
751
|
container can grow beyond the specified value if the parent resource pool has
|
|
666
752
|
unreserved resources. Default: `true`
|
|
667
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a vApp container will not
|
|
753
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a vApp container will not
|
|
668
754
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
669
755
|
unlimited. Default: `-1`
|
|
670
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
756
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
671
757
|
available to the vApp container. Default: `0`
|
|
672
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
758
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
673
759
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
674
760
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
675
761
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
676
762
|
ignored. Default: `normal`
|
|
677
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
763
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
678
764
|
determine resource allocation in case of resource contention. If this is set,
|
|
679
765
|
`memory_share_level` must be `custom`.
|
|
680
|
-
:param pulumi.Input[str] name: The name of the vApp container.
|
|
681
|
-
:param pulumi.Input[str] parent_folder_id: The managed object ID of
|
|
766
|
+
:param pulumi.Input[_builtins.str] name: The name of the vApp container.
|
|
767
|
+
:param pulumi.Input[_builtins.str] parent_folder_id: The managed object ID of
|
|
682
768
|
the vApp container's parent folder.
|
|
683
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
769
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
684
770
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
685
771
|
or standalone host, or a resource pool itself. When moving a vApp container
|
|
686
772
|
from one parent resource pool to another, both must share a common root
|
|
687
773
|
resource pool or the move will fail.
|
|
688
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
774
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
689
775
|
"""
|
|
690
776
|
...
|
|
691
777
|
@overload
|
|
@@ -694,7 +780,87 @@ class VappContainer(pulumi.CustomResource):
|
|
|
694
780
|
args: VappContainerArgs,
|
|
695
781
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
696
782
|
"""
|
|
697
|
-
|
|
783
|
+
The `VappContainer` resource can be used to create and manage
|
|
784
|
+
vApps.
|
|
785
|
+
|
|
786
|
+
For more information on vSphere vApps, see the VMware vSphere [product documentation][ref-vsphere-vapp].
|
|
787
|
+
|
|
788
|
+
[ref-vsphere-vapp]: https://techdocs.broadcom.com/us/en/vmware-cis/vsphere/vsphere/8-0/vsphere-virtual-machine-administration-guide-8-0/managing-multi-tiered-applications-with-vsphere-vapp-in-the-vsphere-web-clientvsphere-vm-admin.html
|
|
789
|
+
|
|
790
|
+
## Basic Example
|
|
791
|
+
|
|
792
|
+
The example below sets up a vSphere vApp container in a compute cluster which uses
|
|
793
|
+
the default settings for CPU and memory reservations, shares, and limits. The compute cluster
|
|
794
|
+
needs to already exist in vSphere.
|
|
795
|
+
|
|
796
|
+
```python
|
|
797
|
+
import pulumi
|
|
798
|
+
import pulumi_vsphere as vsphere
|
|
799
|
+
|
|
800
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
801
|
+
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
802
|
+
datacenter_id=datacenter.id)
|
|
803
|
+
vapp_container = vsphere.VappContainer("vapp_container",
|
|
804
|
+
name="vapp-01",
|
|
805
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
806
|
+
```
|
|
807
|
+
|
|
808
|
+
### Example with a Virtual Machine
|
|
809
|
+
|
|
810
|
+
The example below builds off the basic example, but includes a virtual machine
|
|
811
|
+
in the new vApp container. To accomplish this, the `resource_pool_id` of the
|
|
812
|
+
virtual machine is set to the `id` of the vApp container.
|
|
813
|
+
|
|
814
|
+
```python
|
|
815
|
+
import pulumi
|
|
816
|
+
import pulumi_vsphere as vsphere
|
|
817
|
+
|
|
818
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
819
|
+
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
820
|
+
datacenter_id=datacenter.id)
|
|
821
|
+
datastore = vsphere.get_datastore(name="datastore-01",
|
|
822
|
+
datacenter_id=datacenter.id)
|
|
823
|
+
network = vsphere.get_network(name="VM Network",
|
|
824
|
+
datacenter_id=datacenter.id)
|
|
825
|
+
vapp_container = vsphere.VappContainer("vapp_container",
|
|
826
|
+
name="vapp-01",
|
|
827
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
828
|
+
vm = vsphere.VirtualMachine("vm",
|
|
829
|
+
name="foo",
|
|
830
|
+
resource_pool_id=vapp_container_vsphere_vapp_container["id"],
|
|
831
|
+
datastore_id=datastore.id,
|
|
832
|
+
num_cpus=1,
|
|
833
|
+
memory=1024,
|
|
834
|
+
guest_id="ubuntu64Guest",
|
|
835
|
+
network_interfaces=[{
|
|
836
|
+
"network_id": network.id,
|
|
837
|
+
}],
|
|
838
|
+
disks=[{
|
|
839
|
+
"label": "disk0",
|
|
840
|
+
"size": 20,
|
|
841
|
+
}])
|
|
842
|
+
```
|
|
843
|
+
|
|
844
|
+
## Import
|
|
845
|
+
|
|
846
|
+
An existing vApp container can be imported into this resource via
|
|
847
|
+
|
|
848
|
+
the path to the vApp container, using the following command:
|
|
849
|
+
|
|
850
|
+
[docs-import]: https://developer.hashicorp.com/terraform/cli/import
|
|
851
|
+
|
|
852
|
+
Example:
|
|
853
|
+
|
|
854
|
+
```sh
|
|
855
|
+
$ pulumi import vsphere:index/vappContainer:VappContainer vapp_container /dc-01/host/cluster-01/Resources/resource-pool-01/vapp-01
|
|
856
|
+
```
|
|
857
|
+
|
|
858
|
+
The example above would import the vApp container named `vapp-01` that is
|
|
859
|
+
|
|
860
|
+
located in the resource pool `resource-pool-01` that is part of the host cluster
|
|
861
|
+
|
|
862
|
+
`cluster-01` in the `dc-01` datacenter.
|
|
863
|
+
|
|
698
864
|
:param str resource_name: The name of the resource.
|
|
699
865
|
:param VappContainerArgs args: The arguments to use to populate this resource's properties.
|
|
700
866
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -710,21 +876,21 @@ class VappContainer(pulumi.CustomResource):
|
|
|
710
876
|
def _internal_init(__self__,
|
|
711
877
|
resource_name: str,
|
|
712
878
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
713
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
714
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
715
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
716
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
717
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
718
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
719
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
720
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
721
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
722
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
723
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
724
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
725
|
-
parent_folder_id: Optional[pulumi.Input[str]] = None,
|
|
726
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
727
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
879
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
880
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
881
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
882
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
883
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
884
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
885
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
886
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
887
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
888
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
889
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
890
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
891
|
+
parent_folder_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
892
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
893
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
728
894
|
__props__=None):
|
|
729
895
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
730
896
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -761,21 +927,21 @@ class VappContainer(pulumi.CustomResource):
|
|
|
761
927
|
def get(resource_name: str,
|
|
762
928
|
id: pulumi.Input[str],
|
|
763
929
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
764
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
765
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
766
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
767
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
768
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
769
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
770
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
771
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
772
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
773
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
774
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
775
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
776
|
-
parent_folder_id: Optional[pulumi.Input[str]] = None,
|
|
777
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
778
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'VappContainer':
|
|
930
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
931
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
932
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
933
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
934
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
935
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
936
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
937
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
938
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
939
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
940
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
941
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
942
|
+
parent_folder_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
943
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
944
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'VappContainer':
|
|
779
945
|
"""
|
|
780
946
|
Get an existing VappContainer resource's state with the given name, id, and optional extra
|
|
781
947
|
properties used to qualify the lookup.
|
|
@@ -783,49 +949,49 @@ class VappContainer(pulumi.CustomResource):
|
|
|
783
949
|
:param str resource_name: The unique name of the resulting resource.
|
|
784
950
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
785
951
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
786
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a vApp
|
|
952
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a vApp
|
|
787
953
|
container can grow beyond the specified value if the parent resource pool has
|
|
788
954
|
unreserved resources. Default: `true`
|
|
789
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a vApp container will not
|
|
955
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a vApp container will not
|
|
790
956
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
791
957
|
unlimited.
|
|
792
958
|
Default: `-1`
|
|
793
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
959
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
794
960
|
available to the vApp container. Default: `0`
|
|
795
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
961
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
796
962
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
797
963
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
798
964
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
799
965
|
ignored. Default: `normal`
|
|
800
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
966
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
801
967
|
determine resource allocation in case of resource contention. If this is set,
|
|
802
968
|
`cpu_share_level` must be `custom`.
|
|
803
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
804
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a vApp
|
|
969
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
970
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a vApp
|
|
805
971
|
container can grow beyond the specified value if the parent resource pool has
|
|
806
972
|
unreserved resources. Default: `true`
|
|
807
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a vApp container will not
|
|
973
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a vApp container will not
|
|
808
974
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
809
975
|
unlimited. Default: `-1`
|
|
810
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
976
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
811
977
|
available to the vApp container. Default: `0`
|
|
812
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
978
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
813
979
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
814
980
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
815
981
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
816
982
|
ignored. Default: `normal`
|
|
817
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
983
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
818
984
|
determine resource allocation in case of resource contention. If this is set,
|
|
819
985
|
`memory_share_level` must be `custom`.
|
|
820
|
-
:param pulumi.Input[str] name: The name of the vApp container.
|
|
821
|
-
:param pulumi.Input[str] parent_folder_id: The managed object ID of
|
|
986
|
+
:param pulumi.Input[_builtins.str] name: The name of the vApp container.
|
|
987
|
+
:param pulumi.Input[_builtins.str] parent_folder_id: The managed object ID of
|
|
822
988
|
the vApp container's parent folder.
|
|
823
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
989
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
824
990
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
825
991
|
or standalone host, or a resource pool itself. When moving a vApp container
|
|
826
992
|
from one parent resource pool to another, both must share a common root
|
|
827
993
|
resource pool or the move will fail.
|
|
828
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
994
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
829
995
|
"""
|
|
830
996
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
831
997
|
|
|
@@ -848,9 +1014,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
848
1014
|
__props__.__dict__["tags"] = tags
|
|
849
1015
|
return VappContainer(resource_name, opts=opts, __props__=__props__)
|
|
850
1016
|
|
|
851
|
-
@property
|
|
1017
|
+
@_builtins.property
|
|
852
1018
|
@pulumi.getter(name="cpuExpandable")
|
|
853
|
-
def cpu_expandable(self) -> pulumi.Output[Optional[bool]]:
|
|
1019
|
+
def cpu_expandable(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
854
1020
|
"""
|
|
855
1021
|
Determines if the reservation on a vApp
|
|
856
1022
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -858,9 +1024,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
858
1024
|
"""
|
|
859
1025
|
return pulumi.get(self, "cpu_expandable")
|
|
860
1026
|
|
|
861
|
-
@property
|
|
1027
|
+
@_builtins.property
|
|
862
1028
|
@pulumi.getter(name="cpuLimit")
|
|
863
|
-
def cpu_limit(self) -> pulumi.Output[Optional[int]]:
|
|
1029
|
+
def cpu_limit(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
864
1030
|
"""
|
|
865
1031
|
The CPU utilization of a vApp container will not
|
|
866
1032
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -869,18 +1035,18 @@ class VappContainer(pulumi.CustomResource):
|
|
|
869
1035
|
"""
|
|
870
1036
|
return pulumi.get(self, "cpu_limit")
|
|
871
1037
|
|
|
872
|
-
@property
|
|
1038
|
+
@_builtins.property
|
|
873
1039
|
@pulumi.getter(name="cpuReservation")
|
|
874
|
-
def cpu_reservation(self) -> pulumi.Output[Optional[int]]:
|
|
1040
|
+
def cpu_reservation(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
875
1041
|
"""
|
|
876
1042
|
Amount of CPU (MHz) that is guaranteed
|
|
877
1043
|
available to the vApp container. Default: `0`
|
|
878
1044
|
"""
|
|
879
1045
|
return pulumi.get(self, "cpu_reservation")
|
|
880
1046
|
|
|
881
|
-
@property
|
|
1047
|
+
@_builtins.property
|
|
882
1048
|
@pulumi.getter(name="cpuShareLevel")
|
|
883
|
-
def cpu_share_level(self) -> pulumi.Output[Optional[str]]:
|
|
1049
|
+
def cpu_share_level(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
884
1050
|
"""
|
|
885
1051
|
The CPU allocation level. The level is a
|
|
886
1052
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -890,9 +1056,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
890
1056
|
"""
|
|
891
1057
|
return pulumi.get(self, "cpu_share_level")
|
|
892
1058
|
|
|
893
|
-
@property
|
|
1059
|
+
@_builtins.property
|
|
894
1060
|
@pulumi.getter(name="cpuShares")
|
|
895
|
-
def cpu_shares(self) -> pulumi.Output[int]:
|
|
1061
|
+
def cpu_shares(self) -> pulumi.Output[_builtins.int]:
|
|
896
1062
|
"""
|
|
897
1063
|
The number of shares allocated for CPU. Used to
|
|
898
1064
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -900,17 +1066,17 @@ class VappContainer(pulumi.CustomResource):
|
|
|
900
1066
|
"""
|
|
901
1067
|
return pulumi.get(self, "cpu_shares")
|
|
902
1068
|
|
|
903
|
-
@property
|
|
1069
|
+
@_builtins.property
|
|
904
1070
|
@pulumi.getter(name="customAttributes")
|
|
905
|
-
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
1071
|
+
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
906
1072
|
"""
|
|
907
1073
|
A list of custom attributes to set on this resource.
|
|
908
1074
|
"""
|
|
909
1075
|
return pulumi.get(self, "custom_attributes")
|
|
910
1076
|
|
|
911
|
-
@property
|
|
1077
|
+
@_builtins.property
|
|
912
1078
|
@pulumi.getter(name="memoryExpandable")
|
|
913
|
-
def memory_expandable(self) -> pulumi.Output[Optional[bool]]:
|
|
1079
|
+
def memory_expandable(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
914
1080
|
"""
|
|
915
1081
|
Determines if the reservation on a vApp
|
|
916
1082
|
container can grow beyond the specified value if the parent resource pool has
|
|
@@ -918,9 +1084,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
918
1084
|
"""
|
|
919
1085
|
return pulumi.get(self, "memory_expandable")
|
|
920
1086
|
|
|
921
|
-
@property
|
|
1087
|
+
@_builtins.property
|
|
922
1088
|
@pulumi.getter(name="memoryLimit")
|
|
923
|
-
def memory_limit(self) -> pulumi.Output[Optional[int]]:
|
|
1089
|
+
def memory_limit(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
924
1090
|
"""
|
|
925
1091
|
The CPU utilization of a vApp container will not
|
|
926
1092
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -928,18 +1094,18 @@ class VappContainer(pulumi.CustomResource):
|
|
|
928
1094
|
"""
|
|
929
1095
|
return pulumi.get(self, "memory_limit")
|
|
930
1096
|
|
|
931
|
-
@property
|
|
1097
|
+
@_builtins.property
|
|
932
1098
|
@pulumi.getter(name="memoryReservation")
|
|
933
|
-
def memory_reservation(self) -> pulumi.Output[Optional[int]]:
|
|
1099
|
+
def memory_reservation(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
934
1100
|
"""
|
|
935
1101
|
Amount of CPU (MHz) that is guaranteed
|
|
936
1102
|
available to the vApp container. Default: `0`
|
|
937
1103
|
"""
|
|
938
1104
|
return pulumi.get(self, "memory_reservation")
|
|
939
1105
|
|
|
940
|
-
@property
|
|
1106
|
+
@_builtins.property
|
|
941
1107
|
@pulumi.getter(name="memoryShareLevel")
|
|
942
|
-
def memory_share_level(self) -> pulumi.Output[Optional[str]]:
|
|
1108
|
+
def memory_share_level(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
943
1109
|
"""
|
|
944
1110
|
The CPU allocation level. The level is a
|
|
945
1111
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -949,9 +1115,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
949
1115
|
"""
|
|
950
1116
|
return pulumi.get(self, "memory_share_level")
|
|
951
1117
|
|
|
952
|
-
@property
|
|
1118
|
+
@_builtins.property
|
|
953
1119
|
@pulumi.getter(name="memoryShares")
|
|
954
|
-
def memory_shares(self) -> pulumi.Output[int]:
|
|
1120
|
+
def memory_shares(self) -> pulumi.Output[_builtins.int]:
|
|
955
1121
|
"""
|
|
956
1122
|
The number of shares allocated for CPU. Used to
|
|
957
1123
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -959,26 +1125,26 @@ class VappContainer(pulumi.CustomResource):
|
|
|
959
1125
|
"""
|
|
960
1126
|
return pulumi.get(self, "memory_shares")
|
|
961
1127
|
|
|
962
|
-
@property
|
|
1128
|
+
@_builtins.property
|
|
963
1129
|
@pulumi.getter
|
|
964
|
-
def name(self) -> pulumi.Output[str]:
|
|
1130
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
965
1131
|
"""
|
|
966
1132
|
The name of the vApp container.
|
|
967
1133
|
"""
|
|
968
1134
|
return pulumi.get(self, "name")
|
|
969
1135
|
|
|
970
|
-
@property
|
|
1136
|
+
@_builtins.property
|
|
971
1137
|
@pulumi.getter(name="parentFolderId")
|
|
972
|
-
def parent_folder_id(self) -> pulumi.Output[Optional[str]]:
|
|
1138
|
+
def parent_folder_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
973
1139
|
"""
|
|
974
1140
|
The managed object ID of
|
|
975
1141
|
the vApp container's parent folder.
|
|
976
1142
|
"""
|
|
977
1143
|
return pulumi.get(self, "parent_folder_id")
|
|
978
1144
|
|
|
979
|
-
@property
|
|
1145
|
+
@_builtins.property
|
|
980
1146
|
@pulumi.getter(name="parentResourcePoolId")
|
|
981
|
-
def parent_resource_pool_id(self) -> pulumi.Output[str]:
|
|
1147
|
+
def parent_resource_pool_id(self) -> pulumi.Output[_builtins.str]:
|
|
982
1148
|
"""
|
|
983
1149
|
The managed object ID
|
|
984
1150
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -988,9 +1154,9 @@ class VappContainer(pulumi.CustomResource):
|
|
|
988
1154
|
"""
|
|
989
1155
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
990
1156
|
|
|
991
|
-
@property
|
|
1157
|
+
@_builtins.property
|
|
992
1158
|
@pulumi.getter
|
|
993
|
-
def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1159
|
+
def tags(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
994
1160
|
"""
|
|
995
1161
|
The IDs of any tags to attach to this resource.
|
|
996
1162
|
"""
|