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/resource_pool.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__ = ['ResourcePoolArgs', 'ResourcePool']
|
|
@@ -14,67 +19,67 @@ __all__ = ['ResourcePoolArgs', 'ResourcePool']
|
|
|
14
19
|
@pulumi.input_type
|
|
15
20
|
class ResourcePoolArgs:
|
|
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
|
-
scale_descendants_shares: 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
|
+
scale_descendants_shares: 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 ResourcePool 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 resource pool
|
|
37
42
|
from one parent resource pool to another, both must share a common root
|
|
38
43
|
resource pool.
|
|
39
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a resource
|
|
44
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a resource
|
|
40
45
|
pool 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 resource pool will not
|
|
47
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a resource pool will not
|
|
43
48
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
44
49
|
unlimited. Default: `-1`
|
|
45
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
50
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
46
51
|
available to the resource pool. Default: `0`
|
|
47
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
52
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
48
53
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
49
54
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
50
55
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
51
56
|
ignored. Default: `normal`
|
|
52
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
57
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
53
58
|
determine resource allocation in case of resource contention. If this is set,
|
|
54
59
|
`cpu_share_level` must be `custom`.
|
|
55
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
56
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a resource
|
|
60
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
61
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a resource
|
|
57
62
|
pool can grow beyond the specified value if the parent resource pool has
|
|
58
63
|
unreserved resources. Default: `true`
|
|
59
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a resource pool will not
|
|
64
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a resource pool will not
|
|
60
65
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
61
66
|
unlimited. Default: `-1`
|
|
62
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
67
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
63
68
|
available to the resource pool. Default: `0`
|
|
64
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
69
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
65
70
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
66
71
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
67
72
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
68
73
|
ignored. Default: `normal`
|
|
69
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
74
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
70
75
|
determine resource allocation in case of resource contention. If this is set,
|
|
71
76
|
`memory_share_level` must be `custom`.
|
|
72
|
-
:param pulumi.Input[str] name: The name of the resource pool.
|
|
73
|
-
:param pulumi.Input[str] scale_descendants_shares: Determines if the shares of all
|
|
77
|
+
:param pulumi.Input[_builtins.str] name: The name of the resource pool.
|
|
78
|
+
:param pulumi.Input[_builtins.str] scale_descendants_shares: Determines if the shares of all
|
|
74
79
|
descendants of the resource pool are scaled up or down when the shares
|
|
75
80
|
of the resource pool are scaled up or down. Can be one of `disabled` or
|
|
76
81
|
`scaleCpuAndMemoryShares`. Default: `disabled`.
|
|
77
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
82
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
78
83
|
"""
|
|
79
84
|
pulumi.set(__self__, "parent_resource_pool_id", parent_resource_pool_id)
|
|
80
85
|
if cpu_expandable is not None:
|
|
@@ -106,9 +111,9 @@ class ResourcePoolArgs:
|
|
|
106
111
|
if tags is not None:
|
|
107
112
|
pulumi.set(__self__, "tags", tags)
|
|
108
113
|
|
|
109
|
-
@property
|
|
114
|
+
@_builtins.property
|
|
110
115
|
@pulumi.getter(name="parentResourcePoolId")
|
|
111
|
-
def parent_resource_pool_id(self) -> pulumi.Input[str]:
|
|
116
|
+
def parent_resource_pool_id(self) -> pulumi.Input[_builtins.str]:
|
|
112
117
|
"""
|
|
113
118
|
The managed object ID
|
|
114
119
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -119,12 +124,12 @@ class ResourcePoolArgs:
|
|
|
119
124
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
120
125
|
|
|
121
126
|
@parent_resource_pool_id.setter
|
|
122
|
-
def parent_resource_pool_id(self, value: pulumi.Input[str]):
|
|
127
|
+
def parent_resource_pool_id(self, value: pulumi.Input[_builtins.str]):
|
|
123
128
|
pulumi.set(self, "parent_resource_pool_id", value)
|
|
124
129
|
|
|
125
|
-
@property
|
|
130
|
+
@_builtins.property
|
|
126
131
|
@pulumi.getter(name="cpuExpandable")
|
|
127
|
-
def cpu_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
132
|
+
def cpu_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
128
133
|
"""
|
|
129
134
|
Determines if the reservation on a resource
|
|
130
135
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -133,12 +138,12 @@ class ResourcePoolArgs:
|
|
|
133
138
|
return pulumi.get(self, "cpu_expandable")
|
|
134
139
|
|
|
135
140
|
@cpu_expandable.setter
|
|
136
|
-
def cpu_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
141
|
+
def cpu_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
137
142
|
pulumi.set(self, "cpu_expandable", value)
|
|
138
143
|
|
|
139
|
-
@property
|
|
144
|
+
@_builtins.property
|
|
140
145
|
@pulumi.getter(name="cpuLimit")
|
|
141
|
-
def cpu_limit(self) -> Optional[pulumi.Input[int]]:
|
|
146
|
+
def cpu_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
142
147
|
"""
|
|
143
148
|
The CPU utilization of a resource pool will not
|
|
144
149
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -147,12 +152,12 @@ class ResourcePoolArgs:
|
|
|
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 resource pool. Default: `0`
|
|
@@ -160,12 +165,12 @@ class ResourcePoolArgs:
|
|
|
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 ResourcePoolArgs:
|
|
|
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 ResourcePoolArgs:
|
|
|
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 resource
|
|
213
218
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -216,12 +221,12 @@ class ResourcePoolArgs:
|
|
|
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 resource pool will not
|
|
227
232
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -230,12 +235,12 @@ class ResourcePoolArgs:
|
|
|
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 resource pool. Default: `0`
|
|
@@ -243,12 +248,12 @@ class ResourcePoolArgs:
|
|
|
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 ResourcePoolArgs:
|
|
|
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 ResourcePoolArgs:
|
|
|
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 resource pool.
|
|
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="scaleDescendantsShares")
|
|
293
|
-
def scale_descendants_shares(self) -> Optional[pulumi.Input[str]]:
|
|
298
|
+
def scale_descendants_shares(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
294
299
|
"""
|
|
295
300
|
Determines if the shares of all
|
|
296
301
|
descendants of the resource pool are scaled up or down when the shares
|
|
@@ -300,86 +305,86 @@ class ResourcePoolArgs:
|
|
|
300
305
|
return pulumi.get(self, "scale_descendants_shares")
|
|
301
306
|
|
|
302
307
|
@scale_descendants_shares.setter
|
|
303
|
-
def scale_descendants_shares(self, value: Optional[pulumi.Input[str]]):
|
|
308
|
+
def scale_descendants_shares(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
304
309
|
pulumi.set(self, "scale_descendants_shares", value)
|
|
305
310
|
|
|
306
|
-
@property
|
|
311
|
+
@_builtins.property
|
|
307
312
|
@pulumi.getter
|
|
308
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
313
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
309
314
|
"""
|
|
310
315
|
The IDs of any tags to attach to this resource.
|
|
311
316
|
"""
|
|
312
317
|
return pulumi.get(self, "tags")
|
|
313
318
|
|
|
314
319
|
@tags.setter
|
|
315
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
320
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
316
321
|
pulumi.set(self, "tags", value)
|
|
317
322
|
|
|
318
323
|
|
|
319
324
|
@pulumi.input_type
|
|
320
325
|
class _ResourcePoolState:
|
|
321
326
|
def __init__(__self__, *,
|
|
322
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
323
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
324
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
325
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
326
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
327
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
328
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
329
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
330
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
331
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
332
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
333
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
334
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
335
|
-
scale_descendants_shares: Optional[pulumi.Input[str]] = None,
|
|
336
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
327
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
328
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
329
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
330
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
331
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
332
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
333
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
334
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
335
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
336
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
337
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
338
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
339
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
340
|
+
scale_descendants_shares: Optional[pulumi.Input[_builtins.str]] = None,
|
|
341
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
337
342
|
"""
|
|
338
343
|
Input properties used for looking up and filtering ResourcePool resources.
|
|
339
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a resource
|
|
344
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a resource
|
|
340
345
|
pool can grow beyond the specified value if the parent resource pool has
|
|
341
346
|
unreserved resources. Default: `true`
|
|
342
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a resource pool will not
|
|
347
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a resource pool will not
|
|
343
348
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
344
349
|
unlimited. Default: `-1`
|
|
345
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
350
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
346
351
|
available to the resource pool. Default: `0`
|
|
347
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
352
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
348
353
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
349
354
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
350
355
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
351
356
|
ignored. Default: `normal`
|
|
352
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
357
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
353
358
|
determine resource allocation in case of resource contention. If this is set,
|
|
354
359
|
`cpu_share_level` must be `custom`.
|
|
355
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
356
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a resource
|
|
360
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
361
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a resource
|
|
357
362
|
pool can grow beyond the specified value if the parent resource pool has
|
|
358
363
|
unreserved resources. Default: `true`
|
|
359
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a resource pool will not
|
|
364
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a resource pool will not
|
|
360
365
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
361
366
|
unlimited. Default: `-1`
|
|
362
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
367
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
363
368
|
available to the resource pool. Default: `0`
|
|
364
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
369
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
365
370
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
366
371
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
367
372
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
368
373
|
ignored. Default: `normal`
|
|
369
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
374
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
370
375
|
determine resource allocation in case of resource contention. If this is set,
|
|
371
376
|
`memory_share_level` must be `custom`.
|
|
372
|
-
:param pulumi.Input[str] name: The name of the resource pool.
|
|
373
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
377
|
+
:param pulumi.Input[_builtins.str] name: The name of the resource pool.
|
|
378
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
374
379
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
375
380
|
or standalone host, or a resource pool itself. When moving a resource pool
|
|
376
381
|
from one parent resource pool to another, both must share a common root
|
|
377
382
|
resource pool.
|
|
378
|
-
:param pulumi.Input[str] scale_descendants_shares: Determines if the shares of all
|
|
383
|
+
:param pulumi.Input[_builtins.str] scale_descendants_shares: Determines if the shares of all
|
|
379
384
|
descendants of the resource pool are scaled up or down when the shares
|
|
380
385
|
of the resource pool are scaled up or down. Can be one of `disabled` or
|
|
381
386
|
`scaleCpuAndMemoryShares`. Default: `disabled`.
|
|
382
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
387
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
383
388
|
"""
|
|
384
389
|
if cpu_expandable is not None:
|
|
385
390
|
pulumi.set(__self__, "cpu_expandable", cpu_expandable)
|
|
@@ -412,9 +417,9 @@ class _ResourcePoolState:
|
|
|
412
417
|
if tags is not None:
|
|
413
418
|
pulumi.set(__self__, "tags", tags)
|
|
414
419
|
|
|
415
|
-
@property
|
|
420
|
+
@_builtins.property
|
|
416
421
|
@pulumi.getter(name="cpuExpandable")
|
|
417
|
-
def cpu_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
422
|
+
def cpu_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
418
423
|
"""
|
|
419
424
|
Determines if the reservation on a resource
|
|
420
425
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -423,12 +428,12 @@ class _ResourcePoolState:
|
|
|
423
428
|
return pulumi.get(self, "cpu_expandable")
|
|
424
429
|
|
|
425
430
|
@cpu_expandable.setter
|
|
426
|
-
def cpu_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
431
|
+
def cpu_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
427
432
|
pulumi.set(self, "cpu_expandable", value)
|
|
428
433
|
|
|
429
|
-
@property
|
|
434
|
+
@_builtins.property
|
|
430
435
|
@pulumi.getter(name="cpuLimit")
|
|
431
|
-
def cpu_limit(self) -> Optional[pulumi.Input[int]]:
|
|
436
|
+
def cpu_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
432
437
|
"""
|
|
433
438
|
The CPU utilization of a resource pool will not
|
|
434
439
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -437,12 +442,12 @@ class _ResourcePoolState:
|
|
|
437
442
|
return pulumi.get(self, "cpu_limit")
|
|
438
443
|
|
|
439
444
|
@cpu_limit.setter
|
|
440
|
-
def cpu_limit(self, value: Optional[pulumi.Input[int]]):
|
|
445
|
+
def cpu_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
441
446
|
pulumi.set(self, "cpu_limit", value)
|
|
442
447
|
|
|
443
|
-
@property
|
|
448
|
+
@_builtins.property
|
|
444
449
|
@pulumi.getter(name="cpuReservation")
|
|
445
|
-
def cpu_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
450
|
+
def cpu_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
446
451
|
"""
|
|
447
452
|
Amount of CPU (MHz) that is guaranteed
|
|
448
453
|
available to the resource pool. Default: `0`
|
|
@@ -450,12 +455,12 @@ class _ResourcePoolState:
|
|
|
450
455
|
return pulumi.get(self, "cpu_reservation")
|
|
451
456
|
|
|
452
457
|
@cpu_reservation.setter
|
|
453
|
-
def cpu_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
458
|
+
def cpu_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
454
459
|
pulumi.set(self, "cpu_reservation", value)
|
|
455
460
|
|
|
456
|
-
@property
|
|
461
|
+
@_builtins.property
|
|
457
462
|
@pulumi.getter(name="cpuShareLevel")
|
|
458
|
-
def cpu_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
463
|
+
def cpu_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
459
464
|
"""
|
|
460
465
|
The CPU allocation level. The level is a
|
|
461
466
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -466,12 +471,12 @@ class _ResourcePoolState:
|
|
|
466
471
|
return pulumi.get(self, "cpu_share_level")
|
|
467
472
|
|
|
468
473
|
@cpu_share_level.setter
|
|
469
|
-
def cpu_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
474
|
+
def cpu_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
470
475
|
pulumi.set(self, "cpu_share_level", value)
|
|
471
476
|
|
|
472
|
-
@property
|
|
477
|
+
@_builtins.property
|
|
473
478
|
@pulumi.getter(name="cpuShares")
|
|
474
|
-
def cpu_shares(self) -> Optional[pulumi.Input[int]]:
|
|
479
|
+
def cpu_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
475
480
|
"""
|
|
476
481
|
The number of shares allocated for CPU. Used to
|
|
477
482
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -480,24 +485,24 @@ class _ResourcePoolState:
|
|
|
480
485
|
return pulumi.get(self, "cpu_shares")
|
|
481
486
|
|
|
482
487
|
@cpu_shares.setter
|
|
483
|
-
def cpu_shares(self, value: Optional[pulumi.Input[int]]):
|
|
488
|
+
def cpu_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
484
489
|
pulumi.set(self, "cpu_shares", value)
|
|
485
490
|
|
|
486
|
-
@property
|
|
491
|
+
@_builtins.property
|
|
487
492
|
@pulumi.getter(name="customAttributes")
|
|
488
|
-
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
493
|
+
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
489
494
|
"""
|
|
490
495
|
A list of custom attributes to set on this resource.
|
|
491
496
|
"""
|
|
492
497
|
return pulumi.get(self, "custom_attributes")
|
|
493
498
|
|
|
494
499
|
@custom_attributes.setter
|
|
495
|
-
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
500
|
+
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
496
501
|
pulumi.set(self, "custom_attributes", value)
|
|
497
502
|
|
|
498
|
-
@property
|
|
503
|
+
@_builtins.property
|
|
499
504
|
@pulumi.getter(name="memoryExpandable")
|
|
500
|
-
def memory_expandable(self) -> Optional[pulumi.Input[bool]]:
|
|
505
|
+
def memory_expandable(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
501
506
|
"""
|
|
502
507
|
Determines if the reservation on a resource
|
|
503
508
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -506,12 +511,12 @@ class _ResourcePoolState:
|
|
|
506
511
|
return pulumi.get(self, "memory_expandable")
|
|
507
512
|
|
|
508
513
|
@memory_expandable.setter
|
|
509
|
-
def memory_expandable(self, value: Optional[pulumi.Input[bool]]):
|
|
514
|
+
def memory_expandable(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
510
515
|
pulumi.set(self, "memory_expandable", value)
|
|
511
516
|
|
|
512
|
-
@property
|
|
517
|
+
@_builtins.property
|
|
513
518
|
@pulumi.getter(name="memoryLimit")
|
|
514
|
-
def memory_limit(self) -> Optional[pulumi.Input[int]]:
|
|
519
|
+
def memory_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
515
520
|
"""
|
|
516
521
|
The CPU utilization of a resource pool will not
|
|
517
522
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -520,12 +525,12 @@ class _ResourcePoolState:
|
|
|
520
525
|
return pulumi.get(self, "memory_limit")
|
|
521
526
|
|
|
522
527
|
@memory_limit.setter
|
|
523
|
-
def memory_limit(self, value: Optional[pulumi.Input[int]]):
|
|
528
|
+
def memory_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
524
529
|
pulumi.set(self, "memory_limit", value)
|
|
525
530
|
|
|
526
|
-
@property
|
|
531
|
+
@_builtins.property
|
|
527
532
|
@pulumi.getter(name="memoryReservation")
|
|
528
|
-
def memory_reservation(self) -> Optional[pulumi.Input[int]]:
|
|
533
|
+
def memory_reservation(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
529
534
|
"""
|
|
530
535
|
Amount of CPU (MHz) that is guaranteed
|
|
531
536
|
available to the resource pool. Default: `0`
|
|
@@ -533,12 +538,12 @@ class _ResourcePoolState:
|
|
|
533
538
|
return pulumi.get(self, "memory_reservation")
|
|
534
539
|
|
|
535
540
|
@memory_reservation.setter
|
|
536
|
-
def memory_reservation(self, value: Optional[pulumi.Input[int]]):
|
|
541
|
+
def memory_reservation(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
537
542
|
pulumi.set(self, "memory_reservation", value)
|
|
538
543
|
|
|
539
|
-
@property
|
|
544
|
+
@_builtins.property
|
|
540
545
|
@pulumi.getter(name="memoryShareLevel")
|
|
541
|
-
def memory_share_level(self) -> Optional[pulumi.Input[str]]:
|
|
546
|
+
def memory_share_level(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
542
547
|
"""
|
|
543
548
|
The CPU allocation level. The level is a
|
|
544
549
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -549,12 +554,12 @@ class _ResourcePoolState:
|
|
|
549
554
|
return pulumi.get(self, "memory_share_level")
|
|
550
555
|
|
|
551
556
|
@memory_share_level.setter
|
|
552
|
-
def memory_share_level(self, value: Optional[pulumi.Input[str]]):
|
|
557
|
+
def memory_share_level(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
553
558
|
pulumi.set(self, "memory_share_level", value)
|
|
554
559
|
|
|
555
|
-
@property
|
|
560
|
+
@_builtins.property
|
|
556
561
|
@pulumi.getter(name="memoryShares")
|
|
557
|
-
def memory_shares(self) -> Optional[pulumi.Input[int]]:
|
|
562
|
+
def memory_shares(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
558
563
|
"""
|
|
559
564
|
The number of shares allocated for CPU. Used to
|
|
560
565
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -563,24 +568,24 @@ class _ResourcePoolState:
|
|
|
563
568
|
return pulumi.get(self, "memory_shares")
|
|
564
569
|
|
|
565
570
|
@memory_shares.setter
|
|
566
|
-
def memory_shares(self, value: Optional[pulumi.Input[int]]):
|
|
571
|
+
def memory_shares(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
567
572
|
pulumi.set(self, "memory_shares", value)
|
|
568
573
|
|
|
569
|
-
@property
|
|
574
|
+
@_builtins.property
|
|
570
575
|
@pulumi.getter
|
|
571
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
576
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
572
577
|
"""
|
|
573
578
|
The name of the resource pool.
|
|
574
579
|
"""
|
|
575
580
|
return pulumi.get(self, "name")
|
|
576
581
|
|
|
577
582
|
@name.setter
|
|
578
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
583
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
579
584
|
pulumi.set(self, "name", value)
|
|
580
585
|
|
|
581
|
-
@property
|
|
586
|
+
@_builtins.property
|
|
582
587
|
@pulumi.getter(name="parentResourcePoolId")
|
|
583
|
-
def parent_resource_pool_id(self) -> Optional[pulumi.Input[str]]:
|
|
588
|
+
def parent_resource_pool_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
584
589
|
"""
|
|
585
590
|
The managed object ID
|
|
586
591
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -591,12 +596,12 @@ class _ResourcePoolState:
|
|
|
591
596
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
592
597
|
|
|
593
598
|
@parent_resource_pool_id.setter
|
|
594
|
-
def parent_resource_pool_id(self, value: Optional[pulumi.Input[str]]):
|
|
599
|
+
def parent_resource_pool_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
595
600
|
pulumi.set(self, "parent_resource_pool_id", value)
|
|
596
601
|
|
|
597
|
-
@property
|
|
602
|
+
@_builtins.property
|
|
598
603
|
@pulumi.getter(name="scaleDescendantsShares")
|
|
599
|
-
def scale_descendants_shares(self) -> Optional[pulumi.Input[str]]:
|
|
604
|
+
def scale_descendants_shares(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
600
605
|
"""
|
|
601
606
|
Determines if the shares of all
|
|
602
607
|
descendants of the resource pool are scaled up or down when the shares
|
|
@@ -606,42 +611,43 @@ class _ResourcePoolState:
|
|
|
606
611
|
return pulumi.get(self, "scale_descendants_shares")
|
|
607
612
|
|
|
608
613
|
@scale_descendants_shares.setter
|
|
609
|
-
def scale_descendants_shares(self, value: Optional[pulumi.Input[str]]):
|
|
614
|
+
def scale_descendants_shares(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
610
615
|
pulumi.set(self, "scale_descendants_shares", value)
|
|
611
616
|
|
|
612
|
-
@property
|
|
617
|
+
@_builtins.property
|
|
613
618
|
@pulumi.getter
|
|
614
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
619
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
615
620
|
"""
|
|
616
621
|
The IDs of any tags to attach to this resource.
|
|
617
622
|
"""
|
|
618
623
|
return pulumi.get(self, "tags")
|
|
619
624
|
|
|
620
625
|
@tags.setter
|
|
621
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
626
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
622
627
|
pulumi.set(self, "tags", value)
|
|
623
628
|
|
|
624
629
|
|
|
630
|
+
@pulumi.type_token("vsphere:index/resourcePool:ResourcePool")
|
|
625
631
|
class ResourcePool(pulumi.CustomResource):
|
|
626
632
|
@overload
|
|
627
633
|
def __init__(__self__,
|
|
628
634
|
resource_name: str,
|
|
629
635
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
630
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
631
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
632
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
633
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
634
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
635
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
636
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
637
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
638
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
639
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
640
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
641
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
642
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
643
|
-
scale_descendants_shares: Optional[pulumi.Input[str]] = None,
|
|
644
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
636
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
637
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
638
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
639
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
640
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
641
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
642
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
643
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
644
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
645
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
646
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
647
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
648
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
649
|
+
scale_descendants_shares: Optional[pulumi.Input[_builtins.str]] = None,
|
|
650
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
645
651
|
__props__=None):
|
|
646
652
|
"""
|
|
647
653
|
The `ResourcePool` resource can be used to create and manage
|
|
@@ -650,7 +656,7 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
650
656
|
For more information on vSphere resource pools, please refer to the
|
|
651
657
|
[product documentation][ref-vsphere-resource_pools].
|
|
652
658
|
|
|
653
|
-
[ref-vsphere-resource_pools]: https://
|
|
659
|
+
[ref-vsphere-resource_pools]: https://techdocs.broadcom.com/us/en/vmware-cis/vsphere/vsphere/8-0/vsphere-resource-management-8-0/managing-resource-pools.html
|
|
654
660
|
|
|
655
661
|
## Example Usage
|
|
656
662
|
|
|
@@ -664,7 +670,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
664
670
|
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
665
671
|
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
666
672
|
datacenter_id=datacenter.id)
|
|
667
|
-
resource_pool = vsphere.ResourcePool("
|
|
673
|
+
resource_pool = vsphere.ResourcePool("resource_pool",
|
|
674
|
+
name="resource-pool-01",
|
|
675
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
668
676
|
```
|
|
669
677
|
|
|
670
678
|
A virtual machine resource could be targeted to use the default resource pool
|
|
@@ -674,8 +682,7 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
674
682
|
import pulumi
|
|
675
683
|
import pulumi_vsphere as vsphere
|
|
676
684
|
|
|
677
|
-
vm = vsphere.VirtualMachine("vm", resource_pool_id=
|
|
678
|
-
# ... other configuration ...
|
|
685
|
+
vm = vsphere.VirtualMachine("vm", resource_pool_id=cluster["resourcePoolId"])
|
|
679
686
|
```
|
|
680
687
|
|
|
681
688
|
The following example sets up a parent resource pool in an existing compute cluster
|
|
@@ -689,62 +696,100 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
689
696
|
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
690
697
|
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
691
698
|
datacenter_id=datacenter.id)
|
|
692
|
-
resource_pool_parent = vsphere.ResourcePool("
|
|
693
|
-
|
|
699
|
+
resource_pool_parent = vsphere.ResourcePool("resource_pool_parent",
|
|
700
|
+
name="parent",
|
|
701
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
702
|
+
resource_pool_child = vsphere.ResourcePool("resource_pool_child",
|
|
703
|
+
name="child",
|
|
704
|
+
parent_resource_pool_id=resource_pool_parent.id)
|
|
694
705
|
```
|
|
695
|
-
|
|
706
|
+
|
|
707
|
+
The following example set up a parent resource pool on a standalone ESXi host with the default
|
|
708
|
+
settings for CPU and memory reservations, shares, and limits.
|
|
709
|
+
|
|
710
|
+
```python
|
|
711
|
+
import pulumi
|
|
712
|
+
import pulumi_vsphere as vsphere
|
|
713
|
+
|
|
714
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
715
|
+
thumbprint = vsphere.get_host_thumbprint(address="esxi-01.example.com",
|
|
716
|
+
insecure=True)
|
|
717
|
+
esx_01 = vsphere.Host("esx-01",
|
|
718
|
+
hostname="esxi-01.example.com",
|
|
719
|
+
username="root",
|
|
720
|
+
password="password",
|
|
721
|
+
license="00000-00000-00000-00000-00000",
|
|
722
|
+
thumbprint=thumbprint.id,
|
|
723
|
+
datacenter=datacenter.id)
|
|
724
|
+
```
|
|
725
|
+
|
|
726
|
+
After the hosts are added to the datacenter, a resource pool can then be created on the host.
|
|
727
|
+
|
|
728
|
+
```python
|
|
729
|
+
import pulumi
|
|
730
|
+
import pulumi_vsphere as vsphere
|
|
731
|
+
|
|
732
|
+
host = vsphere.get_host(name="esxi-01.example.com",
|
|
733
|
+
datacenter_id=datacenter["id"])
|
|
734
|
+
resource_pool = vsphere.ResourcePool("resource_pool",
|
|
735
|
+
name="site1-resource-pool",
|
|
736
|
+
parent_resource_pool_id=host.resource_pool_id)
|
|
737
|
+
```
|
|
738
|
+
|
|
739
|
+
## Import
|
|
740
|
+
|
|
696
741
|
### Settings that Require vSphere 7.0 or higher
|
|
697
742
|
|
|
698
743
|
These settings require vSphere 7.0 or higher:
|
|
699
744
|
|
|
700
|
-
* `scale_descendants_shares`
|
|
745
|
+
* [`scale_descendants_shares`](#scale_descendants_shares)
|
|
701
746
|
|
|
702
747
|
:param str resource_name: The name of the resource.
|
|
703
748
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
704
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a resource
|
|
749
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a resource
|
|
705
750
|
pool can grow beyond the specified value if the parent resource pool has
|
|
706
751
|
unreserved resources. Default: `true`
|
|
707
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a resource pool will not
|
|
752
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a resource pool will not
|
|
708
753
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
709
754
|
unlimited. Default: `-1`
|
|
710
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
755
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
711
756
|
available to the resource pool. Default: `0`
|
|
712
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
757
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
713
758
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
714
759
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
715
760
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
716
761
|
ignored. Default: `normal`
|
|
717
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
762
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
718
763
|
determine resource allocation in case of resource contention. If this is set,
|
|
719
764
|
`cpu_share_level` must be `custom`.
|
|
720
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
721
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a resource
|
|
765
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
766
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a resource
|
|
722
767
|
pool can grow beyond the specified value if the parent resource pool has
|
|
723
768
|
unreserved resources. Default: `true`
|
|
724
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a resource pool will not
|
|
769
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a resource pool will not
|
|
725
770
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
726
771
|
unlimited. Default: `-1`
|
|
727
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
772
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
728
773
|
available to the resource pool. Default: `0`
|
|
729
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
774
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
730
775
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
731
776
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
732
777
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
733
778
|
ignored. Default: `normal`
|
|
734
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
779
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
735
780
|
determine resource allocation in case of resource contention. If this is set,
|
|
736
781
|
`memory_share_level` must be `custom`.
|
|
737
|
-
:param pulumi.Input[str] name: The name of the resource pool.
|
|
738
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
782
|
+
:param pulumi.Input[_builtins.str] name: The name of the resource pool.
|
|
783
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
739
784
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
740
785
|
or standalone host, or a resource pool itself. When moving a resource pool
|
|
741
786
|
from one parent resource pool to another, both must share a common root
|
|
742
787
|
resource pool.
|
|
743
|
-
:param pulumi.Input[str] scale_descendants_shares: Determines if the shares of all
|
|
788
|
+
:param pulumi.Input[_builtins.str] scale_descendants_shares: Determines if the shares of all
|
|
744
789
|
descendants of the resource pool are scaled up or down when the shares
|
|
745
790
|
of the resource pool are scaled up or down. Can be one of `disabled` or
|
|
746
791
|
`scaleCpuAndMemoryShares`. Default: `disabled`.
|
|
747
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
792
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
748
793
|
"""
|
|
749
794
|
...
|
|
750
795
|
@overload
|
|
@@ -759,7 +804,7 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
759
804
|
For more information on vSphere resource pools, please refer to the
|
|
760
805
|
[product documentation][ref-vsphere-resource_pools].
|
|
761
806
|
|
|
762
|
-
[ref-vsphere-resource_pools]: https://
|
|
807
|
+
[ref-vsphere-resource_pools]: https://techdocs.broadcom.com/us/en/vmware-cis/vsphere/vsphere/8-0/vsphere-resource-management-8-0/managing-resource-pools.html
|
|
763
808
|
|
|
764
809
|
## Example Usage
|
|
765
810
|
|
|
@@ -773,7 +818,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
773
818
|
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
774
819
|
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
775
820
|
datacenter_id=datacenter.id)
|
|
776
|
-
resource_pool = vsphere.ResourcePool("
|
|
821
|
+
resource_pool = vsphere.ResourcePool("resource_pool",
|
|
822
|
+
name="resource-pool-01",
|
|
823
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
777
824
|
```
|
|
778
825
|
|
|
779
826
|
A virtual machine resource could be targeted to use the default resource pool
|
|
@@ -783,8 +830,7 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
783
830
|
import pulumi
|
|
784
831
|
import pulumi_vsphere as vsphere
|
|
785
832
|
|
|
786
|
-
vm = vsphere.VirtualMachine("vm", resource_pool_id=
|
|
787
|
-
# ... other configuration ...
|
|
833
|
+
vm = vsphere.VirtualMachine("vm", resource_pool_id=cluster["resourcePoolId"])
|
|
788
834
|
```
|
|
789
835
|
|
|
790
836
|
The following example sets up a parent resource pool in an existing compute cluster
|
|
@@ -798,15 +844,53 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
798
844
|
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
799
845
|
compute_cluster = vsphere.get_compute_cluster(name="cluster-01",
|
|
800
846
|
datacenter_id=datacenter.id)
|
|
801
|
-
resource_pool_parent = vsphere.ResourcePool("
|
|
802
|
-
|
|
847
|
+
resource_pool_parent = vsphere.ResourcePool("resource_pool_parent",
|
|
848
|
+
name="parent",
|
|
849
|
+
parent_resource_pool_id=compute_cluster.resource_pool_id)
|
|
850
|
+
resource_pool_child = vsphere.ResourcePool("resource_pool_child",
|
|
851
|
+
name="child",
|
|
852
|
+
parent_resource_pool_id=resource_pool_parent.id)
|
|
803
853
|
```
|
|
804
|
-
|
|
854
|
+
|
|
855
|
+
The following example set up a parent resource pool on a standalone ESXi host with the default
|
|
856
|
+
settings for CPU and memory reservations, shares, and limits.
|
|
857
|
+
|
|
858
|
+
```python
|
|
859
|
+
import pulumi
|
|
860
|
+
import pulumi_vsphere as vsphere
|
|
861
|
+
|
|
862
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
863
|
+
thumbprint = vsphere.get_host_thumbprint(address="esxi-01.example.com",
|
|
864
|
+
insecure=True)
|
|
865
|
+
esx_01 = vsphere.Host("esx-01",
|
|
866
|
+
hostname="esxi-01.example.com",
|
|
867
|
+
username="root",
|
|
868
|
+
password="password",
|
|
869
|
+
license="00000-00000-00000-00000-00000",
|
|
870
|
+
thumbprint=thumbprint.id,
|
|
871
|
+
datacenter=datacenter.id)
|
|
872
|
+
```
|
|
873
|
+
|
|
874
|
+
After the hosts are added to the datacenter, a resource pool can then be created on the host.
|
|
875
|
+
|
|
876
|
+
```python
|
|
877
|
+
import pulumi
|
|
878
|
+
import pulumi_vsphere as vsphere
|
|
879
|
+
|
|
880
|
+
host = vsphere.get_host(name="esxi-01.example.com",
|
|
881
|
+
datacenter_id=datacenter["id"])
|
|
882
|
+
resource_pool = vsphere.ResourcePool("resource_pool",
|
|
883
|
+
name="site1-resource-pool",
|
|
884
|
+
parent_resource_pool_id=host.resource_pool_id)
|
|
885
|
+
```
|
|
886
|
+
|
|
887
|
+
## Import
|
|
888
|
+
|
|
805
889
|
### Settings that Require vSphere 7.0 or higher
|
|
806
890
|
|
|
807
891
|
These settings require vSphere 7.0 or higher:
|
|
808
892
|
|
|
809
|
-
* `scale_descendants_shares`
|
|
893
|
+
* [`scale_descendants_shares`](#scale_descendants_shares)
|
|
810
894
|
|
|
811
895
|
:param str resource_name: The name of the resource.
|
|
812
896
|
:param ResourcePoolArgs args: The arguments to use to populate this resource's properties.
|
|
@@ -823,21 +907,21 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
823
907
|
def _internal_init(__self__,
|
|
824
908
|
resource_name: str,
|
|
825
909
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
826
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
827
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
828
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
829
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
830
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
831
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
832
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
833
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
834
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
835
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
836
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
837
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
838
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
839
|
-
scale_descendants_shares: Optional[pulumi.Input[str]] = None,
|
|
840
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
910
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
911
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
912
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
913
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
914
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
915
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
916
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
917
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
918
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
919
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
920
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
921
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
922
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
923
|
+
scale_descendants_shares: Optional[pulumi.Input[_builtins.str]] = None,
|
|
924
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
841
925
|
__props__=None):
|
|
842
926
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
843
927
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -874,21 +958,21 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
874
958
|
def get(resource_name: str,
|
|
875
959
|
id: pulumi.Input[str],
|
|
876
960
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
877
|
-
cpu_expandable: Optional[pulumi.Input[bool]] = None,
|
|
878
|
-
cpu_limit: Optional[pulumi.Input[int]] = None,
|
|
879
|
-
cpu_reservation: Optional[pulumi.Input[int]] = None,
|
|
880
|
-
cpu_share_level: Optional[pulumi.Input[str]] = None,
|
|
881
|
-
cpu_shares: Optional[pulumi.Input[int]] = None,
|
|
882
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
883
|
-
memory_expandable: Optional[pulumi.Input[bool]] = None,
|
|
884
|
-
memory_limit: Optional[pulumi.Input[int]] = None,
|
|
885
|
-
memory_reservation: Optional[pulumi.Input[int]] = None,
|
|
886
|
-
memory_share_level: Optional[pulumi.Input[str]] = None,
|
|
887
|
-
memory_shares: Optional[pulumi.Input[int]] = None,
|
|
888
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
889
|
-
parent_resource_pool_id: Optional[pulumi.Input[str]] = None,
|
|
890
|
-
scale_descendants_shares: Optional[pulumi.Input[str]] = None,
|
|
891
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'ResourcePool':
|
|
961
|
+
cpu_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
962
|
+
cpu_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
963
|
+
cpu_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
964
|
+
cpu_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
965
|
+
cpu_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
966
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
967
|
+
memory_expandable: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
968
|
+
memory_limit: Optional[pulumi.Input[_builtins.int]] = None,
|
|
969
|
+
memory_reservation: Optional[pulumi.Input[_builtins.int]] = None,
|
|
970
|
+
memory_share_level: Optional[pulumi.Input[_builtins.str]] = None,
|
|
971
|
+
memory_shares: Optional[pulumi.Input[_builtins.int]] = None,
|
|
972
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
973
|
+
parent_resource_pool_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
974
|
+
scale_descendants_shares: Optional[pulumi.Input[_builtins.str]] = None,
|
|
975
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None) -> 'ResourcePool':
|
|
892
976
|
"""
|
|
893
977
|
Get an existing ResourcePool resource's state with the given name, id, and optional extra
|
|
894
978
|
properties used to qualify the lookup.
|
|
@@ -896,50 +980,50 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
896
980
|
:param str resource_name: The unique name of the resulting resource.
|
|
897
981
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
898
982
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
899
|
-
:param pulumi.Input[bool] cpu_expandable: Determines if the reservation on a resource
|
|
983
|
+
:param pulumi.Input[_builtins.bool] cpu_expandable: Determines if the reservation on a resource
|
|
900
984
|
pool can grow beyond the specified value if the parent resource pool has
|
|
901
985
|
unreserved resources. Default: `true`
|
|
902
|
-
:param pulumi.Input[int] cpu_limit: The CPU utilization of a resource pool will not
|
|
986
|
+
:param pulumi.Input[_builtins.int] cpu_limit: The CPU utilization of a resource pool will not
|
|
903
987
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
904
988
|
unlimited. Default: `-1`
|
|
905
|
-
:param pulumi.Input[int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
989
|
+
:param pulumi.Input[_builtins.int] cpu_reservation: Amount of CPU (MHz) that is guaranteed
|
|
906
990
|
available to the resource pool. Default: `0`
|
|
907
|
-
:param pulumi.Input[str] cpu_share_level: The CPU allocation level. The level is a
|
|
991
|
+
:param pulumi.Input[_builtins.str] cpu_share_level: The CPU allocation level. The level is a
|
|
908
992
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
909
993
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
910
994
|
`low`, `normal`, or `high` are specified values in `cpu_shares` will be
|
|
911
995
|
ignored. Default: `normal`
|
|
912
|
-
:param pulumi.Input[int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
996
|
+
:param pulumi.Input[_builtins.int] cpu_shares: The number of shares allocated for CPU. Used to
|
|
913
997
|
determine resource allocation in case of resource contention. If this is set,
|
|
914
998
|
`cpu_share_level` must be `custom`.
|
|
915
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
916
|
-
:param pulumi.Input[bool] memory_expandable: Determines if the reservation on a resource
|
|
999
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: A list of custom attributes to set on this resource.
|
|
1000
|
+
:param pulumi.Input[_builtins.bool] memory_expandable: Determines if the reservation on a resource
|
|
917
1001
|
pool can grow beyond the specified value if the parent resource pool has
|
|
918
1002
|
unreserved resources. Default: `true`
|
|
919
|
-
:param pulumi.Input[int] memory_limit: The CPU utilization of a resource pool will not
|
|
1003
|
+
:param pulumi.Input[_builtins.int] memory_limit: The CPU utilization of a resource pool will not
|
|
920
1004
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
921
1005
|
unlimited. Default: `-1`
|
|
922
|
-
:param pulumi.Input[int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
1006
|
+
:param pulumi.Input[_builtins.int] memory_reservation: Amount of CPU (MHz) that is guaranteed
|
|
923
1007
|
available to the resource pool. Default: `0`
|
|
924
|
-
:param pulumi.Input[str] memory_share_level: The CPU allocation level. The level is a
|
|
1008
|
+
:param pulumi.Input[_builtins.str] memory_share_level: The CPU allocation level. The level is a
|
|
925
1009
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
926
1010
|
values for shares. Can be one of `low`, `normal`, `high`, or `custom`. When
|
|
927
1011
|
`low`, `normal`, or `high` are specified values in `memory_shares` will be
|
|
928
1012
|
ignored. Default: `normal`
|
|
929
|
-
:param pulumi.Input[int] memory_shares: The number of shares allocated for CPU. Used to
|
|
1013
|
+
:param pulumi.Input[_builtins.int] memory_shares: The number of shares allocated for CPU. Used to
|
|
930
1014
|
determine resource allocation in case of resource contention. If this is set,
|
|
931
1015
|
`memory_share_level` must be `custom`.
|
|
932
|
-
:param pulumi.Input[str] name: The name of the resource pool.
|
|
933
|
-
:param pulumi.Input[str] parent_resource_pool_id: The managed object ID
|
|
1016
|
+
:param pulumi.Input[_builtins.str] name: The name of the resource pool.
|
|
1017
|
+
:param pulumi.Input[_builtins.str] parent_resource_pool_id: The managed object ID
|
|
934
1018
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
935
1019
|
or standalone host, or a resource pool itself. When moving a resource pool
|
|
936
1020
|
from one parent resource pool to another, both must share a common root
|
|
937
1021
|
resource pool.
|
|
938
|
-
:param pulumi.Input[str] scale_descendants_shares: Determines if the shares of all
|
|
1022
|
+
:param pulumi.Input[_builtins.str] scale_descendants_shares: Determines if the shares of all
|
|
939
1023
|
descendants of the resource pool are scaled up or down when the shares
|
|
940
1024
|
of the resource pool are scaled up or down. Can be one of `disabled` or
|
|
941
1025
|
`scaleCpuAndMemoryShares`. Default: `disabled`.
|
|
942
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
1026
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
943
1027
|
"""
|
|
944
1028
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
945
1029
|
|
|
@@ -962,9 +1046,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
962
1046
|
__props__.__dict__["tags"] = tags
|
|
963
1047
|
return ResourcePool(resource_name, opts=opts, __props__=__props__)
|
|
964
1048
|
|
|
965
|
-
@property
|
|
1049
|
+
@_builtins.property
|
|
966
1050
|
@pulumi.getter(name="cpuExpandable")
|
|
967
|
-
def cpu_expandable(self) -> pulumi.Output[Optional[bool]]:
|
|
1051
|
+
def cpu_expandable(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
968
1052
|
"""
|
|
969
1053
|
Determines if the reservation on a resource
|
|
970
1054
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -972,9 +1056,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
972
1056
|
"""
|
|
973
1057
|
return pulumi.get(self, "cpu_expandable")
|
|
974
1058
|
|
|
975
|
-
@property
|
|
1059
|
+
@_builtins.property
|
|
976
1060
|
@pulumi.getter(name="cpuLimit")
|
|
977
|
-
def cpu_limit(self) -> pulumi.Output[Optional[int]]:
|
|
1061
|
+
def cpu_limit(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
978
1062
|
"""
|
|
979
1063
|
The CPU utilization of a resource pool will not
|
|
980
1064
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -982,18 +1066,18 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
982
1066
|
"""
|
|
983
1067
|
return pulumi.get(self, "cpu_limit")
|
|
984
1068
|
|
|
985
|
-
@property
|
|
1069
|
+
@_builtins.property
|
|
986
1070
|
@pulumi.getter(name="cpuReservation")
|
|
987
|
-
def cpu_reservation(self) -> pulumi.Output[Optional[int]]:
|
|
1071
|
+
def cpu_reservation(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
988
1072
|
"""
|
|
989
1073
|
Amount of CPU (MHz) that is guaranteed
|
|
990
1074
|
available to the resource pool. Default: `0`
|
|
991
1075
|
"""
|
|
992
1076
|
return pulumi.get(self, "cpu_reservation")
|
|
993
1077
|
|
|
994
|
-
@property
|
|
1078
|
+
@_builtins.property
|
|
995
1079
|
@pulumi.getter(name="cpuShareLevel")
|
|
996
|
-
def cpu_share_level(self) -> pulumi.Output[Optional[str]]:
|
|
1080
|
+
def cpu_share_level(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
997
1081
|
"""
|
|
998
1082
|
The CPU allocation level. The level is a
|
|
999
1083
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -1003,9 +1087,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1003
1087
|
"""
|
|
1004
1088
|
return pulumi.get(self, "cpu_share_level")
|
|
1005
1089
|
|
|
1006
|
-
@property
|
|
1090
|
+
@_builtins.property
|
|
1007
1091
|
@pulumi.getter(name="cpuShares")
|
|
1008
|
-
def cpu_shares(self) -> pulumi.Output[int]:
|
|
1092
|
+
def cpu_shares(self) -> pulumi.Output[_builtins.int]:
|
|
1009
1093
|
"""
|
|
1010
1094
|
The number of shares allocated for CPU. Used to
|
|
1011
1095
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -1013,17 +1097,17 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1013
1097
|
"""
|
|
1014
1098
|
return pulumi.get(self, "cpu_shares")
|
|
1015
1099
|
|
|
1016
|
-
@property
|
|
1100
|
+
@_builtins.property
|
|
1017
1101
|
@pulumi.getter(name="customAttributes")
|
|
1018
|
-
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
1102
|
+
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
1019
1103
|
"""
|
|
1020
1104
|
A list of custom attributes to set on this resource.
|
|
1021
1105
|
"""
|
|
1022
1106
|
return pulumi.get(self, "custom_attributes")
|
|
1023
1107
|
|
|
1024
|
-
@property
|
|
1108
|
+
@_builtins.property
|
|
1025
1109
|
@pulumi.getter(name="memoryExpandable")
|
|
1026
|
-
def memory_expandable(self) -> pulumi.Output[Optional[bool]]:
|
|
1110
|
+
def memory_expandable(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1027
1111
|
"""
|
|
1028
1112
|
Determines if the reservation on a resource
|
|
1029
1113
|
pool can grow beyond the specified value if the parent resource pool has
|
|
@@ -1031,9 +1115,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1031
1115
|
"""
|
|
1032
1116
|
return pulumi.get(self, "memory_expandable")
|
|
1033
1117
|
|
|
1034
|
-
@property
|
|
1118
|
+
@_builtins.property
|
|
1035
1119
|
@pulumi.getter(name="memoryLimit")
|
|
1036
|
-
def memory_limit(self) -> pulumi.Output[Optional[int]]:
|
|
1120
|
+
def memory_limit(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1037
1121
|
"""
|
|
1038
1122
|
The CPU utilization of a resource pool will not
|
|
1039
1123
|
exceed this limit, even if there are available resources. Set to `-1` for
|
|
@@ -1041,18 +1125,18 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1041
1125
|
"""
|
|
1042
1126
|
return pulumi.get(self, "memory_limit")
|
|
1043
1127
|
|
|
1044
|
-
@property
|
|
1128
|
+
@_builtins.property
|
|
1045
1129
|
@pulumi.getter(name="memoryReservation")
|
|
1046
|
-
def memory_reservation(self) -> pulumi.Output[Optional[int]]:
|
|
1130
|
+
def memory_reservation(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1047
1131
|
"""
|
|
1048
1132
|
Amount of CPU (MHz) that is guaranteed
|
|
1049
1133
|
available to the resource pool. Default: `0`
|
|
1050
1134
|
"""
|
|
1051
1135
|
return pulumi.get(self, "memory_reservation")
|
|
1052
1136
|
|
|
1053
|
-
@property
|
|
1137
|
+
@_builtins.property
|
|
1054
1138
|
@pulumi.getter(name="memoryShareLevel")
|
|
1055
|
-
def memory_share_level(self) -> pulumi.Output[Optional[str]]:
|
|
1139
|
+
def memory_share_level(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1056
1140
|
"""
|
|
1057
1141
|
The CPU allocation level. The level is a
|
|
1058
1142
|
simplified view of shares. Levels map to a pre-determined set of numeric
|
|
@@ -1062,9 +1146,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1062
1146
|
"""
|
|
1063
1147
|
return pulumi.get(self, "memory_share_level")
|
|
1064
1148
|
|
|
1065
|
-
@property
|
|
1149
|
+
@_builtins.property
|
|
1066
1150
|
@pulumi.getter(name="memoryShares")
|
|
1067
|
-
def memory_shares(self) -> pulumi.Output[int]:
|
|
1151
|
+
def memory_shares(self) -> pulumi.Output[_builtins.int]:
|
|
1068
1152
|
"""
|
|
1069
1153
|
The number of shares allocated for CPU. Used to
|
|
1070
1154
|
determine resource allocation in case of resource contention. If this is set,
|
|
@@ -1072,17 +1156,17 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1072
1156
|
"""
|
|
1073
1157
|
return pulumi.get(self, "memory_shares")
|
|
1074
1158
|
|
|
1075
|
-
@property
|
|
1159
|
+
@_builtins.property
|
|
1076
1160
|
@pulumi.getter
|
|
1077
|
-
def name(self) -> pulumi.Output[str]:
|
|
1161
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1078
1162
|
"""
|
|
1079
1163
|
The name of the resource pool.
|
|
1080
1164
|
"""
|
|
1081
1165
|
return pulumi.get(self, "name")
|
|
1082
1166
|
|
|
1083
|
-
@property
|
|
1167
|
+
@_builtins.property
|
|
1084
1168
|
@pulumi.getter(name="parentResourcePoolId")
|
|
1085
|
-
def parent_resource_pool_id(self) -> pulumi.Output[str]:
|
|
1169
|
+
def parent_resource_pool_id(self) -> pulumi.Output[_builtins.str]:
|
|
1086
1170
|
"""
|
|
1087
1171
|
The managed object ID
|
|
1088
1172
|
of the parent resource pool. This can be the root resource pool for a cluster
|
|
@@ -1092,9 +1176,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1092
1176
|
"""
|
|
1093
1177
|
return pulumi.get(self, "parent_resource_pool_id")
|
|
1094
1178
|
|
|
1095
|
-
@property
|
|
1179
|
+
@_builtins.property
|
|
1096
1180
|
@pulumi.getter(name="scaleDescendantsShares")
|
|
1097
|
-
def scale_descendants_shares(self) -> pulumi.Output[Optional[str]]:
|
|
1181
|
+
def scale_descendants_shares(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1098
1182
|
"""
|
|
1099
1183
|
Determines if the shares of all
|
|
1100
1184
|
descendants of the resource pool are scaled up or down when the shares
|
|
@@ -1103,9 +1187,9 @@ class ResourcePool(pulumi.CustomResource):
|
|
|
1103
1187
|
"""
|
|
1104
1188
|
return pulumi.get(self, "scale_descendants_shares")
|
|
1105
1189
|
|
|
1106
|
-
@property
|
|
1190
|
+
@_builtins.property
|
|
1107
1191
|
@pulumi.getter
|
|
1108
|
-
def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1192
|
+
def tags(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
1109
1193
|
"""
|
|
1110
1194
|
The IDs of any tags to attach to this resource.
|
|
1111
1195
|
"""
|