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/vmfs_datastore.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__ = ['VmfsDatastoreArgs', 'VmfsDatastore']
|
|
@@ -14,39 +19,39 @@ __all__ = ['VmfsDatastoreArgs', 'VmfsDatastore']
|
|
|
14
19
|
@pulumi.input_type
|
|
15
20
|
class VmfsDatastoreArgs:
|
|
16
21
|
def __init__(__self__, *,
|
|
17
|
-
disks: pulumi.Input[Sequence[pulumi.Input[str]]],
|
|
18
|
-
host_system_id: pulumi.Input[str],
|
|
19
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
20
|
-
datastore_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
21
|
-
folder: Optional[pulumi.Input[str]] = None,
|
|
22
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
23
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
|
|
22
|
+
disks: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
|
|
23
|
+
host_system_id: pulumi.Input[_builtins.str],
|
|
24
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
25
|
+
datastore_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
26
|
+
folder: Optional[pulumi.Input[_builtins.str]] = None,
|
|
27
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
|
|
24
29
|
"""
|
|
25
30
|
The set of arguments for constructing a VmfsDatastore resource.
|
|
26
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] disks: The disks to use with the datastore.
|
|
27
|
-
:param pulumi.Input[str] host_system_id: The managed object ID of
|
|
31
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disks: The disks to use with the datastore.
|
|
32
|
+
:param pulumi.Input[_builtins.str] host_system_id: The managed object ID of
|
|
28
33
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
29
34
|
only host that the datastore will be set up on - see
|
|
30
35
|
here for more info. Forces a
|
|
31
36
|
new resource if changed.
|
|
32
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
37
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
33
38
|
value string to set on datastore resource.
|
|
34
39
|
|
|
35
40
|
> **NOTE:** Custom attributes are unsupported on direct ESXi connections
|
|
36
41
|
and require vCenter.
|
|
37
|
-
:param pulumi.Input[str] datastore_cluster_id: The managed object
|
|
42
|
+
:param pulumi.Input[_builtins.str] datastore_cluster_id: The managed object
|
|
38
43
|
ID of a datastore cluster to put this datastore in.
|
|
39
44
|
Conflicts with `folder`.
|
|
40
|
-
:param pulumi.Input[str] folder: The relative path to a folder to put this datastore in.
|
|
45
|
+
:param pulumi.Input[_builtins.str] folder: The relative path to a folder to put this datastore in.
|
|
41
46
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
42
47
|
Example: for the `dc1` datacenter, and a provided `folder` of `foo/bar`,
|
|
43
48
|
The provider will place a datastore named `test` in a datastore folder
|
|
44
49
|
located at `/dc1/datastore/foo/bar`, with the final inventory path being
|
|
45
50
|
`/dc1/datastore/foo/bar/test`. Conflicts with
|
|
46
51
|
`datastore_cluster_id`.
|
|
47
|
-
:param pulumi.Input[str] name: The name of the datastore. Forces a new resource if
|
|
52
|
+
:param pulumi.Input[_builtins.str] name: The name of the datastore. Forces a new resource if
|
|
48
53
|
changed.
|
|
49
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
54
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
50
55
|
|
|
51
56
|
> **NOTE:** Tagging support is unsupported on direct ESXi connections and
|
|
52
57
|
requires vCenter 6.0 or higher.
|
|
@@ -64,21 +69,21 @@ class VmfsDatastoreArgs:
|
|
|
64
69
|
if tags is not None:
|
|
65
70
|
pulumi.set(__self__, "tags", tags)
|
|
66
71
|
|
|
67
|
-
@property
|
|
72
|
+
@_builtins.property
|
|
68
73
|
@pulumi.getter
|
|
69
|
-
def disks(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
|
|
74
|
+
def disks(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
|
|
70
75
|
"""
|
|
71
76
|
The disks to use with the datastore.
|
|
72
77
|
"""
|
|
73
78
|
return pulumi.get(self, "disks")
|
|
74
79
|
|
|
75
80
|
@disks.setter
|
|
76
|
-
def disks(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
|
|
81
|
+
def disks(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
|
|
77
82
|
pulumi.set(self, "disks", value)
|
|
78
83
|
|
|
79
|
-
@property
|
|
84
|
+
@_builtins.property
|
|
80
85
|
@pulumi.getter(name="hostSystemId")
|
|
81
|
-
def host_system_id(self) -> pulumi.Input[str]:
|
|
86
|
+
def host_system_id(self) -> pulumi.Input[_builtins.str]:
|
|
82
87
|
"""
|
|
83
88
|
The managed object ID of
|
|
84
89
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
@@ -89,12 +94,12 @@ class VmfsDatastoreArgs:
|
|
|
89
94
|
return pulumi.get(self, "host_system_id")
|
|
90
95
|
|
|
91
96
|
@host_system_id.setter
|
|
92
|
-
def host_system_id(self, value: pulumi.Input[str]):
|
|
97
|
+
def host_system_id(self, value: pulumi.Input[_builtins.str]):
|
|
93
98
|
pulumi.set(self, "host_system_id", value)
|
|
94
99
|
|
|
95
|
-
@property
|
|
100
|
+
@_builtins.property
|
|
96
101
|
@pulumi.getter(name="customAttributes")
|
|
97
|
-
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
102
|
+
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
98
103
|
"""
|
|
99
104
|
Map of custom attribute ids to attribute
|
|
100
105
|
value string to set on datastore resource.
|
|
@@ -105,12 +110,12 @@ class VmfsDatastoreArgs:
|
|
|
105
110
|
return pulumi.get(self, "custom_attributes")
|
|
106
111
|
|
|
107
112
|
@custom_attributes.setter
|
|
108
|
-
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
113
|
+
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
109
114
|
pulumi.set(self, "custom_attributes", value)
|
|
110
115
|
|
|
111
|
-
@property
|
|
116
|
+
@_builtins.property
|
|
112
117
|
@pulumi.getter(name="datastoreClusterId")
|
|
113
|
-
def datastore_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
118
|
+
def datastore_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
114
119
|
"""
|
|
115
120
|
The managed object
|
|
116
121
|
ID of a datastore cluster to put this datastore in.
|
|
@@ -119,12 +124,12 @@ class VmfsDatastoreArgs:
|
|
|
119
124
|
return pulumi.get(self, "datastore_cluster_id")
|
|
120
125
|
|
|
121
126
|
@datastore_cluster_id.setter
|
|
122
|
-
def datastore_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
127
|
+
def datastore_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
123
128
|
pulumi.set(self, "datastore_cluster_id", value)
|
|
124
129
|
|
|
125
|
-
@property
|
|
130
|
+
@_builtins.property
|
|
126
131
|
@pulumi.getter
|
|
127
|
-
def folder(self) -> Optional[pulumi.Input[str]]:
|
|
132
|
+
def folder(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
128
133
|
"""
|
|
129
134
|
The relative path to a folder to put this datastore in.
|
|
130
135
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
@@ -137,12 +142,12 @@ class VmfsDatastoreArgs:
|
|
|
137
142
|
return pulumi.get(self, "folder")
|
|
138
143
|
|
|
139
144
|
@folder.setter
|
|
140
|
-
def folder(self, value: Optional[pulumi.Input[str]]):
|
|
145
|
+
def folder(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
141
146
|
pulumi.set(self, "folder", value)
|
|
142
147
|
|
|
143
|
-
@property
|
|
148
|
+
@_builtins.property
|
|
144
149
|
@pulumi.getter
|
|
145
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
150
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
146
151
|
"""
|
|
147
152
|
The name of the datastore. Forces a new resource if
|
|
148
153
|
changed.
|
|
@@ -150,12 +155,12 @@ class VmfsDatastoreArgs:
|
|
|
150
155
|
return pulumi.get(self, "name")
|
|
151
156
|
|
|
152
157
|
@name.setter
|
|
153
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
158
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
154
159
|
pulumi.set(self, "name", value)
|
|
155
160
|
|
|
156
|
-
@property
|
|
161
|
+
@_builtins.property
|
|
157
162
|
@pulumi.getter
|
|
158
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
163
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
159
164
|
"""
|
|
160
165
|
The IDs of any tags to attach to this resource.
|
|
161
166
|
|
|
@@ -165,66 +170,66 @@ class VmfsDatastoreArgs:
|
|
|
165
170
|
return pulumi.get(self, "tags")
|
|
166
171
|
|
|
167
172
|
@tags.setter
|
|
168
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
173
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
169
174
|
pulumi.set(self, "tags", value)
|
|
170
175
|
|
|
171
176
|
|
|
172
177
|
@pulumi.input_type
|
|
173
178
|
class _VmfsDatastoreState:
|
|
174
179
|
def __init__(__self__, *,
|
|
175
|
-
accessible: Optional[pulumi.Input[bool]] = None,
|
|
176
|
-
capacity: Optional[pulumi.Input[int]] = None,
|
|
177
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
178
|
-
datastore_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
179
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
180
|
-
folder: Optional[pulumi.Input[str]] = None,
|
|
181
|
-
free_space: Optional[pulumi.Input[int]] = None,
|
|
182
|
-
host_system_id: Optional[pulumi.Input[str]] = None,
|
|
183
|
-
maintenance_mode: Optional[pulumi.Input[str]] = None,
|
|
184
|
-
multiple_host_access: Optional[pulumi.Input[bool]] = None,
|
|
185
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
186
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
187
|
-
uncommitted_space: Optional[pulumi.Input[int]] = None,
|
|
188
|
-
url: Optional[pulumi.Input[str]] = None):
|
|
180
|
+
accessible: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
181
|
+
capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
182
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
183
|
+
datastore_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
184
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
185
|
+
folder: Optional[pulumi.Input[_builtins.str]] = None,
|
|
186
|
+
free_space: Optional[pulumi.Input[_builtins.int]] = None,
|
|
187
|
+
host_system_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
188
|
+
maintenance_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
189
|
+
multiple_host_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
190
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
191
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
192
|
+
uncommitted_space: Optional[pulumi.Input[_builtins.int]] = None,
|
|
193
|
+
url: Optional[pulumi.Input[_builtins.str]] = None):
|
|
189
194
|
"""
|
|
190
195
|
Input properties used for looking up and filtering VmfsDatastore resources.
|
|
191
|
-
:param pulumi.Input[bool] accessible: The connectivity status of the datastore. If this is `false`,
|
|
196
|
+
:param pulumi.Input[_builtins.bool] accessible: The connectivity status of the datastore. If this is `false`,
|
|
192
197
|
some other computed attributes may be out of date.
|
|
193
|
-
:param pulumi.Input[int] capacity: Maximum capacity of the datastore, in megabytes.
|
|
194
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
198
|
+
:param pulumi.Input[_builtins.int] capacity: Maximum capacity of the datastore, in megabytes.
|
|
199
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
195
200
|
value string to set on datastore resource.
|
|
196
201
|
|
|
197
202
|
> **NOTE:** Custom attributes are unsupported on direct ESXi connections
|
|
198
203
|
and require vCenter.
|
|
199
|
-
:param pulumi.Input[str] datastore_cluster_id: The managed object
|
|
204
|
+
:param pulumi.Input[_builtins.str] datastore_cluster_id: The managed object
|
|
200
205
|
ID of a datastore cluster to put this datastore in.
|
|
201
206
|
Conflicts with `folder`.
|
|
202
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] disks: The disks to use with the datastore.
|
|
203
|
-
:param pulumi.Input[str] folder: The relative path to a folder to put this datastore in.
|
|
207
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disks: The disks to use with the datastore.
|
|
208
|
+
:param pulumi.Input[_builtins.str] folder: The relative path to a folder to put this datastore in.
|
|
204
209
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
205
210
|
Example: for the `dc1` datacenter, and a provided `folder` of `foo/bar`,
|
|
206
211
|
The provider will place a datastore named `test` in a datastore folder
|
|
207
212
|
located at `/dc1/datastore/foo/bar`, with the final inventory path being
|
|
208
213
|
`/dc1/datastore/foo/bar/test`. Conflicts with
|
|
209
214
|
`datastore_cluster_id`.
|
|
210
|
-
:param pulumi.Input[int] free_space: Available space of this datastore, in megabytes.
|
|
211
|
-
:param pulumi.Input[str] host_system_id: The managed object ID of
|
|
215
|
+
:param pulumi.Input[_builtins.int] free_space: Available space of this datastore, in megabytes.
|
|
216
|
+
:param pulumi.Input[_builtins.str] host_system_id: The managed object ID of
|
|
212
217
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
213
218
|
only host that the datastore will be set up on - see
|
|
214
219
|
here for more info. Forces a
|
|
215
220
|
new resource if changed.
|
|
216
|
-
:param pulumi.Input[str] maintenance_mode: The current maintenance mode state of the datastore.
|
|
217
|
-
:param pulumi.Input[bool] multiple_host_access: If `true`, more than one host in the datacenter has
|
|
221
|
+
:param pulumi.Input[_builtins.str] maintenance_mode: The current maintenance mode state of the datastore.
|
|
222
|
+
:param pulumi.Input[_builtins.bool] multiple_host_access: If `true`, more than one host in the datacenter has
|
|
218
223
|
been configured with access to the datastore.
|
|
219
|
-
:param pulumi.Input[str] name: The name of the datastore. Forces a new resource if
|
|
224
|
+
:param pulumi.Input[_builtins.str] name: The name of the datastore. Forces a new resource if
|
|
220
225
|
changed.
|
|
221
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
226
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
222
227
|
|
|
223
228
|
> **NOTE:** Tagging support is unsupported on direct ESXi connections and
|
|
224
229
|
requires vCenter 6.0 or higher.
|
|
225
|
-
:param pulumi.Input[int] uncommitted_space: Total additional storage space, in megabytes,
|
|
230
|
+
:param pulumi.Input[_builtins.int] uncommitted_space: Total additional storage space, in megabytes,
|
|
226
231
|
potentially used by all virtual machines on this datastore.
|
|
227
|
-
:param pulumi.Input[str] url: The unique locator for the datastore.
|
|
232
|
+
:param pulumi.Input[_builtins.str] url: The unique locator for the datastore.
|
|
228
233
|
"""
|
|
229
234
|
if accessible is not None:
|
|
230
235
|
pulumi.set(__self__, "accessible", accessible)
|
|
@@ -255,9 +260,9 @@ class _VmfsDatastoreState:
|
|
|
255
260
|
if url is not None:
|
|
256
261
|
pulumi.set(__self__, "url", url)
|
|
257
262
|
|
|
258
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
259
264
|
@pulumi.getter
|
|
260
|
-
def accessible(self) -> Optional[pulumi.Input[bool]]:
|
|
265
|
+
def accessible(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
261
266
|
"""
|
|
262
267
|
The connectivity status of the datastore. If this is `false`,
|
|
263
268
|
some other computed attributes may be out of date.
|
|
@@ -265,24 +270,24 @@ class _VmfsDatastoreState:
|
|
|
265
270
|
return pulumi.get(self, "accessible")
|
|
266
271
|
|
|
267
272
|
@accessible.setter
|
|
268
|
-
def accessible(self, value: Optional[pulumi.Input[bool]]):
|
|
273
|
+
def accessible(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
269
274
|
pulumi.set(self, "accessible", value)
|
|
270
275
|
|
|
271
|
-
@property
|
|
276
|
+
@_builtins.property
|
|
272
277
|
@pulumi.getter
|
|
273
|
-
def capacity(self) -> Optional[pulumi.Input[int]]:
|
|
278
|
+
def capacity(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
274
279
|
"""
|
|
275
280
|
Maximum capacity of the datastore, in megabytes.
|
|
276
281
|
"""
|
|
277
282
|
return pulumi.get(self, "capacity")
|
|
278
283
|
|
|
279
284
|
@capacity.setter
|
|
280
|
-
def capacity(self, value: Optional[pulumi.Input[int]]):
|
|
285
|
+
def capacity(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
281
286
|
pulumi.set(self, "capacity", value)
|
|
282
287
|
|
|
283
|
-
@property
|
|
288
|
+
@_builtins.property
|
|
284
289
|
@pulumi.getter(name="customAttributes")
|
|
285
|
-
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
|
|
290
|
+
def custom_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
|
|
286
291
|
"""
|
|
287
292
|
Map of custom attribute ids to attribute
|
|
288
293
|
value string to set on datastore resource.
|
|
@@ -293,12 +298,12 @@ class _VmfsDatastoreState:
|
|
|
293
298
|
return pulumi.get(self, "custom_attributes")
|
|
294
299
|
|
|
295
300
|
@custom_attributes.setter
|
|
296
|
-
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
|
|
301
|
+
def custom_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
|
|
297
302
|
pulumi.set(self, "custom_attributes", value)
|
|
298
303
|
|
|
299
|
-
@property
|
|
304
|
+
@_builtins.property
|
|
300
305
|
@pulumi.getter(name="datastoreClusterId")
|
|
301
|
-
def datastore_cluster_id(self) -> Optional[pulumi.Input[str]]:
|
|
306
|
+
def datastore_cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
302
307
|
"""
|
|
303
308
|
The managed object
|
|
304
309
|
ID of a datastore cluster to put this datastore in.
|
|
@@ -307,24 +312,24 @@ class _VmfsDatastoreState:
|
|
|
307
312
|
return pulumi.get(self, "datastore_cluster_id")
|
|
308
313
|
|
|
309
314
|
@datastore_cluster_id.setter
|
|
310
|
-
def datastore_cluster_id(self, value: Optional[pulumi.Input[str]]):
|
|
315
|
+
def datastore_cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
311
316
|
pulumi.set(self, "datastore_cluster_id", value)
|
|
312
317
|
|
|
313
|
-
@property
|
|
318
|
+
@_builtins.property
|
|
314
319
|
@pulumi.getter
|
|
315
|
-
def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
320
|
+
def disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
316
321
|
"""
|
|
317
322
|
The disks to use with the datastore.
|
|
318
323
|
"""
|
|
319
324
|
return pulumi.get(self, "disks")
|
|
320
325
|
|
|
321
326
|
@disks.setter
|
|
322
|
-
def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
327
|
+
def disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
323
328
|
pulumi.set(self, "disks", value)
|
|
324
329
|
|
|
325
|
-
@property
|
|
330
|
+
@_builtins.property
|
|
326
331
|
@pulumi.getter
|
|
327
|
-
def folder(self) -> Optional[pulumi.Input[str]]:
|
|
332
|
+
def folder(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
328
333
|
"""
|
|
329
334
|
The relative path to a folder to put this datastore in.
|
|
330
335
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
@@ -337,24 +342,24 @@ class _VmfsDatastoreState:
|
|
|
337
342
|
return pulumi.get(self, "folder")
|
|
338
343
|
|
|
339
344
|
@folder.setter
|
|
340
|
-
def folder(self, value: Optional[pulumi.Input[str]]):
|
|
345
|
+
def folder(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
341
346
|
pulumi.set(self, "folder", value)
|
|
342
347
|
|
|
343
|
-
@property
|
|
348
|
+
@_builtins.property
|
|
344
349
|
@pulumi.getter(name="freeSpace")
|
|
345
|
-
def free_space(self) -> Optional[pulumi.Input[int]]:
|
|
350
|
+
def free_space(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
346
351
|
"""
|
|
347
352
|
Available space of this datastore, in megabytes.
|
|
348
353
|
"""
|
|
349
354
|
return pulumi.get(self, "free_space")
|
|
350
355
|
|
|
351
356
|
@free_space.setter
|
|
352
|
-
def free_space(self, value: Optional[pulumi.Input[int]]):
|
|
357
|
+
def free_space(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
353
358
|
pulumi.set(self, "free_space", value)
|
|
354
359
|
|
|
355
|
-
@property
|
|
360
|
+
@_builtins.property
|
|
356
361
|
@pulumi.getter(name="hostSystemId")
|
|
357
|
-
def host_system_id(self) -> Optional[pulumi.Input[str]]:
|
|
362
|
+
def host_system_id(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
358
363
|
"""
|
|
359
364
|
The managed object ID of
|
|
360
365
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
@@ -365,24 +370,24 @@ class _VmfsDatastoreState:
|
|
|
365
370
|
return pulumi.get(self, "host_system_id")
|
|
366
371
|
|
|
367
372
|
@host_system_id.setter
|
|
368
|
-
def host_system_id(self, value: Optional[pulumi.Input[str]]):
|
|
373
|
+
def host_system_id(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
369
374
|
pulumi.set(self, "host_system_id", value)
|
|
370
375
|
|
|
371
|
-
@property
|
|
376
|
+
@_builtins.property
|
|
372
377
|
@pulumi.getter(name="maintenanceMode")
|
|
373
|
-
def maintenance_mode(self) -> Optional[pulumi.Input[str]]:
|
|
378
|
+
def maintenance_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
374
379
|
"""
|
|
375
380
|
The current maintenance mode state of the datastore.
|
|
376
381
|
"""
|
|
377
382
|
return pulumi.get(self, "maintenance_mode")
|
|
378
383
|
|
|
379
384
|
@maintenance_mode.setter
|
|
380
|
-
def maintenance_mode(self, value: Optional[pulumi.Input[str]]):
|
|
385
|
+
def maintenance_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
381
386
|
pulumi.set(self, "maintenance_mode", value)
|
|
382
387
|
|
|
383
|
-
@property
|
|
388
|
+
@_builtins.property
|
|
384
389
|
@pulumi.getter(name="multipleHostAccess")
|
|
385
|
-
def multiple_host_access(self) -> Optional[pulumi.Input[bool]]:
|
|
390
|
+
def multiple_host_access(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
386
391
|
"""
|
|
387
392
|
If `true`, more than one host in the datacenter has
|
|
388
393
|
been configured with access to the datastore.
|
|
@@ -390,12 +395,12 @@ class _VmfsDatastoreState:
|
|
|
390
395
|
return pulumi.get(self, "multiple_host_access")
|
|
391
396
|
|
|
392
397
|
@multiple_host_access.setter
|
|
393
|
-
def multiple_host_access(self, value: Optional[pulumi.Input[bool]]):
|
|
398
|
+
def multiple_host_access(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
394
399
|
pulumi.set(self, "multiple_host_access", value)
|
|
395
400
|
|
|
396
|
-
@property
|
|
401
|
+
@_builtins.property
|
|
397
402
|
@pulumi.getter
|
|
398
|
-
def name(self) -> Optional[pulumi.Input[str]]:
|
|
403
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
399
404
|
"""
|
|
400
405
|
The name of the datastore. Forces a new resource if
|
|
401
406
|
changed.
|
|
@@ -403,12 +408,12 @@ class _VmfsDatastoreState:
|
|
|
403
408
|
return pulumi.get(self, "name")
|
|
404
409
|
|
|
405
410
|
@name.setter
|
|
406
|
-
def name(self, value: Optional[pulumi.Input[str]]):
|
|
411
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
407
412
|
pulumi.set(self, "name", value)
|
|
408
413
|
|
|
409
|
-
@property
|
|
414
|
+
@_builtins.property
|
|
410
415
|
@pulumi.getter
|
|
411
|
-
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
|
|
416
|
+
def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
412
417
|
"""
|
|
413
418
|
The IDs of any tags to attach to this resource.
|
|
414
419
|
|
|
@@ -418,12 +423,12 @@ class _VmfsDatastoreState:
|
|
|
418
423
|
return pulumi.get(self, "tags")
|
|
419
424
|
|
|
420
425
|
@tags.setter
|
|
421
|
-
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
|
|
426
|
+
def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
422
427
|
pulumi.set(self, "tags", value)
|
|
423
428
|
|
|
424
|
-
@property
|
|
429
|
+
@_builtins.property
|
|
425
430
|
@pulumi.getter(name="uncommittedSpace")
|
|
426
|
-
def uncommitted_space(self) -> Optional[pulumi.Input[int]]:
|
|
431
|
+
def uncommitted_space(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
427
432
|
"""
|
|
428
433
|
Total additional storage space, in megabytes,
|
|
429
434
|
potentially used by all virtual machines on this datastore.
|
|
@@ -431,63 +436,198 @@ class _VmfsDatastoreState:
|
|
|
431
436
|
return pulumi.get(self, "uncommitted_space")
|
|
432
437
|
|
|
433
438
|
@uncommitted_space.setter
|
|
434
|
-
def uncommitted_space(self, value: Optional[pulumi.Input[int]]):
|
|
439
|
+
def uncommitted_space(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
435
440
|
pulumi.set(self, "uncommitted_space", value)
|
|
436
441
|
|
|
437
|
-
@property
|
|
442
|
+
@_builtins.property
|
|
438
443
|
@pulumi.getter
|
|
439
|
-
def url(self) -> Optional[pulumi.Input[str]]:
|
|
444
|
+
def url(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
440
445
|
"""
|
|
441
446
|
The unique locator for the datastore.
|
|
442
447
|
"""
|
|
443
448
|
return pulumi.get(self, "url")
|
|
444
449
|
|
|
445
450
|
@url.setter
|
|
446
|
-
def url(self, value: Optional[pulumi.Input[str]]):
|
|
451
|
+
def url(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
447
452
|
pulumi.set(self, "url", value)
|
|
448
453
|
|
|
449
454
|
|
|
455
|
+
@pulumi.type_token("vsphere:index/vmfsDatastore:VmfsDatastore")
|
|
450
456
|
class VmfsDatastore(pulumi.CustomResource):
|
|
451
457
|
@overload
|
|
452
458
|
def __init__(__self__,
|
|
453
459
|
resource_name: str,
|
|
454
460
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
455
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
456
|
-
datastore_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
457
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
458
|
-
folder: Optional[pulumi.Input[str]] = None,
|
|
459
|
-
host_system_id: Optional[pulumi.Input[str]] = None,
|
|
460
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
461
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
461
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
462
|
+
datastore_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
463
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
464
|
+
folder: Optional[pulumi.Input[_builtins.str]] = None,
|
|
465
|
+
host_system_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
466
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
467
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
462
468
|
__props__=None):
|
|
463
469
|
"""
|
|
464
|
-
|
|
470
|
+
The `VmfsDatastore` resource can be used to create and manage VMFS
|
|
471
|
+
datastores on an ESXi host or a set of hosts. The resource supports using any
|
|
472
|
+
SCSI device that can generally be used in a datastore, such as local disks, or
|
|
473
|
+
disks presented to a host or multiple hosts over Fibre Channel or iSCSI.
|
|
474
|
+
Devices can be specified manually, or discovered using the
|
|
475
|
+
[`get_vmfs_disks`][data-source-vmfs-disks] data source.
|
|
476
|
+
|
|
477
|
+
[data-source-vmfs-disks]: /docs/providers/vsphere/d/vmfs_disks.html
|
|
478
|
+
|
|
479
|
+
## Auto-Mounting of Datastores Within vCenter
|
|
480
|
+
|
|
481
|
+
Note that the current behavior of this resource will auto-mount any created
|
|
482
|
+
datastores to any other host within vCenter that has access to the same disk.
|
|
483
|
+
|
|
484
|
+
Example: You want to create a datastore with a iSCSI LUN that is visible on 3
|
|
485
|
+
hosts in a single vSphere cluster (`esxi1`, `esxi2` and `esxi3`). When you
|
|
486
|
+
create the datastore on `esxi1`, the datastore will be automatically mounted on
|
|
487
|
+
`esxi2` and `esxi3`, without the need to configure the resource on either of
|
|
488
|
+
those two hosts.
|
|
489
|
+
|
|
490
|
+
Future versions of this resource may allow you to control the hosts that a
|
|
491
|
+
datastore is mounted to, but currently, this automatic behavior cannot be
|
|
492
|
+
changed, so keep this in mind when writing your configurations and deploying
|
|
493
|
+
your disks.
|
|
494
|
+
|
|
495
|
+
## Increasing Datastore Size
|
|
496
|
+
|
|
497
|
+
To increase the size of a datastore, you must add additional disks to the
|
|
498
|
+
`disks` attribute. Expanding the size of a datastore by increasing the size of
|
|
499
|
+
an already provisioned disk is currently not supported (but may be in future
|
|
500
|
+
versions of this resource).
|
|
501
|
+
|
|
502
|
+
> **NOTE:** You cannot decrease the size of a datastore. If the resource
|
|
503
|
+
detects disks removed from the configuration, the provider will give an error.
|
|
504
|
+
|
|
505
|
+
[cmd-taint]: /docs/commands/taint.html
|
|
506
|
+
|
|
507
|
+
## Example Usage
|
|
508
|
+
|
|
509
|
+
### Addition of local disks on a single host
|
|
510
|
+
|
|
511
|
+
The following example uses the default datacenter and default host to add a
|
|
512
|
+
datastore with local disks to a single ESXi server.
|
|
513
|
+
|
|
514
|
+
> **NOTE:** There are some situations where datastore creation will not work
|
|
515
|
+
when working through vCenter (usually when trying to create a datastore on a
|
|
516
|
+
single host with local disks). If you experience trouble creating the datastore
|
|
517
|
+
you need through vCenter, break the datastore off into a different configuration
|
|
518
|
+
and deploy it using the ESXi server as the provider endpoint, using a similar
|
|
519
|
+
configuration to what is below.
|
|
520
|
+
|
|
521
|
+
```python
|
|
522
|
+
import pulumi
|
|
523
|
+
import pulumi_vsphere as vsphere
|
|
524
|
+
|
|
525
|
+
datacenter = vsphere.get_datacenter()
|
|
526
|
+
host = vsphere.get_host(datacenter_id=datacenter.id)
|
|
527
|
+
datastore = vsphere.VmfsDatastore("datastore",
|
|
528
|
+
name="test",
|
|
529
|
+
host_system_id=esxi_host["id"],
|
|
530
|
+
disks=[
|
|
531
|
+
"mpx.vmhba1:C0:T1:L0",
|
|
532
|
+
"mpx.vmhba1:C0:T2:L0",
|
|
533
|
+
"mpx.vmhba1:C0:T2:L0",
|
|
534
|
+
])
|
|
535
|
+
```
|
|
536
|
+
|
|
537
|
+
### Auto-detection of disks via `get_vmfs_disks`
|
|
538
|
+
|
|
539
|
+
The following example makes use of the
|
|
540
|
+
`get_vmfs_disks` data source to auto-detect
|
|
541
|
+
exported iSCSI LUNS matching a certain NAA vendor ID (in this case, LUNs
|
|
542
|
+
exported from a [NetApp][ext-netapp]). These discovered disks are then loaded
|
|
543
|
+
into `VmfsDatastore`. The datastore is also placed in the
|
|
544
|
+
`datastore-folder` folder afterwards.
|
|
545
|
+
|
|
546
|
+
[ext-netapp]: https://kb.netapp.com/support/s/article/ka31A0000000rLRQAY/how-to-match-a-lun-s-naa-number-to-its-serial-number?language=en_US
|
|
547
|
+
|
|
548
|
+
```python
|
|
549
|
+
import pulumi
|
|
550
|
+
import pulumi_vsphere as vsphere
|
|
551
|
+
|
|
552
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
553
|
+
host = vsphere.get_host(name="esxi-01.example.com",
|
|
554
|
+
datacenter_id=datacenter.id)
|
|
555
|
+
available = vsphere.get_vmfs_disks(host_system_id=host.id,
|
|
556
|
+
rescan=True,
|
|
557
|
+
filter="naa.60a98000")
|
|
558
|
+
datastore = vsphere.VmfsDatastore("datastore",
|
|
559
|
+
name="test",
|
|
560
|
+
host_system_id=esxi_host["id"],
|
|
561
|
+
folder="datastore-folder",
|
|
562
|
+
disks=[available.disks])
|
|
563
|
+
```
|
|
564
|
+
|
|
565
|
+
## Import
|
|
566
|
+
|
|
567
|
+
An existing VMFS datastore can be imported into this resource
|
|
568
|
+
|
|
569
|
+
via its managed object ID, via the command below. You also need the host system
|
|
570
|
+
|
|
571
|
+
ID.
|
|
572
|
+
|
|
573
|
+
[docs-import]: https://developer.hashicorp.com/terraform/cli/import
|
|
574
|
+
|
|
575
|
+
```sh
|
|
576
|
+
$ pulumi import vsphere:index/vmfsDatastore:VmfsDatastore datastore datastore-123:host-10
|
|
577
|
+
```
|
|
578
|
+
|
|
579
|
+
You need a tool like [`govc`][ext-govc] that can display managed object IDs.
|
|
580
|
+
|
|
581
|
+
[ext-govc]: https://github.com/vmware/govmomi/tree/master/govc
|
|
582
|
+
|
|
583
|
+
In the case of govc, you can locate a managed object ID from an inventory path
|
|
584
|
+
|
|
585
|
+
by doing the following:
|
|
586
|
+
|
|
587
|
+
$ govc ls -i /dc/datastore/terraform-test
|
|
588
|
+
|
|
589
|
+
Datastore:datastore-123
|
|
590
|
+
|
|
591
|
+
To locate host IDs, it might be a good idea to supply the `-l` flag as well so
|
|
592
|
+
|
|
593
|
+
that you can line up the names with the IDs:
|
|
594
|
+
|
|
595
|
+
$ govc ls -l -i /dc/host/cluster1
|
|
596
|
+
|
|
597
|
+
ResourcePool:resgroup-10 /dc/host/cluster1/Resources
|
|
598
|
+
|
|
599
|
+
HostSystem:host-10 /dc/host/cluster1/esxi1
|
|
600
|
+
|
|
601
|
+
HostSystem:host-11 /dc/host/cluster1/esxi2
|
|
602
|
+
|
|
603
|
+
HostSystem:host-12 /dc/host/cluster1/esxi3
|
|
604
|
+
|
|
465
605
|
:param str resource_name: The name of the resource.
|
|
466
606
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
467
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
607
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
468
608
|
value string to set on datastore resource.
|
|
469
609
|
|
|
470
610
|
> **NOTE:** Custom attributes are unsupported on direct ESXi connections
|
|
471
611
|
and require vCenter.
|
|
472
|
-
:param pulumi.Input[str] datastore_cluster_id: The managed object
|
|
612
|
+
:param pulumi.Input[_builtins.str] datastore_cluster_id: The managed object
|
|
473
613
|
ID of a datastore cluster to put this datastore in.
|
|
474
614
|
Conflicts with `folder`.
|
|
475
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] disks: The disks to use with the datastore.
|
|
476
|
-
:param pulumi.Input[str] folder: The relative path to a folder to put this datastore in.
|
|
615
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disks: The disks to use with the datastore.
|
|
616
|
+
:param pulumi.Input[_builtins.str] folder: The relative path to a folder to put this datastore in.
|
|
477
617
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
478
618
|
Example: for the `dc1` datacenter, and a provided `folder` of `foo/bar`,
|
|
479
619
|
The provider will place a datastore named `test` in a datastore folder
|
|
480
620
|
located at `/dc1/datastore/foo/bar`, with the final inventory path being
|
|
481
621
|
`/dc1/datastore/foo/bar/test`. Conflicts with
|
|
482
622
|
`datastore_cluster_id`.
|
|
483
|
-
:param pulumi.Input[str] host_system_id: The managed object ID of
|
|
623
|
+
:param pulumi.Input[_builtins.str] host_system_id: The managed object ID of
|
|
484
624
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
485
625
|
only host that the datastore will be set up on - see
|
|
486
626
|
here for more info. Forces a
|
|
487
627
|
new resource if changed.
|
|
488
|
-
:param pulumi.Input[str] name: The name of the datastore. Forces a new resource if
|
|
628
|
+
:param pulumi.Input[_builtins.str] name: The name of the datastore. Forces a new resource if
|
|
489
629
|
changed.
|
|
490
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
630
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
491
631
|
|
|
492
632
|
> **NOTE:** Tagging support is unsupported on direct ESXi connections and
|
|
493
633
|
requires vCenter 6.0 or higher.
|
|
@@ -499,7 +639,141 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
499
639
|
args: VmfsDatastoreArgs,
|
|
500
640
|
opts: Optional[pulumi.ResourceOptions] = None):
|
|
501
641
|
"""
|
|
502
|
-
|
|
642
|
+
The `VmfsDatastore` resource can be used to create and manage VMFS
|
|
643
|
+
datastores on an ESXi host or a set of hosts. The resource supports using any
|
|
644
|
+
SCSI device that can generally be used in a datastore, such as local disks, or
|
|
645
|
+
disks presented to a host or multiple hosts over Fibre Channel or iSCSI.
|
|
646
|
+
Devices can be specified manually, or discovered using the
|
|
647
|
+
[`get_vmfs_disks`][data-source-vmfs-disks] data source.
|
|
648
|
+
|
|
649
|
+
[data-source-vmfs-disks]: /docs/providers/vsphere/d/vmfs_disks.html
|
|
650
|
+
|
|
651
|
+
## Auto-Mounting of Datastores Within vCenter
|
|
652
|
+
|
|
653
|
+
Note that the current behavior of this resource will auto-mount any created
|
|
654
|
+
datastores to any other host within vCenter that has access to the same disk.
|
|
655
|
+
|
|
656
|
+
Example: You want to create a datastore with a iSCSI LUN that is visible on 3
|
|
657
|
+
hosts in a single vSphere cluster (`esxi1`, `esxi2` and `esxi3`). When you
|
|
658
|
+
create the datastore on `esxi1`, the datastore will be automatically mounted on
|
|
659
|
+
`esxi2` and `esxi3`, without the need to configure the resource on either of
|
|
660
|
+
those two hosts.
|
|
661
|
+
|
|
662
|
+
Future versions of this resource may allow you to control the hosts that a
|
|
663
|
+
datastore is mounted to, but currently, this automatic behavior cannot be
|
|
664
|
+
changed, so keep this in mind when writing your configurations and deploying
|
|
665
|
+
your disks.
|
|
666
|
+
|
|
667
|
+
## Increasing Datastore Size
|
|
668
|
+
|
|
669
|
+
To increase the size of a datastore, you must add additional disks to the
|
|
670
|
+
`disks` attribute. Expanding the size of a datastore by increasing the size of
|
|
671
|
+
an already provisioned disk is currently not supported (but may be in future
|
|
672
|
+
versions of this resource).
|
|
673
|
+
|
|
674
|
+
> **NOTE:** You cannot decrease the size of a datastore. If the resource
|
|
675
|
+
detects disks removed from the configuration, the provider will give an error.
|
|
676
|
+
|
|
677
|
+
[cmd-taint]: /docs/commands/taint.html
|
|
678
|
+
|
|
679
|
+
## Example Usage
|
|
680
|
+
|
|
681
|
+
### Addition of local disks on a single host
|
|
682
|
+
|
|
683
|
+
The following example uses the default datacenter and default host to add a
|
|
684
|
+
datastore with local disks to a single ESXi server.
|
|
685
|
+
|
|
686
|
+
> **NOTE:** There are some situations where datastore creation will not work
|
|
687
|
+
when working through vCenter (usually when trying to create a datastore on a
|
|
688
|
+
single host with local disks). If you experience trouble creating the datastore
|
|
689
|
+
you need through vCenter, break the datastore off into a different configuration
|
|
690
|
+
and deploy it using the ESXi server as the provider endpoint, using a similar
|
|
691
|
+
configuration to what is below.
|
|
692
|
+
|
|
693
|
+
```python
|
|
694
|
+
import pulumi
|
|
695
|
+
import pulumi_vsphere as vsphere
|
|
696
|
+
|
|
697
|
+
datacenter = vsphere.get_datacenter()
|
|
698
|
+
host = vsphere.get_host(datacenter_id=datacenter.id)
|
|
699
|
+
datastore = vsphere.VmfsDatastore("datastore",
|
|
700
|
+
name="test",
|
|
701
|
+
host_system_id=esxi_host["id"],
|
|
702
|
+
disks=[
|
|
703
|
+
"mpx.vmhba1:C0:T1:L0",
|
|
704
|
+
"mpx.vmhba1:C0:T2:L0",
|
|
705
|
+
"mpx.vmhba1:C0:T2:L0",
|
|
706
|
+
])
|
|
707
|
+
```
|
|
708
|
+
|
|
709
|
+
### Auto-detection of disks via `get_vmfs_disks`
|
|
710
|
+
|
|
711
|
+
The following example makes use of the
|
|
712
|
+
`get_vmfs_disks` data source to auto-detect
|
|
713
|
+
exported iSCSI LUNS matching a certain NAA vendor ID (in this case, LUNs
|
|
714
|
+
exported from a [NetApp][ext-netapp]). These discovered disks are then loaded
|
|
715
|
+
into `VmfsDatastore`. The datastore is also placed in the
|
|
716
|
+
`datastore-folder` folder afterwards.
|
|
717
|
+
|
|
718
|
+
[ext-netapp]: https://kb.netapp.com/support/s/article/ka31A0000000rLRQAY/how-to-match-a-lun-s-naa-number-to-its-serial-number?language=en_US
|
|
719
|
+
|
|
720
|
+
```python
|
|
721
|
+
import pulumi
|
|
722
|
+
import pulumi_vsphere as vsphere
|
|
723
|
+
|
|
724
|
+
datacenter = vsphere.get_datacenter(name="dc-01")
|
|
725
|
+
host = vsphere.get_host(name="esxi-01.example.com",
|
|
726
|
+
datacenter_id=datacenter.id)
|
|
727
|
+
available = vsphere.get_vmfs_disks(host_system_id=host.id,
|
|
728
|
+
rescan=True,
|
|
729
|
+
filter="naa.60a98000")
|
|
730
|
+
datastore = vsphere.VmfsDatastore("datastore",
|
|
731
|
+
name="test",
|
|
732
|
+
host_system_id=esxi_host["id"],
|
|
733
|
+
folder="datastore-folder",
|
|
734
|
+
disks=[available.disks])
|
|
735
|
+
```
|
|
736
|
+
|
|
737
|
+
## Import
|
|
738
|
+
|
|
739
|
+
An existing VMFS datastore can be imported into this resource
|
|
740
|
+
|
|
741
|
+
via its managed object ID, via the command below. You also need the host system
|
|
742
|
+
|
|
743
|
+
ID.
|
|
744
|
+
|
|
745
|
+
[docs-import]: https://developer.hashicorp.com/terraform/cli/import
|
|
746
|
+
|
|
747
|
+
```sh
|
|
748
|
+
$ pulumi import vsphere:index/vmfsDatastore:VmfsDatastore datastore datastore-123:host-10
|
|
749
|
+
```
|
|
750
|
+
|
|
751
|
+
You need a tool like [`govc`][ext-govc] that can display managed object IDs.
|
|
752
|
+
|
|
753
|
+
[ext-govc]: https://github.com/vmware/govmomi/tree/master/govc
|
|
754
|
+
|
|
755
|
+
In the case of govc, you can locate a managed object ID from an inventory path
|
|
756
|
+
|
|
757
|
+
by doing the following:
|
|
758
|
+
|
|
759
|
+
$ govc ls -i /dc/datastore/terraform-test
|
|
760
|
+
|
|
761
|
+
Datastore:datastore-123
|
|
762
|
+
|
|
763
|
+
To locate host IDs, it might be a good idea to supply the `-l` flag as well so
|
|
764
|
+
|
|
765
|
+
that you can line up the names with the IDs:
|
|
766
|
+
|
|
767
|
+
$ govc ls -l -i /dc/host/cluster1
|
|
768
|
+
|
|
769
|
+
ResourcePool:resgroup-10 /dc/host/cluster1/Resources
|
|
770
|
+
|
|
771
|
+
HostSystem:host-10 /dc/host/cluster1/esxi1
|
|
772
|
+
|
|
773
|
+
HostSystem:host-11 /dc/host/cluster1/esxi2
|
|
774
|
+
|
|
775
|
+
HostSystem:host-12 /dc/host/cluster1/esxi3
|
|
776
|
+
|
|
503
777
|
:param str resource_name: The name of the resource.
|
|
504
778
|
:param VmfsDatastoreArgs args: The arguments to use to populate this resource's properties.
|
|
505
779
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
@@ -515,13 +789,13 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
515
789
|
def _internal_init(__self__,
|
|
516
790
|
resource_name: str,
|
|
517
791
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
518
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
519
|
-
datastore_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
520
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
521
|
-
folder: Optional[pulumi.Input[str]] = None,
|
|
522
|
-
host_system_id: Optional[pulumi.Input[str]] = None,
|
|
523
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
524
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
792
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
793
|
+
datastore_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
794
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
795
|
+
folder: Optional[pulumi.Input[_builtins.str]] = None,
|
|
796
|
+
host_system_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
797
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
798
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
525
799
|
__props__=None):
|
|
526
800
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
527
801
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -559,20 +833,20 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
559
833
|
def get(resource_name: str,
|
|
560
834
|
id: pulumi.Input[str],
|
|
561
835
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
562
|
-
accessible: Optional[pulumi.Input[bool]] = None,
|
|
563
|
-
capacity: Optional[pulumi.Input[int]] = None,
|
|
564
|
-
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
|
|
565
|
-
datastore_cluster_id: Optional[pulumi.Input[str]] = None,
|
|
566
|
-
disks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
567
|
-
folder: Optional[pulumi.Input[str]] = None,
|
|
568
|
-
free_space: Optional[pulumi.Input[int]] = None,
|
|
569
|
-
host_system_id: Optional[pulumi.Input[str]] = None,
|
|
570
|
-
maintenance_mode: Optional[pulumi.Input[str]] = None,
|
|
571
|
-
multiple_host_access: Optional[pulumi.Input[bool]] = None,
|
|
572
|
-
name: Optional[pulumi.Input[str]] = None,
|
|
573
|
-
tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
|
|
574
|
-
uncommitted_space: Optional[pulumi.Input[int]] = None,
|
|
575
|
-
url: Optional[pulumi.Input[str]] = None) -> 'VmfsDatastore':
|
|
836
|
+
accessible: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
837
|
+
capacity: Optional[pulumi.Input[_builtins.int]] = None,
|
|
838
|
+
custom_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
|
|
839
|
+
datastore_cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
840
|
+
disks: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
841
|
+
folder: Optional[pulumi.Input[_builtins.str]] = None,
|
|
842
|
+
free_space: Optional[pulumi.Input[_builtins.int]] = None,
|
|
843
|
+
host_system_id: Optional[pulumi.Input[_builtins.str]] = None,
|
|
844
|
+
maintenance_mode: Optional[pulumi.Input[_builtins.str]] = None,
|
|
845
|
+
multiple_host_access: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
846
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
847
|
+
tags: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
848
|
+
uncommitted_space: Optional[pulumi.Input[_builtins.int]] = None,
|
|
849
|
+
url: Optional[pulumi.Input[_builtins.str]] = None) -> 'VmfsDatastore':
|
|
576
850
|
"""
|
|
577
851
|
Get an existing VmfsDatastore resource's state with the given name, id, and optional extra
|
|
578
852
|
properties used to qualify the lookup.
|
|
@@ -580,43 +854,43 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
580
854
|
:param str resource_name: The unique name of the resulting resource.
|
|
581
855
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
582
856
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
583
|
-
:param pulumi.Input[bool] accessible: The connectivity status of the datastore. If this is `false`,
|
|
857
|
+
:param pulumi.Input[_builtins.bool] accessible: The connectivity status of the datastore. If this is `false`,
|
|
584
858
|
some other computed attributes may be out of date.
|
|
585
|
-
:param pulumi.Input[int] capacity: Maximum capacity of the datastore, in megabytes.
|
|
586
|
-
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
859
|
+
:param pulumi.Input[_builtins.int] capacity: Maximum capacity of the datastore, in megabytes.
|
|
860
|
+
:param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] custom_attributes: Map of custom attribute ids to attribute
|
|
587
861
|
value string to set on datastore resource.
|
|
588
862
|
|
|
589
863
|
> **NOTE:** Custom attributes are unsupported on direct ESXi connections
|
|
590
864
|
and require vCenter.
|
|
591
|
-
:param pulumi.Input[str] datastore_cluster_id: The managed object
|
|
865
|
+
:param pulumi.Input[_builtins.str] datastore_cluster_id: The managed object
|
|
592
866
|
ID of a datastore cluster to put this datastore in.
|
|
593
867
|
Conflicts with `folder`.
|
|
594
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] disks: The disks to use with the datastore.
|
|
595
|
-
:param pulumi.Input[str] folder: The relative path to a folder to put this datastore in.
|
|
868
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] disks: The disks to use with the datastore.
|
|
869
|
+
:param pulumi.Input[_builtins.str] folder: The relative path to a folder to put this datastore in.
|
|
596
870
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
597
871
|
Example: for the `dc1` datacenter, and a provided `folder` of `foo/bar`,
|
|
598
872
|
The provider will place a datastore named `test` in a datastore folder
|
|
599
873
|
located at `/dc1/datastore/foo/bar`, with the final inventory path being
|
|
600
874
|
`/dc1/datastore/foo/bar/test`. Conflicts with
|
|
601
875
|
`datastore_cluster_id`.
|
|
602
|
-
:param pulumi.Input[int] free_space: Available space of this datastore, in megabytes.
|
|
603
|
-
:param pulumi.Input[str] host_system_id: The managed object ID of
|
|
876
|
+
:param pulumi.Input[_builtins.int] free_space: Available space of this datastore, in megabytes.
|
|
877
|
+
:param pulumi.Input[_builtins.str] host_system_id: The managed object ID of
|
|
604
878
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
605
879
|
only host that the datastore will be set up on - see
|
|
606
880
|
here for more info. Forces a
|
|
607
881
|
new resource if changed.
|
|
608
|
-
:param pulumi.Input[str] maintenance_mode: The current maintenance mode state of the datastore.
|
|
609
|
-
:param pulumi.Input[bool] multiple_host_access: If `true`, more than one host in the datacenter has
|
|
882
|
+
:param pulumi.Input[_builtins.str] maintenance_mode: The current maintenance mode state of the datastore.
|
|
883
|
+
:param pulumi.Input[_builtins.bool] multiple_host_access: If `true`, more than one host in the datacenter has
|
|
610
884
|
been configured with access to the datastore.
|
|
611
|
-
:param pulumi.Input[str] name: The name of the datastore. Forces a new resource if
|
|
885
|
+
:param pulumi.Input[_builtins.str] name: The name of the datastore. Forces a new resource if
|
|
612
886
|
changed.
|
|
613
|
-
:param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The IDs of any tags to attach to this resource.
|
|
887
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] tags: The IDs of any tags to attach to this resource.
|
|
614
888
|
|
|
615
889
|
> **NOTE:** Tagging support is unsupported on direct ESXi connections and
|
|
616
890
|
requires vCenter 6.0 or higher.
|
|
617
|
-
:param pulumi.Input[int] uncommitted_space: Total additional storage space, in megabytes,
|
|
891
|
+
:param pulumi.Input[_builtins.int] uncommitted_space: Total additional storage space, in megabytes,
|
|
618
892
|
potentially used by all virtual machines on this datastore.
|
|
619
|
-
:param pulumi.Input[str] url: The unique locator for the datastore.
|
|
893
|
+
:param pulumi.Input[_builtins.str] url: The unique locator for the datastore.
|
|
620
894
|
"""
|
|
621
895
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
622
896
|
|
|
@@ -638,26 +912,26 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
638
912
|
__props__.__dict__["url"] = url
|
|
639
913
|
return VmfsDatastore(resource_name, opts=opts, __props__=__props__)
|
|
640
914
|
|
|
641
|
-
@property
|
|
915
|
+
@_builtins.property
|
|
642
916
|
@pulumi.getter
|
|
643
|
-
def accessible(self) -> pulumi.Output[bool]:
|
|
917
|
+
def accessible(self) -> pulumi.Output[_builtins.bool]:
|
|
644
918
|
"""
|
|
645
919
|
The connectivity status of the datastore. If this is `false`,
|
|
646
920
|
some other computed attributes may be out of date.
|
|
647
921
|
"""
|
|
648
922
|
return pulumi.get(self, "accessible")
|
|
649
923
|
|
|
650
|
-
@property
|
|
924
|
+
@_builtins.property
|
|
651
925
|
@pulumi.getter
|
|
652
|
-
def capacity(self) -> pulumi.Output[int]:
|
|
926
|
+
def capacity(self) -> pulumi.Output[_builtins.int]:
|
|
653
927
|
"""
|
|
654
928
|
Maximum capacity of the datastore, in megabytes.
|
|
655
929
|
"""
|
|
656
930
|
return pulumi.get(self, "capacity")
|
|
657
931
|
|
|
658
|
-
@property
|
|
932
|
+
@_builtins.property
|
|
659
933
|
@pulumi.getter(name="customAttributes")
|
|
660
|
-
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
|
|
934
|
+
def custom_attributes(self) -> pulumi.Output[Optional[Mapping[str, _builtins.str]]]:
|
|
661
935
|
"""
|
|
662
936
|
Map of custom attribute ids to attribute
|
|
663
937
|
value string to set on datastore resource.
|
|
@@ -667,9 +941,9 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
667
941
|
"""
|
|
668
942
|
return pulumi.get(self, "custom_attributes")
|
|
669
943
|
|
|
670
|
-
@property
|
|
944
|
+
@_builtins.property
|
|
671
945
|
@pulumi.getter(name="datastoreClusterId")
|
|
672
|
-
def datastore_cluster_id(self) -> pulumi.Output[Optional[str]]:
|
|
946
|
+
def datastore_cluster_id(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
673
947
|
"""
|
|
674
948
|
The managed object
|
|
675
949
|
ID of a datastore cluster to put this datastore in.
|
|
@@ -677,17 +951,17 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
677
951
|
"""
|
|
678
952
|
return pulumi.get(self, "datastore_cluster_id")
|
|
679
953
|
|
|
680
|
-
@property
|
|
954
|
+
@_builtins.property
|
|
681
955
|
@pulumi.getter
|
|
682
|
-
def disks(self) -> pulumi.Output[Sequence[str]]:
|
|
956
|
+
def disks(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
683
957
|
"""
|
|
684
958
|
The disks to use with the datastore.
|
|
685
959
|
"""
|
|
686
960
|
return pulumi.get(self, "disks")
|
|
687
961
|
|
|
688
|
-
@property
|
|
962
|
+
@_builtins.property
|
|
689
963
|
@pulumi.getter
|
|
690
|
-
def folder(self) -> pulumi.Output[Optional[str]]:
|
|
964
|
+
def folder(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
691
965
|
"""
|
|
692
966
|
The relative path to a folder to put this datastore in.
|
|
693
967
|
This is a path relative to the datacenter you are deploying the datastore to.
|
|
@@ -699,17 +973,17 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
699
973
|
"""
|
|
700
974
|
return pulumi.get(self, "folder")
|
|
701
975
|
|
|
702
|
-
@property
|
|
976
|
+
@_builtins.property
|
|
703
977
|
@pulumi.getter(name="freeSpace")
|
|
704
|
-
def free_space(self) -> pulumi.Output[int]:
|
|
978
|
+
def free_space(self) -> pulumi.Output[_builtins.int]:
|
|
705
979
|
"""
|
|
706
980
|
Available space of this datastore, in megabytes.
|
|
707
981
|
"""
|
|
708
982
|
return pulumi.get(self, "free_space")
|
|
709
983
|
|
|
710
|
-
@property
|
|
984
|
+
@_builtins.property
|
|
711
985
|
@pulumi.getter(name="hostSystemId")
|
|
712
|
-
def host_system_id(self) -> pulumi.Output[str]:
|
|
986
|
+
def host_system_id(self) -> pulumi.Output[_builtins.str]:
|
|
713
987
|
"""
|
|
714
988
|
The managed object ID of
|
|
715
989
|
the host to set the datastore up on. Note that this is not necessarily the
|
|
@@ -719,35 +993,35 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
719
993
|
"""
|
|
720
994
|
return pulumi.get(self, "host_system_id")
|
|
721
995
|
|
|
722
|
-
@property
|
|
996
|
+
@_builtins.property
|
|
723
997
|
@pulumi.getter(name="maintenanceMode")
|
|
724
|
-
def maintenance_mode(self) -> pulumi.Output[str]:
|
|
998
|
+
def maintenance_mode(self) -> pulumi.Output[_builtins.str]:
|
|
725
999
|
"""
|
|
726
1000
|
The current maintenance mode state of the datastore.
|
|
727
1001
|
"""
|
|
728
1002
|
return pulumi.get(self, "maintenance_mode")
|
|
729
1003
|
|
|
730
|
-
@property
|
|
1004
|
+
@_builtins.property
|
|
731
1005
|
@pulumi.getter(name="multipleHostAccess")
|
|
732
|
-
def multiple_host_access(self) -> pulumi.Output[bool]:
|
|
1006
|
+
def multiple_host_access(self) -> pulumi.Output[_builtins.bool]:
|
|
733
1007
|
"""
|
|
734
1008
|
If `true`, more than one host in the datacenter has
|
|
735
1009
|
been configured with access to the datastore.
|
|
736
1010
|
"""
|
|
737
1011
|
return pulumi.get(self, "multiple_host_access")
|
|
738
1012
|
|
|
739
|
-
@property
|
|
1013
|
+
@_builtins.property
|
|
740
1014
|
@pulumi.getter
|
|
741
|
-
def name(self) -> pulumi.Output[str]:
|
|
1015
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
742
1016
|
"""
|
|
743
1017
|
The name of the datastore. Forces a new resource if
|
|
744
1018
|
changed.
|
|
745
1019
|
"""
|
|
746
1020
|
return pulumi.get(self, "name")
|
|
747
1021
|
|
|
748
|
-
@property
|
|
1022
|
+
@_builtins.property
|
|
749
1023
|
@pulumi.getter
|
|
750
|
-
def tags(self) -> pulumi.Output[Optional[Sequence[str]]]:
|
|
1024
|
+
def tags(self) -> pulumi.Output[Optional[Sequence[_builtins.str]]]:
|
|
751
1025
|
"""
|
|
752
1026
|
The IDs of any tags to attach to this resource.
|
|
753
1027
|
|
|
@@ -756,18 +1030,18 @@ class VmfsDatastore(pulumi.CustomResource):
|
|
|
756
1030
|
"""
|
|
757
1031
|
return pulumi.get(self, "tags")
|
|
758
1032
|
|
|
759
|
-
@property
|
|
1033
|
+
@_builtins.property
|
|
760
1034
|
@pulumi.getter(name="uncommittedSpace")
|
|
761
|
-
def uncommitted_space(self) -> pulumi.Output[int]:
|
|
1035
|
+
def uncommitted_space(self) -> pulumi.Output[_builtins.int]:
|
|
762
1036
|
"""
|
|
763
1037
|
Total additional storage space, in megabytes,
|
|
764
1038
|
potentially used by all virtual machines on this datastore.
|
|
765
1039
|
"""
|
|
766
1040
|
return pulumi.get(self, "uncommitted_space")
|
|
767
1041
|
|
|
768
|
-
@property
|
|
1042
|
+
@_builtins.property
|
|
769
1043
|
@pulumi.getter
|
|
770
|
-
def url(self) -> pulumi.Output[str]:
|
|
1044
|
+
def url(self) -> pulumi.Output[_builtins.str]:
|
|
771
1045
|
"""
|
|
772
1046
|
The unique locator for the datastore.
|
|
773
1047
|
"""
|